python爬虫实战之旅（ 第七章：异步爬虫（协程法））

上接： 第七章：异步爬虫（线程池法)
下接：第八章：selenium模块

支持异步的框架演变历史：
tornado、fastapl、django 3.x asgi、aiohttp

1.协程

定义：
协程不是计算机提供的，而是通过程序人为创造；即让一个线程能够在代码中游走（在流程中随意切换），使代码切换执行。

1.1 实现协程的方法

• 使用第三方模块(例如早期的greenlet模块)
• 使用yield关键字
• 使用python3.4引入的asyncio装饰器
• 使用python3.5定义的关键字async、await

1.1.1 greenlet实现协程

安装：

pip install greenlet

from greenlet import greenlet

def fun1():
    print('1')
    gr2.switch()    #切换到fun2函数
    print('2')
    gr2.switch()    #切换到fun2函数，并从上一次执行的位置后一步继续向后执行

def fun2():
    print('3')
    gr1.switch()    #切换到fun1函数，并从上一次执行的位置后一步继续向后执行
    print('4')

gr1 = greenlet(fun1)#定义一个对象
gr2 = greenlet(fun2)
gr1.switch()        #第一步：去执行fun1函数

输出（可以通过输出数字顺序看出程序执行过程中发送了跳转）：

1
3
2
4

1.1.2 yield关键字

凡是有关键字yield的函数叫做生成器函数，返回一个生成器

def func1():
    yield 1
    yield from func2()
    yield 2


def func2():
    yield 3
    yield 4


f1 = func1()

for item in f1:
    print(item)

输出：

1
3
4
2

1.1.3 asyncio

相较于上述的greenlet和yield的手动切换，asyncio是在有I/O情况时自动切换任务的。

要求python版本大于3.4

@asyncio.coroutine类似一个装饰器的作用，表示接下来的函数是一个协程函数，其作用就是不改变原来函数的代码，给它添加新的一些功能。

import asyncio

@asyncio.coroutine#类似一个装饰器的作用，表示接下来的函数是一个协程函数
def func1():
    print(1)
    yield from asyncio.sleep(2)  # 遇到 IO 耗时操作，自动化切换到 tasks 中的其他任务
    print(2)


@asyncio.coroutine
def func2():
    print(3)
    yield from asyncio.sleep(2)  # 遇到 IO 耗时操作，自动化切换到 tasks 中的其他任务
    print(4)


tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2())
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

不过输出时发出了警告：

1
3
D:/Adobe/PyCharm2017/协程/asyncio协程.py:4: DeprecationWarning: "@coroutine" decorator is deprecated since Python 3.8, use "async def" instead
  def func1():
D:/Adobe/PyCharm2017/协程/asyncio协程.py:11: DeprecationWarning: "@coroutine" decorator is deprecated since Python 3.8, use "async def" instead
  def func2():
2
4

这是因为我的python版本是3.8.5，所以相应的语句有更新，原版关键字不适应，解决方法就是使用最新的关键字async/await。

1.1.4 async & await 关键字

import asyncio

async def func1():
    print(1)
    await asyncio.sleep(2)  # 遇到 IO 耗时操作，自动化切换到 tasks 中的其他任务
    print(2)


async def func2():
    print(3)
    await asyncio.sleep(2)  # 遇到 IO 耗时操作，自动化切换到 tasks 中的其他任务
    print(4)


tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2())
]#封装作用，

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

输出情况跟上述情况的输出是一致的：

1
3
2
4

1.2 协程的意义

在一个线程中如果遇到I/O等待时间，线程不会选择等待，而是利用这段时间完成其他任务。

1.2.1 案例：下载三张图片（同步与异步的对比体会）

①普通下载方式，一个接一个

import requests

def download_imag(url):
    print("开始下载：",url)
    #发送网络请求，下载图片
    response = requests.get(url)
    print("下载完成")
    #图片保存到本地文件
    file_name = url.rsplit('_')[-1]
    with open(file_name,mode='wb') as file_object:
        file_object.write(response.content)
        time.sleep(2)
        pass
    pass

if __name__=='__main__':
    url_list=[
        'http://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg',
        'http://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJDd6800429.jpg',
        'http://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg',
    ]
   
    for item in url_list:
        download_imag(item)
        pass
    

输出可以看到是一个下载完成另一个才开始：

