高性能爬虫

假设有3个url需要发请求。

串行

import requests

urls_list = [
    'https://www.cnblogs.com/longyunfeigu/p/9491496.html',
    'https://dig.chouti.com/',
    'https://dig.chouti.com/r/pic/hot/1'
]

for url in urls_list:
    requests.get(url)

串行肯定是最慢的，怎么改进？第一反应：开多个线程。好吧，lowB 第一反应都是这个方法

多线程

import time
from concurrent.futures import ThreadPoolExecutor
import requests

urls_list = [
    'https://www.cnblogs.com/longyunfeigu/p/9491496.html',
    'https://dig.chouti.com/',
    'https://dig.chouti.com/r/pic/hot/1'
]

start_time = time.time()
pool = ThreadPoolExecutor(3)
def task(url):
    requests.get(url)
    print('ending')

for i in urls_list:
    pool.submit(task, i)
pool.shutdown()
end_time = time.time()
print(end_time - start_time)

开多个线程虽然可以实现并发，但是开线程总归是要耗费资源的，那能不能利用一个线程帮忙提高效率呢，这就需要异步非阻塞登场了

异步非阻塞

什么是异步非阻塞？异步非阻塞就是 异步+非阻塞。异步就是回调，非阻塞指的是单个任务不等待。
在网络IO中，有两个阶段会出现"浪费时间"的情况，一个阶段是connect的时候，请求发出去等待信息回来通知这个客户端socket就绪可以发http报文信息。
另一个阶段是recv接受数据的时候（发送数据不需要等待，直接发就行）需要等待，因为服务端需通过网络把数据发送过来。非阻塞就是不再等待，connect原先需要等待是吧，ok现在我不等了，
recv需要等待是吧，ok我也不等了。不等报错咋办？报错就报错呗，大不了异常捕获就行。如果是非阻塞socket，那么3个url的请求在connect的时候都发出去了，注意，即使报错，请求也是如弦上之箭射出去了。
那么等connect成功后就应该发送数据了呀，这时候就体现出回调了，成功就回来调用一段代码。所有的抽象的话语都可以结合大致的代码来理解。以后如果遇到一些抽象话语不好理解，那么就应该用代码去理解这个抽象话语。
有了异步非阻塞的概念是，那么我们就可以利用一个线程把所有的连接都发送出去，等连接都发送出去而且任意一个connect的信息都没返回的时候，线程就只好等待了，
等有connect的信息返回表示这个客户端socket准备就绪可以发http报文了，这时候再去执行发送数据的代码。这个过程说起来简单，但有一个问题还不清晰：程序怎么知道哪个socket是就绪的？这个大致有2种解决方式：要么是通知（叫醒服务，这个更偏向底层，我们写的应用程序代码可以利用底层已经实现好的技术）；要么是用while死循环不断去检测 。python中有一些模块已经帮我们实现了异步非阻塞的功能。

twisted

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)
# 死循环，不断地处理deferred_list里的socket对象，按理说处理完成就应该自动停止了，但可能是这个框架架构设计问题，不能做到自动停止，需要手动停
reactor.run()

gevent

gevent 是基于greenlet做的，greenlet实现了协程。协程和线程不一样，协程不是真实存在的，是程序员伪造出来的具有类似于线程的切换效果。单纯的协程不能完成提高效率的方式，如greenlet需要手动切换，所以这出现了gevent。
gevent 可以在遇到IO阻塞的时候自动切换协程的运行，这样就可以提升效率。而协程切来切去的功能正好可以利用过来实现异步非阻塞

import gevent
from gevent import monkey

monkey.patch_all()
import requests

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

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

requests模块发请求，内部也是用socket，先去connect，然后发送请求，最后收到响应

asyncio

asyncio默认只支持发tcp层的报文，想要发http请求，就需要自己封装http报文

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', '/longyunfeigu/'),
    fetch_async('baidu.com', '/')
]

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

自定义IO模块

运用知识：非阻塞socket + IO多路复用

