Python关于爬虫的异步携程

• 异步非阻塞,asyncio
• 越来越多框架都在异步->提升性能

解析:

• 协程
• asyncio模块进行

1.协程

协程不是计算机提供的,是程序员人为创造的

携程(Coroutine),也可以被称为微线程,是一种用户态上下文切换技术,起始技术通过一个线程实现代码块相互切换执行例如

def func1(): print(1) .... print(2) def func2()): print(3) .... print(4) //只有一个线程来切换协程,来回切换 func1() func2()

实现协程几种方法

• greenlet,早期模块
• yield关键字
• asyncio装饰器(python3.4以上)
• async,await关键字(python3.5以上)[推荐]

实现携程的方式

1.1 greenlet实现协程

pip install greenlt

from greenlt import greenlt
def func1():
    print(1) //输出1
    gr2.switch() //第三步切换函数
    print(2) //输出2
    gr2.switch() //
def func2()):
    print(3) //输出3
    gr1.switch()
    print(4) //
//只有一个线程来切换协程,来回切换
gr1=greenlet(func1)
gr2=greenlet(func2)
gr1.switch() //执行func1函数

二.协程的意义

在一个线程中如果遇到IO等待时间,线程不会等待,利用空闲的时候在去干点其他的事

 

3.快速上手

• 协程函数,定义函数时候async def 函数名
• 协程对象,执行协程函数()得到的协程对象

async def func():
    pass
result = func() #执行协程函数得到协程对象的时候,内部代码不会执行

如果想要运行协程函数内部代码,必须要将协程对象交给事件循环来处理

import asyncio
async def func():
    print("进入")
result = func() #执行协程函数得到协程对象的时候,内部代码不会执行

loop=asyncio.get_event_loop()
loop.run_until_comlete(result) #添加到事件循环中
asyncio.run(result) #python3.7 等价于上面两句,属于封装了

3.3 await

await+可等待的对象(协程对象,Future,Task对象->IO等待)'

示例1:

import asycion
async def func():
    print("ali")
    response = await asyncio.sleep(2) #等待 返回值的是await后面的运算结果
    print("pass",response)
asyncio.run(fun())
    

示例2:

import asyncio
# async def func():
#     print("进入")
# result = func() #执行协程函数得到协程对象的时候,内部代码不会执行
#
# loop=asyncio.get_event_loop()
# # loop.run_until_comlete(result) #添加到事件循环中
# asyncio.run(result) #python3.7 等价于上面两句,属于封装了


async def others():
    print("start")
    await asyncio.sleep(2)
    print('end')
    return '返回值'
async def func():
    print("执行代码过程")
    response= await others()
    print("IO请求结束,结果为",response)

asyncio.run(func())

示例3:

import asyncio
async def others():
    print("start")
    await asyncio.sleep(2)
    print('end')
    return '返回值'
async def func():
    print("执行代码过程")
    response= await others()
    print("IO请求结束,结果为",response)
    response2= await others()
    print("IO请求结束,结果为",response2) 
asyncio.run(func())

3.4 Task对象

在事件循环中添加多个任务

示例1:

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

示例2:

import asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return "返回值"


async def main():
    print("main开始")
    task_list=[
        asyncio.create_task(func(),name="n1"),
        asyncio.create_task(func(),name="n2")
    ]
    print("结束")
    done,pending = await asyncio.wait(task_list)
    #done返回是函数返回值,pending返回的是任务没有完成的函数
    print(done)
asyncio.run(main())

示例3:

import asyncio
async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return "返回值"


task_list=[
        func(),
        func()
]
done,pending = asyncio.run(asyncio.wait(task_list)))

3.5 Future对象

Task继承Future,Task对象内部await结果的处理基于Future对象来的

示例1:

async def main():
    loop = asyncio.get_running_loop()
    #创建一个任务(Future对象),这个任务什么都不干
    fut=loop.create_furure()
    await fut
asyncio.run(main())

3.6 concurrent.futures.Future对象