开始下载： http://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg
下载完成
开始下载： http://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJDd6800429.jpg
下载完成
开始下载： http://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg
下载完成

②使用async

import aiohttp
import asyncio

async def fetch(session,url):
    print("开始下载：",url)
    async with session.get(url,verify_ssl=False) as response:
        content =await response.content.read()
        file_name = url.rsplit('_')[-1]
        with open(file_name,mode='wb') as file_object:
            file_object.write(content)
            pass
    print("下载完成")
    pass

async def main():
    async with aiohttp.ClientSession() as session:
        url_list=[
            'http://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg',
            'http://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJDd6800429.jpg',
            'http://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg',
        ]
        tasks=[asyncio.create_task(fetch(session,url)) for url in url_list]
        await asyncio.wait(tasks)

if __name__=='__main__':
    asyncio.run(main())

输出可以看到下载请求几乎都是同时加载的：

开始下载： http://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg
开始下载： http://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJDd6800429.jpg
开始下载： http://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg
下载完成
下载完成
下载完成

2.使用asyncio模块进行异步编程

2.1 事件循环

理解成为一个死循环，去检测并执行某些代码，举例如下伪代码：

#伪代码
任务列表 = [任务1，任务2，任务3，……]
#每个任务都有自己对应的状态，比如待完成，已完成，等待I/O中
while True:
    可执行的任务列表和已完成的任务列表的实时更新=去任务列表中检查所有任务的状态
    for 就绪任务 in 已准备就绪的任务列表：
       执行已就绪的任务
    for 已完成的任务 in 已完成的任务列表：
       在任务列表中移除已完成的任务
    如果任务列表中的任务都已完成，则终止循环

例如在之前的async代码中就出现过下列语句：

import asyncio

#去生成或获取一个事件循环
loop = asyncio.get_event_loop()
#将任务放到‘任务列表’
loop.run_until_complete(asyncio.wait(tasks))

2.2快速上手

协程函数：定义函数时前方有“async def”；
协程对象：执行“协程函数（）”得到的协程对象；

async def func():
  print("hello world!")
  pass

result = func()

如上代码：func是一个协程函数，result是一个协程对象（注——执行协程函数创建协程对象，函数内部代码不会执行）
而如果要使得协程函数运行，必须j将协程函数当作一个任务添加到事件循环中，事件循环内部会帮助我们运行代码：

import asyncio

async def func():
  print("hello world!")
  pass

result = func()

loop = asyncio.get_event_loop()
loop.run_until_complete(result)

随着python的发展，python3.7版本之后，loop = asyncio.get_event_loop() loop.run_until_complete(result)两个语句被替代为asyncio.run（result）即可

2.3 await关键字

await+可等待的对象（协程对象、Future、Task对象—>I/O等待）
示例①：
其中response=await asncio.sleep（2）是模拟I/O等待时间，这是事件循环会切到其他任务，其他任务完成或I/O时间完成则会返回一个状态值

import asyncio

async def func():
  print("hello world!")
  response=await asyncio.sleep(2)
  print("等待结束",response)
  pass

asyncio.run(func())

示例②： 了解await的返回值

import asyncio

async def others():
  print("start")
  await asyncio.sleep(2)
  print("end")
  return 'other函数执行成功'

async def func():
  print("执行协程函数内部代码")
  #遇到I/O操作随即挂起当前协程（任务），等I/O操作完成之后再继续往下执行，当前协程挂起时，事件循环可以去执行其他协程（任务）
  response=await others()
  print("I/O请求结束，结束为：",response)

asyncio.run(func())

输出：

执行协程函数内部代码
start
end
I/O请求结束，结束为： other函数执行成功

示例③： await就是等待对象的值得到结果之后再继续向下走。

import asyncio

async def others():
  print("start")
  await asyncio.sleep(2)
  print("end")
  return 'other函数执行成功'

async def func():
  print("执行协程函数内部代码")
  #遇到I/O操作随即挂起当前协程（任务），等I/O操作完成之后再继续往下执行，当前协程挂起时，事件循环可以去执行其他协程（任务）
  response1=await others()
  print("I/O请求结束，结束为：",response1)
  response2=await others()
  print("I/O请求结束，结束为：",response2)

asyncio.run(func())

输出：