from socket import *
import select
import time

class HttpContext(object):
    def __init__(self, sock, url_dict):
        import time
        self._start_time = time.time()
        self.sock = sock
        self.port = ''
        self.host = ''
        self.method = ''
        self.data = ''
        self.path = ''
        self.content = b''
        self.text = ''
        self.timeout = 0
        self.callback = None
        self.initial(url_dict)

    def initial(self, url_dict):
        self.port = url_dict.get('port')
        self.host = url_dict.get('host')
        self.method = url_dict.get('method')
        self.data = url_dict.get('data')
        self.path = url_dict.get('path')
        self.timeout = url_dict.get('timeout', 5)
        self.callback = url_dict.get('callback')

    def connect(self):
        self.sock.connect((self.host, self.port))

    def fileno(self):
        return self.sock.fileno()

    def send_get(self):
        content = """%s %s HTTP/1.0\r\nHost: %s\r\n\r\n"""%(
            self.method.upper(), self.path, self.host)
        self.sock.sendall(bytes(content, encoding='utf8'))

    def sendall(self):
        if self.method.upper() == 'GET':
            self.send_get()
        elif self.method.upper() == 'POST':
            self.send_post()
        else:
            pass

    def send_post(self):
        content = """%s %s HTTP/1.0\r\nHost: %s\r\n\r\n%s"""%(
            self.method.upper(), self.path, self.host, self.data)
        self.sock.sendall(bytes(content, encoding='utf8'))

    def recv(self):
        import time
        while 1:
            data = self.sock.recv(8096)
            if not data:
                break
            self.content += data
            self.text += str(data, encoding='utf8')
            time.sleep(0.1)
        self.finish()

    def finish(self, msg=''):
        if msg:
            self.text = msg
            self.content = bytes(msg, encoding='utf8')
        if self.callback:
            self.callback(self.text)


class AsynchRequest(object):
    def __init__(self):
        self.conn_socket_list = []
        self.recv_socket_list = []

    def add_request(self, **url_dict):
        # 立即发起connect连接
        soc = socket(AF_INET,SOCK_STREAM)
        soc.setblocking(0)
        ctx = HttpContext(soc, url_dict)
        self.conn_socket_list.append(ctx)
        self.recv_socket_list.append(ctx)
        try:
            ctx.connect()
        except BlockingIOError as e:
            pass
            # print('request is sended')

    def check_timeout(self):
        # 检验是否超时
        ctime = time.time()
        for ctx in self.recv_socket_list:
            if ctx._start_time + ctx.timeout <= ctime:
                self.recv_socket_list.remove(ctx)
                self.conn_socket_list.remove(ctx)
                ctx.finish('connect超时')

    def run(self):
        while 1:
            #  r_list 代表socket对象是否有数据可以读， w_list代表socket是否可以写，也就是是否可以发送数据，写服务端程序一般只需要用到 r_list
            # IO多路复用监听的对象不一定是socket对象，只要对象有fileno方法都能监听，内部也是拿对象的fileno的返回值来监听
            r_list, w_list, e_list = select.select(self.conn_socket_list, self.recv_socket_list, [], 0.05)
            for w in w_list:
                w.sendall()
                self.recv_socket_list.remove(w)
            for r in r_list:
                r.recv()
                self.conn_socket_list.remove(r)
            if not self.conn_socket_list:
                break
            self.check_timeout()

def callback(response):
    print(response)

url_list = [
    {'host': 'www.baidu.com','port': 80, 'path':'/', 'name':'baidu', 'method':'GET', 'callback': callback},
    {'host': 'cn.bing.com','port': 80,'path':'/', 'name':'chouti', 'method':'GET'},
]
if __name__ == '__main__':    
    obj = AsynchRequest()
    for i in url_list:
        obj.add_request(**i)
    obj.run()

这里的自定义IO模块是站在客户端的角度来定义的，借助底层的IO多路复用来帮我们检测socket是否已经准备好(不用我们手动写死循环去检测socket对象是否已经准备好)