如何提升爬虫性能相关的知识点
爬虫的本质是伪造 socket 客户端与服务端的通信过程,如果我们有多个 url 待爬取,只用一个线程且采用串行的方式执行,那只能等待爬取一个 url 结束后才能继续下一个,这样我们就会发现效率非常低.
原因:爬虫是一项 IO 密集型任务,遇到 IO 问题就会阻塞,CPU 运行就会停滞,直到阻塞结束.那么在 CPU 等待组合结束的过程中,任务其实是呈现出卡住的状态.但是,如果在单线程下进行 N 个任务且都是纯计算的任务的话,那么该线程对 cpu 的利用率仍然会很高,所以单线程下串行多个计算密集型任务效率不会比并发低,但要是 IO 密集型任务就会显得非常低效.关于 IO 模型详见链接: http://www.cnblogs.com/linhaifeng/articles/7454717.html
提高爬虫高效率的方法就是:
同步,异步,回调机制
同步调用即提交一个任务后就在原地等待任务结束,等到拿到任务的结果后再继续下一行代码,效率低下.
示例代码:
import requests
def parse_page(res):
print('解析 %s' %(len(res)))
def get_page(url):
print('下载 %s' %url)
response=requests.get(url)
if response.status_code == 200:
return response.text
urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']
for url in urls:
res=get_page(url)
parse_page(res) #调用一个任务,就在原地等待任务结束拿到结果后才进入下一次循环
同步调用
针对上述同步调用,可在服务端开启多线程或多进程来解决,这样各自遇到 IO 阻塞都不会影响到彼此.但是这样也是存在问题的,一个服务端终究是一台电脑,受硬件限制无法做到无限制开线程或进程,在遇到同时相应成千上万的路由请求时(如 12306,学校内网抢课),这个方案会严重占用系统资源,降低响应效率,线程和进程容易进入假死状态,用户看到的就是网站卡爆了无法访问..
#IO密集型程序应该用多线程
import requests
from threading import Thread,current_thread
def parse_page(res):
print('%s 解析 %s' %(current_thread().getName(),len(res)))
def get_page(url,callback=parse_page):
print('%s 下载 %s' %(current_thread().getName(),url))
response=requests.get(url)
if response.status_code == 200:
callback(response.text)
if __name__ == '__main__':
urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']
for url in urls:
t=Thread(target=get_page,args=(url,))
t.start()
多进程或多线程
多线程示例代码
线程池或进程池 + 异步调用
使用 "线程池" 或 "连接池" 是一个解决思路."线程池" 旨在减少创建和销毁线程的频率,其维持一定合理数量的线程,并让空闲的线程重新承担新的执行任务."连接池" 维持连接的缓存池,尽量重用已有的连接,减少创建和关闭连接的频率.这两种技术都可以很好的降低系统开销,都被广泛应用很多大型系统,如 websphere,tomcat 和各种数据库等.
但是 "线程池" 和 "连接池" 技术也只是在一定程度上缓解了频繁调用 IO 接口带来的资源占用.而且,所谓 "池" 始终有其上限,当请求大大超过上限时,"池" 构成的系统对外界的响应并不比没有池的时候效果好多少.所以使用 "池" 必须考虑其面临的响应规模,并根据响应规模调整 "池" 的大小.面对大规模的服务请求,多线程模型也会遇到瓶颈,可以用非阻塞接口可以相对有效的解决这个问题.
#IO密集型程序应该用多线程,所以此时我们使用线程池
import requests
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def parse_page(res):
res=res.result()
print('%s 解析 %s' %(current_thread().getName(),len(res)))
def get_page(url):
print('%s 下载 %s' %(current_thread().getName(),url))
response=requests.get(url)
if response.status_code == 200:
return response.text
if __name__ == '__main__':
urls=['https://www.baidu.com/','http://www.sina.com.cn/','https://www.python.org']
pool=ThreadPoolExecutor(50)
# pool=ProcessPoolExecutor(50)
for url in urls:
pool.submit(get_page,url).add_done_callback(parse_page)
pool.shutdown(wait=True)
进程池或线程池:异步调用+回调机制
使用了线程池异步调用 + 回调机制的示例代码
如何提高性能
综上所述,解决 IO 阻塞问题便是提高爬虫性能的终极目标.但是 IO 是无法避免的,IO 的时间也是与电脑硬件相关的,程序根本无法做到优化.怎么办呢?解决这一问题的关键在于,我们自己从应用程序级别检测 IO 阻塞,然后在检测到 IO 阻塞发生时立刻将 CPU 切换到我们自己程序的其他任务执行,这样把我们程序的阻塞时间降到最低,处于就绪态的程序就会增多,以此来迷惑操作系统,操作系统便以为我们的程序是 IO 比较少的程序,从而会尽可能多的分配 CPU 给我们,从而达到了提升程序执行效率的目的.
asyncio 模块
在 python3.3 之后新增了 asyncio 模块,可以帮我们检测 IO(只能是网络 IO),实现应用程序级别的切换
基本使用方法:
import asyncio#222
@asyncio.coroutine
def task(task_id,senconds):
print('%s is start' %task_id)
yield from asyncio.sleep(senconds) #只能检测网络IO,检测到IO后切换到其他任务执行
print('%s is end' %task_id)
tasks=[task(task_id="任务1",senconds=3),task("任务2",2),task(task_id="任务3",senconds=1)]
loop=asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
注:asyncio 模块只能发 tcp 级别的请求,不能发 http 协议,因此,在我们需要发送 http 请求的时候,需要我们自定义 http 报头
import asyncio
import requests
import uuid
user_agent='Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.221 Safari/537.36 SE 2.X MetaSr 1.0'
def parse_page(host,res):
print('%s 解析结果 %s' %(host,len(res)))
with open('%s.html' %(uuid.uuid1()),'wb') as f:
f.write(res)
@asyncio.coroutine
def get_page(host,port=80,url='/',callback=parse_page,ssl=False):
print('下载 http://%s:%s%s' %(host,port,url))
#步骤一(IO阻塞):发起tcp链接,是阻塞操作,因此需要yield from
if ssl:
port=443
recv,send=yield from asyncio.open_connection(host=host,port=443,ssl=ssl)
# 步骤二:封装http协议的报头,因为asyncio模块只能封装并发送tcp包,因此这一步需要我们自己封装http协议的包
request_headers="""GET %s HTTP/1.0\r\nHost: %s\r\nUser-agent: %s\r\n\r\n""" %(url,host,user_agent)
# requset_headers="""POST %s HTTP/1.0\r\nHost: %s\r\n\r\nname=egon&password=123""" % (url, host,)
request_headers=request_headers.encode('utf-8')
# 步骤三(IO阻塞):发送http请求包
send.write(request_headers)
yield from send.drain()
# 步骤四(IO阻塞):接收响应头
while True:
line=yield from recv.readline()
if line == b'\r\n':
break
print('%s Response headers:%s' %(host,line))
# 步骤五(IO阻塞):接收响应体
text=yield from recv.read()
# 步骤六:执行回调函数
callback(host,text)
# 步骤七:关闭套接字
send.close() #没有recv.close()方法,因为是四次挥手断链接,双向链接的两端,一端发完数据后执行send.close()另外一端就被动地断开
if __name__ == '__main__':
tasks=[
get_page('www.baidu.com',url='/s?wd=美女',ssl=True),
get_page('www.cnblogs.com',url='/',ssl=True),
]
loop=asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
asyncio + 自定义 http 协议头
aiohttp 模块
自定义 http 报头多少有点麻烦,aiohttp 模块专门帮我们封装了 http 头,我们用 asyncio 模块和 aiohttp 模块就可以
import aiohttp
import asyncio#pip3 install aiohttp
@asyncio.coroutine
def get_page(url):
print('GET:%s' %url)
response=yield from aiohttp.request('GET',url)
data=yield from response.read()
print(url,data)
response.close()
return 1
tasks=[
get_page('https://www.python.org/doc'),
get_page('https://www.cnblogs.com/linhaifeng'),
get_page('https://www.openstack.org')
]
loop=asyncio.get_event_loop()
results=loop.run_until_complete(asyncio.gather(*tasks))
loop.close()
print('=====>',results) #[1, 1, 1]
aiohttp 模块 + asyncio 模块
import requests
import asyncio
@asyncio.coroutine
def get_page(func,*args):
print('GET:%s' %args[0])
loog=asyncio.get_event_loop()
furture=loop.run_in_executor(None,func,*args)
response=yield from furture
print(response.url,len(response.text))
return 1
tasks=[
get_page(requests.get,'https://www.python.org/doc'),
get_page(requests.get,'https://www.cnblogs.com/linhaifeng'),
get_page(requests.get,'https://www.openstack.org')
]
loop=asyncio.get_event_loop()
results=loop.run_until_complete(asyncio.gather(*tasks))
loop.close()
print('=====>',results) #[1, 1, 1]
优化代码
grequests 模块
grequests 模块是封装了协程 gevent 和 requests 模块的模块,可以利用协程来提高性能.
#pip3 install grequests
import grequests
request_list=[
grequests.get('https://wwww.xxxx.org/doc1'),
grequests.get('https://www.cnblogs.com/linhaifeng'),
grequests.get('https://www.openstack.org')
]
##### 执行并获取响应列表 #####
# response_list = grequests.map(request_list)
# print(response_list)
##### 执行并获取响应列表(处理异常) #####
def exception_handler(request, exception):
# print(request,exception)
print("%s Request failed" %request.url)
response_list = grequests.map(request_list, exception_handler=exception_handler)
print(response_list)
grequests 模块内示例代码
以上都是底层原理,各自身怀绝技的小喽喽,将他们的绝招都偷来以后就有了下面两个强大的框架
twisted 框架和 tornado 框架
用 twisted 框架和 tornado 框架会自动处理异步和回调,我们要做的就只是发起请求就好了
twisted 框架:是一个网络框架,其中封装了一个发送异步请求,检测 IO 并自动切换的小功能(人家内功深厚,绝技众多,还没用力上面的小喽喽就多倒下了)
安装:
#访问https://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted下载Twisted-17.9.0-cp36-cp36m-win_amd64.whl
#下载完后放入C盘下(哪儿都可以)
pip3 install C:\Twisted-17.9.0-cp36-cp36m-win_amd64.whl
pip3 install twisted
pip3 install pyopenssl
基本使用示例:
from twisted.web.client import getPage,defer
from twisted.internet import reactor
def all_done(arg):
# print(arg)
reactor.stop()
def callback(res):
print(res)
return 1
defer_list=[]
urls=[
'http://www.baidu.com',
'http://www.bing.com',
'https://www.python.org',
]
for url in urls:
obj=getPage(url.encode('utf=-8'),)
obj.addCallback(callback)
defer_list.append(obj)
defer.DeferredList(defer_list).addBoth(all_done)
reactor.run()
#twisted的getPage的详细用法
from twisted.internet import reactor
from twisted.web.client import getPage
import urllib.parse
def one_done(arg):
print(arg)
reactor.stop()
post_data = urllib.parse.urlencode({'check_data': 'adf')
post_data = bytes(post_data, encoding='utf8')
headers = {b'Content-Type': b'application/x-www-form-urlencoded'
response = getPage(bytes('http://dig.chouti.com/login', encoding='utf8'),
method=bytes('POST', encoding='utf8'),
postdata=post_data,
cookies={},
headers=headers)
response.addBoth(one_done)
reactor.run()
twisted 基本用法
tornado 框架:
tornado 是一个应用非常大的框架
from tornado.httpclient import AsyncHTTPClient
from tornado.httpclient import HTTPRequest
from tornado import ioloop
n=0#计数器
def handle_response(response):
global n
"""
处理返回值内容(需要维护计数器,来停止IO循环),调用 ioloop.IOLoop.current().stop()
:param response:
:return:
"""
try:
if response.error:
print("Error:", response.error)
else:
raise TypeError
print(response.body)
finally:
n-=1#完成一个任务,计数器减一
if n == 0:#任务结束,程序终止
ioloop.IOLoop.current().stop()
def func():
global n
url_list = [
'http://www.baidu.com',
'http://www.cnblogs.com',
]
for url in url_list:
print(url)
http_client = AsyncHTTPClient()
http_client.fetch(HTTPRequest(url), handle_response)
n+=1#任务数加一
ioloop.IOLoop.current().add_callback(func)
ioloop.IOLoop.current().start()
tornado 基本用法
终极大招
上面第一部分讲的是解决问题的思路,第二部分基础的原理,第三部分是两个武林高手.但是他们都不是我们在工作中会使用的方式,真正爬虫时我们会用一个专门针对爬虫封装好所有功能的绝世高手--Scrapy 框架.
详情请见链接:
来源: http://www.bubuko.com/infodetail-2472195.html