执行协程函数内部代码
start
end
I/O请求结束，结束为： other函数执行成功
start
end
I/O请求结束，结束为： other函数执行成功

2.4 Task对象

Task是在事件循环中添加多个任务的。使他们并发存在从而在遇到I/O阻塞时帮助事件循环进行任务切换。
Tasks用于并发调度协调，通过asyncio create_task（协程对象）的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除了使用asycio.creat_task（）函数以外，还可以用低层级的loop.creat_task()或ensure_future函数。不建议手动实例化Task对象。
示例①：

import asyncio

async def func():
  print("1")
  await asyncio.sleep(2)
  print("2")
  return 'func函数执行成功'

async def main():
  print("main开始")
  #创建Task对象。将当前执行func函数任务添加到事件循环。
  task1=asyncio.create_task(func())
  task2=asyncio.create_task(func())
  print("main结束")
  #当执行某协程遇到io操作时，会自动化切换执行其他任务
  #此处的await是等待对应的协程全都执行完毕并获取结果
  ret1 =await task1
  ret2 =await task2
  print(ret1,ret2)
asyncio.run(main())

输出：

main开始
main结束
1
1#可以看到task2随即执行，正是因为task1遇到了i/o请求
2
2
func函数执行成功 func函数执行成功

示例②： 对示例①代码进行简化

import asyncio


async def func():
    print("1")
    await asyncio.sleep(2)
    print("2")
    return 'func函数执行成功'


async def main():
    print("main开始")

    task_list = [
        asyncio.create_task(func(),name='task1'),
        asyncio.create_task(func(),name='task2')
    ]

    print("main结束")
    # 当执行某协程遇到io操作时，会自动化切换执行其他任务
    # 此处的await是等待对应的协程全都执行完毕并获取结果
    done, pending = await asyncio.wait(task_list, timeout=None)
    # done是一个集合，集合里面放置每个对象的返回值，timeout表示时间限制
    print(done)

asyncio.run(main())

输出：

main开始
main结束
1
1
2
2
{
     <Task finished name='task1' coro=<func() done, defined at D:/Adobe/PyCharm2017/协程/协程对象.py:4> result='func函数执行成功'>, <Task finished name='task2' coro=<func() done, defined at D:/Adobe/PyCharm2017/协程/协程对象.py:4> result='func函数执行成功'>}

2.5 asyncio.Future对象

Task继承于Future，Task对象内部await结果的处理基于Future对象来的。
示例①：

import asyncio


async def main():
    #获取当前事件循环
    loop=asyncio.get_running_loop()
    #创建一个任务（Future对象），当前这个任务什么都不干
    fut = loop.create_future()
    #等待任务最终结果（Future对象，没有结果会一直等待下去）
    await  fut
asyncio.run(main())

示例②：

import asyncio

async def set_after(fut):
    await asyncio.sleep(2)
    fut.set_result('666')

async def main():
    #获取当前事件循环
    loop=asyncio.get_running_loop()
    #创建一个任务（Future对象），当前这个任务没绑定任何行为，则这个任务会永远进行下去而不结束
    fut = loop.create_future()

    #创建一个任务（Task对象），绑定了set——after函数，函数内部在2s之后，会给fut赋值
    #即手动设置future任务的最终结果，那么fut就可以结束了
    await  loop.create_task(set_after(fut))

    #等待Future对象获取最终结果，否则一直等下去
    data=await fut
    print(data)

asyncio.run(main())

输出：

666

2.6 concurrent.Future对象

因为代码可能会存在交叉时间，例如crm项目80%都是基于协程异步编程+MySQL（不支持做异步编程）

import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutor

def func(value):
    time.sleep(1)
    print(value)
    return 123

#创建线程池,规定每个池子一次处理最多五个任务
pool = ThreadPoolExecutor(max_workers=5)

#创建进程池
#pool = ProcessPoolExecutor(max_workers=5)

for i in range(10):
    fut = pool.submit(func,i)
    print(fut)

2.7 异步迭代器

异步迭代器：
实现了__aiter__()和__anext__()方法的对象。__anext__必须返回一个awaitable对象。async for会处理异步迭代器的__anext__()方法所返回的可等待对象，直到其引发一个 StopAsynIteration异常。
异步可迭代对象：
可在async for语句中被使用的对象。必须通过它的__aiter__()返回一个asynchronous oterator.

