这里我们通过请求网页例子来一步步理解爬虫性能
当我们有一个列表存放了一些url需要我们获取相关数据,我们首先想到的是循环
简单的循环串行
这一种方法相对来说是最慢的,因为一个一个循环,耗时是最长的,是所有的时间总和
代码如下:
1
2
3
4
5
6
7
8
9
10
11
|
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)
|
通过线程池
通过线程池的方式访问,这样整体的耗时是所有连接里耗时最久的那个,相对循环来说快了很多
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
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操作,所以这里线程池比进程池更好
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
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 )
|
进程池+回调函数
这种方式和线程+回调函数的效果是一样的,相对来说开进程比开线程浪费资源
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
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()
|
主流的单线程实现并发的几种方式
- asyncio
- gevent
- Twisted
- Tornado
下面分别是这四种代码的实现例子:
asyncio例子1:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
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\r\nHost: %s\r\n\r\n""" % (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()
|
asyncio + aiohttp 代码例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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()
|
asyncio+requests代码例子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
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()
|
gevent+requests代码例子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
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={}),
# ])
|
grequests代码例子
这个是讲requests+gevent进行了封装
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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代码例子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#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代码例子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
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()
|
以上就是Python 爬虫性能相关总结的详细内容,更多关于Python 爬虫性能的资料请关注服务器之家其它相关文章!
原文链接:https://www.cnblogs.com/zhaof/p/7171148.html