• 爬虫性能相关

    爬虫信息相关

    这里我们通过请求网页例子来一步步理解爬虫性能

    当我们有一个列表存放了一些url需要我们获取相关数据，我们首先想到的是循环

    简单的循环串行

    这一种方法相对来说是最慢的，因为一个一个循环，耗时是最长的，是所有的时间总和
    代码如下：

    import requests

url_list = [
    'http://www.baidu.com',
    'http://www.pythonsite.com',
    'http://www.cnblogs.com/'
]

for url in url_list:
    result = requests.get(url)
    print(result.text)

    通过线程池

    通过线程池的方式访问，这样整体的耗时是所有连接里耗时最久的那个，相对循环来说快了很多

    import requests
from concurrent.futures import ThreadPoolExecutor

def fetch_request(url):
    result = requests.get(url)
    print(result.text)

url_list = [
    'http://www.baidu.com',
    'http://www.bing.com',
    'http://www.cnblogs.com/'
]
pool = ThreadPoolExecutor(10)

for url in url_list:
    #去线程池中获取一个线程，线程去执行fetch_request方法
    pool.submit(fetch_request,url)

pool.shutdown(True)

    线程池+回调函数

    这里定义了一个回调函数callback

    from concurrent.futures import ThreadPoolExecutor
import requests


def fetch_async(url):
    response = requests.get(url)

    return response


def callback(future):
    print(future.result().text)


url_list = [
    'http://www.baidu.com',
    'http://www.bing.com',
    'http://www.cnblogs.com/'
]

pool = ThreadPoolExecutor(5)

for url in url_list:
    v = pool.submit(fetch_async,url)
    #这里调用回调函数
    v.add_done_callback(callback)

pool.shutdown()

    通过进程池

    通过进程池的方式访问，同样的也是取决于耗时最长的，但是相对于线程来说，进程需要耗费更多的资源，同时这里是访问url时IO操作，所以这里线程池比进程池更好

    import requests
from concurrent.futures import ProcessPoolExecutor

def fetch_request(url):
    result = requests.get(url)
    print(result.text)

url_list = [
    'http://www.baidu.com',
    'http://www.bing.com',
    'http://www.cnblogs.com/'
]
pool = ProcessPoolExecutor(10)

for url in url_list:
    #去进程池中获取一个线程，子进程程去执行fetch_request方法
    pool.submit(fetch_request,url)

pool.shutdown(True)

    进程池+回调函数

    这种方式和线程+回调函数的效果是一样的，相对来说开进程比开线程浪费资源

    from concurrent.futures import ProcessPoolExecutor
import requests


def fetch_async(url):
    response = requests.get(url)

    return response


def callback(future):
    print(future.result().text)


url_list = [
    'http://www.baidu.com',
    'http://www.bing.com',
    'http://www.cnblogs.com/'
]

pool = ProcessPoolExecutor(5)

for url in url_list:
    v = pool.submit(fetch_async, url)
    # 这里调用回调函数
    v.add_done_callback(callback)

pool.shutdown()

    主流的单线程实现并发的几种方式

    1. asyncio
    2. gevent
    3. Twisted
    4. Tornado

    下面分别是这四种代码的实现例子：

    asyncio例子1：

    import asyncio


@asyncio.coroutine #通过这个装饰器装饰
def func1():
    print('before...func1......')
    # 这里必须用yield from，并且这里必须是asyncio.sleep不能是time.sleep
    yield from asyncio.sleep(2)
    print('end...func1......')


tasks = [func1(), func1()]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.gather(*tasks))
loop.close()

    上述的效果是同时会打印两个before的内容，然后等待2秒打印end内容
    这里asyncio并没有提供我们发送http请求的方法，但是我们可以在yield from这里构造http请求的方法。

    asyncio例子2：

    import asyncio


@asyncio.coroutine
def fetch_async(host, url='/'):
    print("----",host, url)
    reader, writer = yield from asyncio.open_connection(host, 80)

    #构造请求头内容
    request_header_content = """GET %s HTTP/1.0
Host: %s

""" % (url, host,)
    request_header_content = bytes(request_header_content, encoding='utf-8')
    #发送请求
    writer.write(request_header_content)
    yield from writer.drain()
    text = yield from reader.read()
    print(host, url, text)
    writer.close()

tasks = [
    fetch_async('www.cnblogs.com', '/zhaof/'),
    fetch_async('dig.chouti.com', '/pic/show?nid=4073644713430508&lid=10273091')
]

loop = asyncio.get_event_loop()
results = loop.run_until_complete(asyncio.gather(*tasks))
loop.close()
    View Code

    asyncio + aiohttp 代码例子：

    import aiohttp