import asyncio

class Reader(object):
    #自定义异步迭代器（同时也是异步可迭代对象）
    def __init__(self):#初始化
        self.count=0

    async def readline(self):
        #await asyncio.sleep(1)
        self.count+=1
        if self.count ==10:
            return None
        return self.count

    def __aiter__(self):
        return self
    async def __anext__(self):
        val=await self.readline()
        if val ==None:
            raise StopAsyncIteration
        return val

async def func():
    obj=Reader()
    #因为自定义异步迭代器的for循环只能定义在协程函数中
    async  for item in obj:
        print(item)

asyncio.run(func())

输出：

1
2
3
4
5
6
7
8
9

2.8 异步上下文管理器

此对象通过定义__aenter__()和__aexit__()方法来对async with语句中的环境进行控制。
代码：

import  asyncio
class AsyncContextManager:
    def __init__(self):
        self.conn = 0

    async def do_something(self):
        #异步操作数据库
        return 666
    async def __aenter__(self):
        #异步链接数据库
        self.conn=await asyncio.sleep(1)
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        #异步关闭数据库连接
        await asyncio.sleep(1)

async def func():
    async with AsyncContextManager() as f:
        result = await f.do_something()
        print(result)

asyncio.run(func())

输出：

666

2.9 uvloop

是asyncio的事件循环的替代方案。事件循环等级优先于默认的asyncio的事件循环。
安装：

pip install uvloop

代码：

import asyncio
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLooPolicy())
#编写asyncio的代码，与之前写的代码一致
#内部的事件循环自动化会变为uvloop
asyncio.run(…)

注意事项：asgi是支持异步的封装接口，其中的uvicorn内部正是使用了uvloop而变得效率高。

3.实战案例

3.1 异步redis

当a服务器想要访问b服务器的redis时，必然会涉及到请求、同意、链接、操作、断开等网络IO操作，而在这种IO阻塞时候能够让线程去完成其他任务就可以提高运行速度。
安装：

pip install aioredis

import asyncio
import aioredis

async def execute(address,password):
    print("开始执行",address)
    #网络IO操作：先去连接47.93.4.197：6379，遇到IO则自动切换任务，去连接47.93.4.198：6379
    redis = await aioredis.create_redis_pool(address,password=password)
    
    #网络IO操作，遇到IO会自动切换任务
    await  redis.hmset_dict('car',key1=1,key2=2,key3=3)
    
    #网络IO操作：遇到IO会自动切换任务
    result = await redis.hgetall('car',encoding='utf-8')
    print(result)
    
    redis.close()
    #网络IO操作：遇到IO会自动切换任务
    await redis.wait_closed()
    
    print("结束",address)
    
task_list=[
    execute('redis://47.93.4.197:6379','root!2345'),
    execute('redis://47.93.4.198:6379','root!2345')
]
asyncio.run(asyncio.wait(task_list))

5.2 异步MySQL

同理，中心思想也是在IO阻塞时去切换执行其他任务
安装：

pip insatll aioredis

示例：

import asyncio
import aiomysql

async def execute():
    #网络IO操作：连接MySQL
    conn = await aiomysql.connect(host='127.0.0.1',port=3306,user='root',password=='123',db='mysql',)
    
    #网络IO操作，创建COURSOR
    cur=await conn.coursor()
    
    #网络IO操作：执行SQL
    await cur.execute("SELECT Host,User FROM user")
    
    #网络IO操作：获取SQL结果
    result=await cur.fetchall()
    print(result)
    
    #网络IO操作：遇到IO会自动切换任务
    await cur.close()
    conn.close()
    
asyncio.run(execute())

5.3 异步爬虫

示例①：

import aiohttp
import  asyncio

async def fetch(session,url):
    print("发送请求",url)
    async with session.get(url,verify_ssl=False) as response:
        text = await response.text()
        print("得到结果：",url,len(text))
        return text
    
async def main():
    async with aiohttp.ClientSession() as session:
        url_list=[
            'https://python.org',
            'https://www.baidu.com',
            'https://www.pythonav.com'
        ]
        tasks=[asyncio.create_task(fetch(session,url))for url in url_list]
        done,pending=await asyncio.wait(tasks)
        
if __name__ =='__main__':
    asyncio.run(main())

