如何提升爬虫性能相关的知识点

如何提升爬虫性能相关的知识点

　　爬虫的本质是伪造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
Host: %s
User-agent: %s

""" %(url,host,user_agent)
    # requset_headers="""POST %s HTTP/1.0
Host: %s

name=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'
':
            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()

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]

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)

以上都是底层原理，各自身怀绝技的小喽喽，将他们的绝招都偷来以后就有了下面两个强大的框架

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()

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()

终极大招

　　上面第一部分讲的是解决问题的思路，第二部分基础的原理，第三部分是两个武林高手。但是他们都不是我们在工作中会使用的方式，真正爬虫时我们会用一个专门针对爬虫封装好所有功能的绝世高手——Scrapy框架。

　　详情请见链接：http://www.cnblogs.com/zhuminghui/p/8336857.html