import asyncio


@asyncio.coroutine
def fetch_async(url):
    print(url)
    response = yield from aiohttp.request('GET', url)
    print(url, response)
    response.close()


tasks = [fetch_async('http://baidu.com/'), fetch_async('http://www.chouti.com/')]

event_loop = asyncio.get_event_loop()
results = event_loop.run_until_complete(asyncio.gather(*tasks))
event_loop.close()
    View Code

    asyncio+requests代码例子

    import asyncio
import requests


@asyncio.coroutine
def fetch_async(func, *args):
    loop = asyncio.get_event_loop()
    future = loop.run_in_executor(None, func, *args)
    response = yield from future
    print(response.url, response.content)


tasks = [
    fetch_async(requests.get, 'http://www.cnblogs.com/wupeiqi/'),
    fetch_async(requests.get, 'http://dig.chouti.com/pic/show?nid=4073644713430508&lid=10273091')
]

loop = asyncio.get_event_loop()
results = loop.run_until_complete(asyncio.gather(*tasks))
loop.close()
    View Code

    gevent+requests代码例子

    import gevent

import requests
from gevent import monkey

monkey.patch_all()


def fetch_async(method, url, req_kwargs):
    print(method, url, req_kwargs)
    response = requests.request(method=method, url=url, **req_kwargs)
    print(response.url, response.content)

# ##### 发送请求 #####
gevent.joinall([
    gevent.spawn(fetch_async, method='get', url='https://www.python.org/', req_kwargs={}),
    gevent.spawn(fetch_async, method='get', url='https://www.yahoo.com/', req_kwargs={}),
    gevent.spawn(fetch_async, method='get', url='https://github.com/', req_kwargs={}),
])

# ##### 发送请求（协程池控制最大协程数量） #####
# from gevent.pool import Pool
# pool = Pool(None)
# gevent.joinall([
#     pool.spawn(fetch_async, method='get', url='https://www.python.org/', req_kwargs={}),
#     pool.spawn(fetch_async, method='get', url='https://www.yahoo.com/', req_kwargs={}),
#     pool.spawn(fetch_async, method='get', url='https://www.github.com/', req_kwargs={}),
# ])
    View Code

    grequests代码例子
    这个是讲requests+gevent进行了封装

    import grequests


request_list = [
    grequests.get('http://httpbin.org/delay/1', timeout=0.001),
    grequests.get('http://fakedomain/'),
    grequests.get('http://httpbin.org/status/500')
]


# ##### 执行并获取响应列表 #####
# response_list = grequests.map(request_list)
# print(response_list)


# ##### 执行并获取响应列表（处理异常） #####
# def exception_handler(request, exception):
# print(request,exception)
#     print("Request failed")

# response_list = grequests.map(request_list, exception_handler=exception_handler)
# print(response_list)

    twisted代码例子

    #getPage相当于requets模块，defer特殊的返回值，rector是做事件循环
from twisted.web.client import getPage, defer
from twisted.internet import reactor

def all_done(arg):
    reactor.stop()

def callback(contents):
    print(contents)

deferred_list = []

url_list = ['http://www.bing.com', 'http://www.baidu.com', ]
for url in url_list:
    deferred = getPage(bytes(url, encoding='utf8'))
    deferred.addCallback(callback)
    deferred_list.append(deferred)
#这里就是进就行一种检测，判断所有的请求知否执行完毕
dlist = defer.DeferredList(deferred_list)
dlist.addBoth(all_done)

reactor.run()

    tornado代码例子

    from tornado.httpclient import AsyncHTTPClient
from tornado.httpclient import HTTPRequest
from tornado import ioloop


def handle_response(response):
    """
    处理返回值内容（需要维护计数器，来停止IO循环），调用 ioloop.IOLoop.current().stop()
    :param response: 
    :return: 
    """
    if response.error:
        print("Error:", response.error)
    else:
        print(response.body)


def func():
    url_list = [
        'http://www.baidu.com',
        'http://www.bing.com',
    ]
    for url in url_list:
        print(url)
        http_client = AsyncHTTPClient()
        http_client.fetch(HTTPRequest(url), handle_response)


ioloop.IOLoop.current().add_callback(func)
ioloop.IOLoop.current().start()
    View Code
  • 相关阅读:
    for memory long term update
    Tomcat 部署 Jenkins （Linux系统）
    Linux新增硬盘
    jenkins常见问题
    Linux安装JDk
    Jenkins入门(一)
    主播必备工具Bongo Cat！
    Docker常用命令
    Docker二进制部署
    golang中for语句详解
  • 原文地址：https://www.cnblogs.com/xiao-xue-di/p/10250779.html
Copyright © 2020-2023  润新知