综上总结一下就是：

协程相关概念	如下所示
even_loop	事件循环，相当于一个无限循环，我们把一些函数注册到这个事件循环上。
coroutine	协程对象，我们可以将协程对象注册到事件循环中，它会被事件循环调用，我们可以使用async
task	任务，它是对协程对象的进一步封装，包含了任务的各个状态。
future	代表将来执行货还没有执行的任务，实际上和task没有本质区别。
async	定义一个协程。
await	用来挂起阻塞方法的执行。

5.3.1 单任务示例：

import asyncio

async def request(url):
    print('正在请求的url是',url)
    print('请求成功',url)

#async修饰的函数，调用之后返回一个协程对象
c=request('www.baidu.com')

#创建一个事件循环对象
#loop=asyncio.get_event_loop()
#将协程对象注册到loop中，然后启动loop
#loop.run_until_complete(c)

#task的使用
# loop = asyncio.get_event_loop()
# #基于loop创建一个task对象
# task=loop.create_task(c)
# print(task)#状态属性中会显示待定
# loop.run_until_complete(task)
# print(task)#状态属性中会显示已完成

#future的使用(与task的区别就是不用基于事件循环loop)
# loop= asyncio.get_event_loop()
# task =asyncio.ensure_future(c)
# print(task)
# loop.run_until_complete(task)
# print(task)

def callback_func(task):
    #result返回的就是任务对象中封装的协程对象对应函数的返回值
    print(task.result())

#绑定回顾
loop= asyncio.get_event_loop()
task =asyncio.ensure_future(c)
#将回调函数绑定到任务对象中
task.add_done_callbacl(callback_func)
loop.run_until_complete(task)

输出：

正在请求的url是：www.baidu.com
请求成功，www.baidu.com
www.baidu.com

5.3.2 多任务示例

import time
import aiohttp
import asyncio


async def request(url):
    print("正在下载", url)
    #在异步协程中如果出现了同步模块相关的代码，那么就无法实现异步
    #比如使用语句：time.sleep(2)最后用时就是6s
    #挡在asyncio中遇到阻塞操作中必须进行手动挂起
    await asyncio.sleep(2)
    print('下载完毕',url)

start=time.time()
urls= [
            'www.baidu.com',
            'www.sogou.com',
            'www.goubanjia.com'
        ]
#任务列表
stasks=[]
for url in urls:
    c=request(url)
    task=asyncio.ensure_future(c)
    stasks.append(task)

loop=asyncio.get_event_loop()
#需要将任务列表封装到wait中
loop.run_until_complete(asyncio.wait(stasks))
print(time.time()-start)

输出结果：

正在下载 www.baidu.com
正在下载 www.sogou.com
正在下载 www.goubanjia.com
下载完毕 www.baidu.com
下载完毕 www.sogou.com
下载完毕 www.goubanjia.com
2.001760721206665

6.aiohttp模块引出

在编写代码时我们会发现如果仍然使用原先爬虫代码中的：response = requests.get（url=url），最后验证耗时时会与单个执行没有区别，原因是：在异步协程中如果出现了同步模块相关的代码，那么就无法实现异步操作，所以我们引入了aiohttp模块对该语句进行了改进。
安装：

pip install aiohttp

并且使用该模块中的ClientSession
代码：

import time
import aiohttp
import asyncio
import requests

async def get_pagr(url):
    async with aiohttp.ClientSession() as session:
        #get()、post()函数使用一样；
        #headers,params/data 参数对应不变
        #但是使用代理IP的关键字变为：proxy='http://ip:port'
        async with session.get(url) as response:
            #text()返回字符串形式的响应数据
            #read（）返回的二进制的响应数据
            #json（）返回的就是json对象
            #注意：在获取响应数据操作之前一定要使用await进行手动挂起
            page_text=await response.text()
            print(page_text)


start=time.time()
urls= ['需要相关服务器地址',
       'http://127.0.0.1:5000/bobo',
       'http://127.0.0.1:5000/jay'
        ]
#任务列表
stasks=[]
for url in urls:
    c=request(url)
    task=asyncio.ensure_future(c)
    stasks.append(task)

loop=asyncio.get_event_loop()
#需要将任务列表封装到wait中
loop.run_until_complete(asyncio.wait(stasks))
print(time.time()-start)