协程 - IPS99技术分享

标签：__ task 协程 func time print asyncio

一、协程

概念

协程

又称微线程(纤程)，是一种用户态的轻量级线程
子程序

在所有的语言中都是层级调用的，比如A中调用B，B在执行过程中调用C，C执行完返回，B执行完返回，最后是A执行完毕。这是通过栈实现的，一个函数就是一个执行的子程序，子程序的调用总是有一个入口、一次返回，调用的顺序是明确的
理解协程

普通理解：线程是系统级别的，它们是由操作系统调度。协程是程序级别，由程序员根据需求自己调度。我们把一个线程中的一个个函数称为子程序，那么一个子程序在执行的过程中可以中断去执行别的子程序，这就是协程。也就是说同一个线程下的一段代码1执行执行着就中断，然后去执行另一段代码2，当再次回来执行代码1时，接着从之前的中断的位置继续向下执行
优点

a、最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

b、不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
缺点

a、无法利用多核CPU，协程的本质是单个线程，它不能同时将多个CPU的多个核心使用上，失去了标准线程使用多CPU的能力。

b、进行阻塞操作(操作IO)会阻塞整个程序

二、同步与异步

1、同步与异步的概念

前言

python由于GIL（全局锁）的存在，不能发挥多核的优势，其性能一直饱受诟病。然而在IO密集型的网络编程里，异步处理比同步处理能提升成百上千倍的效率

IO密集型就是磁盘的读取数据和输出数据非常大的时候就是属于IO密集型
由于IO操作的运行时间远远大于cpu、内存运行时间，所以任务的大部分时间都是在等待IO操作完成，IO的特点是cpu消耗小，所以，IO任务越多，cpu效率越高，当然不是越多越好，有一个极限值。
同步

指完成事务的逻辑，先执行第一个事务，如果阻塞了，会一直等待，直到这个事务完成，再执行第二个事务，顺序执行
异步

是和同步相对的，异步是指在处理调用这个事务的之后，不会等待这个事务的处理结果，直接处理第二个事务去了，通过状态、通知、回调来通知调用者处理结果

2、同步与异步代码

同步

import time

def run(index):
    print("lucky is a good man", index)
    time.sleep(2)
    print("lucky is a nice man", index)

for i in range(1, 5):
    run(i)

异步

说明：后面的课程中会使用到asyncio模块，现在的目的是使同学们理解异步思想

import time
import asyncio


async def run(i):
    print("lucky is a good man", i)
    # 模拟一个耗时IO
    await asyncio.sleep(2)
    print("lucky is a nice man", i)


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    tasks = []
    t1 = time.time()

    for url in range(1, 5):
        coroutine = run(url)
        task = asyncio.ensure_future(coroutine)
        tasks.append(task)
    loop.run_until_complete(asyncio.wait(tasks))
    t2 = time.time()
    print("总耗时：%.2f" % (t2 - t1))

三、asyncio模块

1、概述

asyncio模块

是python3.4版本引入的标准库，直接内置了对异步IO的操作
编程模式

是一个消息循环，我们从asyncio模块中直接获取一个EventLoop的引用，然后把需要执行的协程扔到EventLoop中执行，就实现了异步IO
说明

到目前为止实现协程的不仅仅只有asyncio,tornado和gevent都实现了类似功能

关键字的说明

关键字	说明
event_loop	消息循环，程序开启一个无限循环，把一些函数注册到事件循环上，当满足事件发生的时候，调用相应的协程函数
coroutine	协程对象，指一个使用async关键字定义的函数，它的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环，由事件循环调用
task	任务，一个协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含了任务的各种状态
async/await	python3.5用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口

2、asyncio基本使用

定义一个协程

import asyncio
import time

# 通过async关键字定义了一个协程，协程是不能直接运行的，需要将协程放到消息循环中
async def run(x):
    print("waiting：%d"%x)
    await asyncio.sleep(x)
    print("结束run")

#得到一个协程对象
coroutine = run(2)
asyncio.run(coroutine)

等同于

import asyncio
import time

# 通过async关键字定义了一个协程，协程是不能直接运行的，需要将协程放到消息循环中
async def run(x):
    print("waiting：%d"%x)
    await asyncio.sleep(x)
    print("结束run")

#得到一个协程对象
coroutine = run(2)


# 创建一个消息循环
loop = asyncio.get_event_loop()

#将协程对象加入到消息循环
loop.run_until_complete(coroutine)

创建一个任务

import asyncio
import time

async def run(x):
    print("waiting：%d"%x)
    await asyncio.sleep(x)
    print("结束run")

coroutine = run(2)
#创建任务
task = asyncio.ensure_future(coroutine)

loop = asyncio.get_event_loop()

# 将任务加入到消息循环
loop.run_until_complete(task)

阻塞和await

async可以定义协程，使用await可以针对耗时操作进行挂起，就与生成器的yield一样，函数交出控制权。协程遇到await，消息循环会挂起该协程，执行别的协程，直到其他协程也会挂起或者执行完毕，在进行下一次执行

获取返回值

import time
import asyncio

async def run(url):
    print("开始向'%s'要数据……"%(url))
    # 向百度要数据，网络IO
    await asyncio.sleep(5)
    data = "'%s'的数据"%(url)
    print("给你数据")
    return data

# 定义一个回调函数
def call_back(future):
    print("call_back:", future.result())

coroutine = run("百度")
# 创建一个任务对象
task = asyncio.ensure_future(coroutine)

# 给任务添加回调，在任务结束后调用回调函数
task.add_done_callback(call_back)

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

3、多任务

同步

同时请求"百度", "阿里", "腾讯", "新浪"四个网站，假设响应时长均为2秒

import time

def run(url):
    print("开始向'%s'要数据……"%(url))
    # 向百度要数据，网络IO
    time.sleep(2)
    data = "'%s'的数据"%(url)
    return data

if __name__ == "__main__":
    t1 = time.time()
    for url in ["百度", "阿里", "腾讯", "新浪"]:
        print(run(url))
    t2 = time.time()
    print("总耗时：%.2f"%(t2-t1))

异步

同时请求"百度", "阿里", "腾讯", "新浪"四个网站，假设响应时长均为2秒

使用ensure_future创建多任务

import time
import asyncio

async def run(url):
    print("开始向'%s'要数据……"%(url))
    await asyncio.sleep(2)
    data = "'%s'的数据"%(url)
    return data

def call_back(future):
    print("call_back:", future.result())

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    tasks = []
    t1 = time.time()
    
    for url in ["百度", "阿里", "腾讯", "新浪"]:
        coroutine = run(url)
        task = asyncio.ensure_future(coroutine)
        task.add_done_callback(call_back)
        tasks.append(task)
        
    # 同时添加4个异步任务
    # asyncio.wait(tasks) 将任务的列表又变成 <coroutine object wait at 0x7f80f43408c0>
    loop.run_until_complete(asyncio.wait(tasks))

    t2 = time.time()
    print("总耗时：%.2f" % (t2 - t1))

封装成异步函数

import time
import asyncio


async def run(url):
    print("开始向'%s'要数据……" % (url))
    await asyncio.sleep(2)
    data = "'%s'的数据" % (url)
    return data


def call_back(future):
    print("call_back:", future.result())


async def main():
    tasks = []
    t1 = time.time()

    for url in ["百度", "阿里", "腾讯", "新浪"]:
        coroutine = run(url)
        task = asyncio.ensure_future(coroutine)
        task.add_done_callback(call_back)
        tasks.append(task)

    # 同时添加4个异步任务
    await asyncio.wait(tasks)
    t2 = time.time()
    print("总耗时：%.2f" % (t2 - t1))

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

使用loop.create_task创建多任务

import time
import asyncio


async def run(url):
    print("开始向'%s'要数据……" % (url))
    await asyncio.sleep(2)
    data = "'%s'的数据" % (url)
    return data


def call_back(future):
    print("call_back:", future.result())


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    tasks = []
    t1 = time.time()

    for url in ["百度", "阿里", "腾讯", "新浪"]:
        coroutine = run(url)
        # task = asyncio.ensure_future(coroutine)
        task = loop.create_task(coroutine)
        task.add_done_callback(call_back)
        tasks.append(task)
        # 同时添加4个异步任务
    loop.run_until_complete(asyncio.wait(tasks))

    t2 = time.time()
    print("总耗时：%.2f" % (t2 - t1))

封装成异步函数

import time
import asyncio


async def run(url):
    print("开始向'%s'要数据……" % (url))
    await asyncio.sleep(2)
    data = "'%s'的数据" % (url)
    return data


def call_back(future):
    print("call_back:", future.result())


async def main():
    tasks = []
    t1 = time.time()
    for url in ["百度", "阿里", "腾讯", "新浪"]:
        coroutine = run(url)
        task = loop.create_task(coroutine)
        task.add_done_callback(call_back)
        tasks.append(task)
    # 同时添加4个异步任务
    await asyncio.wait(tasks)
    t2 = time.time()
    print("总耗时：%.2f" % (t2 - t1))

if __name__ == "__main__":
  	# asyncio.run(main())
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

使用asyncio.create_task创建多任务

import time
import asyncio


async def run(url):
    print("开始向'%s'要数据……" % (url))
    await asyncio.sleep(2)
    data = "'%s'的数据" % (url)
    return data


def call_back(future):
    print("call_back:", future.result())


async def main():
    tasks = []
    t1 = time.time()
    for url in ["百度", "阿里", "腾讯", "新浪"]:
        coroutine = run(url)
        task = asyncio.create_task(coroutine)
        task.add_done_callback(call_back)
        tasks.append(task)
    # 同时添加4个异步任务
    await asyncio.wait(tasks)
    t2 = time.time()
    print("总耗时：%.2f" % (t2 - t1))

if __name__ == "__main__":
    # asyncio.run(main())
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

4、Task 概念及用法

Task，是 python 中与事件循环进行交互的一种主要方式。

创建 Task，意思就是把协程封装成 Task 实例，并追踪协程的运行 / 完成状态，用于未来获取协程的结果。

Task 核心作用: 在事件循环中添加多个并发任务;

具体来说，是通过 asyncio.create_task() 创建 Task，让协程对象加入时事件循环中，等待被调度执行。

注意:Python 3.7 以后的版本支持 asyncio.create_task() ，在此之前的写法为 loop.create_task() ，开发过程中需要注意代码写法对不同版本 python 的兼容性。

需要指出的是，协程封装为 Task 后不会立马启动，当某个代码 await 这个 Task 的时候才会被执行。

当多个 Task 被加入一个 task_list 的时候，添加 Task 的过程中 Task 不会执行，必须要用 await asyncio.wait() 或 await asyncio.gather() 将 Task 对象加入事件循环中异步执行。

一般在开发中，常用的写法是这样的:

-- 先创建 task_list 空列表;
-- 然后用 asyncio.create_task() 创建 Task;

-- 再把 Task 对象加入 task_list ;

-- 最后使用 await asyncio.wait 或 await asyncio.gather 将 Task 对象加入事件循环中异步执行。

注意: 创建 Task 对象时，除了可以使用 asyncio.create_task() 之外，还可以用最低层级的 loop.create_task() 或 asyncio.ensure_future() ，他们都可以用来创建 Task 对象，其中关于 ensure_future 相关内容本文接下来会一起讲。

Task 简单用法

import asyncio

async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return "test"


async def main():
    print("main start")

    # python 3.7及以上版本的写法
    task1 = asyncio.create_task(func())
    task2 = asyncio.create_task(func())

    # python3.7以前的写法
    # task1 = asyncio.ensure_future(func())
    # task2 = asyncio.ensure_future(func())
    print("main end")

    ret1 = await task1
    ret2 = await task2

    print(ret1, ret2)


# python3.7以后的写法
asyncio.run(main())

# python3.7以前的写法
# loop = asyncio.get_event_loop()
# loop.run_until_complete(main())

"""
在创建task的时候，就将创建好的task添加到了时间循环当中，所以说必须得有时间循环，才可以创建task，否则会报错
"""

task用法实例

import asyncio
import arrow

def current_time():
    '''
    获取当前时间
    :return:
    '''
    cur_time = arrow.now().to('Asia/Shanghai').format('YYYY-MM-DD HH:mm:ss')
    return cur_time


async def func(sleep_time):
    func_name_suffix = sleep_time # 使用 sleep_time (函数 I/O 等待时长)作为函数名后缀，以区分任务对象
    print(f"[{current_time()}] 执行异步函数 {func.__name__}-{func_name_suffix}")
    await asyncio.sleep(sleep_time)
    print(f"[{current_time()}]函数{func.__name__}-{func_name_suffix} 执行完毕")
    return f"【[{current_time()}] 得到函数 {func.__name__}-{func_name_suffix} 执行结果】"

async def run():
    task_list = []
    for i in range(5):
        task = asyncio.create_task(func(i))
        task_list.append(task)
    done, pending = await asyncio.wait(task_list)
    for done_task in done:
        print((f"[{current_time()}]得到执行结果 {done_task.result()}"))
def main():
    loop = asyncio.get_event_loop()
    loop.run_until_complete(run())

if __name__ == '__main__':
    main()

代码执行结果如下:

/usr/local/bin/python3.7 /Users/xialigang/PycharmProjects/爬虫/123.py
[2022-07-01 16:44:57] 执行异步函数 func-0
[2022-07-01 16:44:57] 执行异步函数 func-1
[2022-07-01 16:44:57] 执行异步函数 func-2
[2022-07-01 16:44:57] 执行异步函数 func-3
[2022-07-01 16:44:57] 执行异步函数 func-4
[2022-07-01 16:44:57]函数func-0 执行完毕
[2022-07-01 16:44:58]函数func-1 执行完毕
[2022-07-01 16:44:59]函数func-2 执行完毕
[2022-07-01 16:45:00]函数func-3 执行完毕
[2022-07-01 16:45:01]函数func-4 执行完毕
[2022-07-01 16:45:01]得到执行结果 【[2022-07-01 16:44:59] 得到函数 func-2 执行结果】
[2022-07-01 16:45:01]得到执行结果 【[2022-07-01 16:44:57] 得到函数 func-0 执行结果】
[2022-07-01 16:45:01]得到执行结果 【[2022-07-01 16:45:00] 得到函数 func-3 执行结果】
[2022-07-01 16:45:01]得到执行结果 【[2022-07-01 16:44:58] 得到函数 func-1 执行结果】
[2022-07-01 16:45:01]得到执行结果 【[2022-07-01 16:45:01] 得到函数 func-4 执行结果】

Process finished with exit code 0

5、协程嵌套与返回值

使用async可以定义协程，协程用于耗时的io操作，我们也可以封装更多的io操作过程，这样就实现了嵌套的协程，即一个协程中await了另外一个协程，如此连接起来

import time
import asyncio

async def run(url):
    print("开始向'%s'要数据……"%(url))
    await asyncio.sleep(2)
    data = "'%s'的数据"%(url)
    return data

def call_back(future):
    print("call_back:", future.result())

async def main():
    tasks = []
    for url in ["百度", "阿里", "腾讯", "新浪"]:
        coroutine = run(url)
        task = asyncio.ensure_future(coroutine)
        # task.add_done_callback(call_back)
        tasks.append(task)

    # #1、可以没有回调函数
    # dones, pendings = await asyncio.wait(tasks)
    # #处理数据，类似回调，建议使用回调
    # for t in dones:
    #     print("数据：%s"%(t.result()))

    # #2、可以没有回调函数
    # results = await asyncio.gather(*tasks)
    # # 处理数据，类似回调，建议使用回调
    # for result in results:
    #     print("数据：%s"%(result))


    # 3、有无回调函数均可以
    # return await asyncio.wait(tasks)


    # 4、有无回调函数均可以
    # return await asyncio.gather(*tasks)



if __name__ == "__main__":
    t1 = time.time()
    loop = asyncio.get_event_loop()
    #1、
    # loop.run_until_complete(main())
    # asyncio.run(main()) # 等同于上面两行代码

    #2、
    # loop.run_until_complete(main())

    # # 3、
    # dones, pendings = loop.run_until_complete(main())
    # #处理数据，类似回调，建议使用回调
    # for t in dones:
    #     print("数据：%s"%(t.result()))

    # 4、
    # results = loop.run_until_complete(main())
    # for result in results:
    #     print("数据：%s"%(result))

    t2 = time.time()
    print("总耗时：%.2f" % (t2 - t1))

asyncio.wait和asyncio.gather的异同

异同点综述

相同:从功能上看， asyncio.wait 和 asyncio.gather 实现的效果是相同的，都是把所有 Task 任务结果收集起来。

不同: asyncio.wait 会返回两个值: done 和 pending ， done 为已完成的协程 Task ， pending 为超时未完成的协程 Task ，需通过 future.result 调用 Task 的 result ;而 asyncio.gather 返回的是所有已完成 Task 的 result ，不需要再进行调用或其他操作，就可以得到全部结果。

asyncio.wait 用法:

最常见的写法是: await asyncio.wait(task_list) 。

import asyncio
import arrow

def current_time():
    '''
    获取当前时间
    :return:
     '''
    cur_time = arrow.now().to('Asia/Shanghai').format('YYYY-MM-DD HH:mm:ss')
    return cur_time

async def func(sleep_time):
    func_name_suffix = sleep_time # 使用 sleep_time (函数 I/O 等待时长)作为函数名后缀，以区分任务对象
    print(f"[{current_time()}] 执行异步函数 {func.__name__}-{func_name_suffix}")
    await asyncio.sleep(sleep_time)
    print(f"[{current_time()}]函数{func.__name__}-{func_name_suffix} 执行完毕")
    return f"【[{current_time()}] 得到函数 {func.__name__}-{func_name_suffix} 执行结果】"

async def run():
    task_list = []
    for i in range(5):
        task = asyncio.create_task(func(i))
        task_list.append(task)

    done, pending = await asyncio.wait(task_list)
    for done_task in done:
        print((f"[{current_time()}]得到执行结果 {done_task.result()}"))

def main():
    loop = asyncio.get_event_loop()
    loop.run_until_complete(run())

if __name__ == '__main__':
    main()

代码执行结果如下:

/usr/local/bin/python3.7 /Users/xialigang/PycharmProjects/爬虫/123.py
[2022-07-04 15:31:47] 执行异步函数 func-0
[2022-07-04 15:31:47] 执行异步函数 func-1
[2022-07-04 15:31:47] 执行异步函数 func-2
[2022-07-04 15:31:47] 执行异步函数 func-3
[2022-07-04 15:31:47] 执行异步函数 func-4
[2022-07-04 15:31:47]函数func-0 执行完毕
[2022-07-04 15:31:48]函数func-1 执行完毕
[2022-07-04 15:31:49]函数func-2 执行完毕
[2022-07-04 15:31:50]函数func-3 执行完毕
[2022-07-04 15:31:51]函数func-4 执行完毕
[2022-07-04 15:31:51]得到执行结果 【[2022-07-04 15:31:49] 得到函数 func-2 执行结果】
[2022-07-04 15:31:51]得到执行结果 【[2022-07-04 15:31:47] 得到函数 func-0 执行结果】
[2022-07-04 15:31:51]得到执行结果 【[2022-07-04 15:31:50] 得到函数 func-3 执行结果】
[2022-07-04 15:31:51]得到执行结果 【[2022-07-04 15:31:48] 得到函数 func-1 执行结果】
[2022-07-04 15:31:51]得到执行结果 【[2022-07-04 15:31:51] 得到函数 func-4 执行结果】

Process finished with exit code 0

asyncio.gather 用法:

最常见的用法是: await asyncio.gather(*task_list) ，注意这里 task_list 前面有一个 * 。

import asyncio
import arrow

def current_time():
    '''
    获取当前时间
    :return:
     '''
    cur_time = arrow.now().to('Asia/Shanghai').format('YYYY-MM-DD HH:mm:ss')
    return cur_time

async def func(sleep_time):
    func_name_suffix = sleep_time # 使用 sleep_time (函数 I/O 等待时长)作为函数名后缀，以区分任务对象
    print(f"[{current_time()}] 执行异步函数 {func.__name__}-{func_name_suffix}")
    await asyncio.sleep(sleep_time)
    print(f"[{current_time()}]函数{func.__name__}-{func_name_suffix} 执行完毕")
    return f"【[{current_time()}] 得到函数 {func.__name__}-{func_name_suffix} 执行结果】"

async def run():
    task_list = []
    for i in range(5):
        task = asyncio.create_task(func(i))
        task_list.append(task)

    results = await asyncio.gather(*task_list)
    for result in results:
        print((f"[{current_time()}]得到执行结果 {result}"))

def main():
    loop = asyncio.get_event_loop()
    loop.run_until_complete(run())

if __name__ == '__main__':
    main()

代码执行结果如下:

/usr/local/bin/python3.7 /Users/xialigang/PycharmProjects/爬虫/123.py
[2022-07-04 15:33:24] 执行异步函数 func-0
[2022-07-04 15:33:24] 执行异步函数 func-1
[2022-07-04 15:33:24] 执行异步函数 func-2
[2022-07-04 15:33:24] 执行异步函数 func-3
[2022-07-04 15:33:24] 执行异步函数 func-4
[2022-07-04 15:33:24]函数func-0 执行完毕
[2022-07-04 15:33:25]函数func-1 执行完毕
[2022-07-04 15:33:26]函数func-2 执行完毕
[2022-07-04 15:33:27]函数func-3 执行完毕
[2022-07-04 15:33:28]函数func-4 执行完毕
[2022-07-04 15:33:28]得到执行结果 【[2022-07-04 15:33:24] 得到函数 func-0 执行结果】
[2022-07-04 15:33:28]得到执行结果 【[2022-07-04 15:33:25] 得到函数 func-1 执行结果】
[2022-07-04 15:33:28]得到执行结果 【[2022-07-04 15:33:26] 得到函数 func-2 执行结果】
[2022-07-04 15:33:28]得到执行结果 【[2022-07-04 15:33:27] 得到函数 func-3 执行结果】
[2022-07-04 15:33:28]得到执行结果 【[2022-07-04 15:33:28] 得到函数 func-4 执行结果】

Process finished with exit code 0

四、aiohttp与aiofiles

1、安装与使用

pip install aiohttp

2、简单实例使用

aiohttp的自我介绍中就包含了客户端和服务器端，所以我们分别来看下客户端和服务器端的简单实例代码。

客户端：

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()


async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, "http://httpbin.org/headers")
        print(html)

asyncio.run(main())


"""输出结果：
{
  "headers": {
    "Accept": "*/*", 
    "Accept-Encoding": "gzip, deflate", 
    "Host": "httpbin.org", 
    "User-Agent": "Python/3.7 aiohttp/3.6.2"
  }
}
"""

这个代码是不是很简单，一个函数用来发起请求，另外一个函数用来下载网页。

3、入门

简单示范

首先是学习客户端，也就是用来发送http请求的用法。首先看一段代码，会在代码中讲述需要注意的地方：

import aiohttp
import asyncio

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get('http://httpbin.org/get') as resp:
            print(resp.status)
            print(await resp.text())

asyncio.run(main())

代码解释：

在网络请求中，一个请求就是一个会话，然后aiohttp使用的是ClientSession来管理会话，所以第一个重点，看一下ClientSession:

class ClientSession:
    """First-class interface for making HTTP requests."""

在源码中，这个类的注释是使用HTTP请求接口的第一个类。然后上面的代码就是实例化一个ClientSession类然后命名为session，然后用session去发送请求。这里有一个坑，那就是ClientSession.get()协程的必需参数只能是str类和yarl.URL的实例。

当然这只是get请求，其他的请求都是支持的：

session.post('http://httpbin.org/post', data='data')
session.get('http://httpbin.org/get')

4、在URL中传递参数

有时候在发起网络请求的时候需要附加一些参数到url中，这一点也是支持的。

import aiohttp
import asyncio

async def main():
    async with aiohttp.ClientSession() as session:
        params = {'key1': 'value1', 'key2': 'value2'}
        async with session.get('http://httpbin.org/get',
                               params=params) as resp:
            print(resp.url)

asyncio.run(main())

我们可以通过params参数来指定要传递的参数，

同时如果需要指定一个键对应多个值的参数，那么MultiDict就在这个时候起作用了。你可以传递两个元祖列表来作为参数：

import aiohttp
import asyncio

async def main():
    async with aiohttp.ClientSession() as session:
        params = [('key', 'value1'), ('key', 'value2')]

        async with session.get('http://httpbin.org/get',
                               params=params) as r:
            expect = 'http://httpbin.org/get?key=value2&key=value1'
            # assert str(r.url) == expect
            print(r.url)
asyncio.run(main())

5、读取响应内容

我们可以读取到服务器的响应状态和响应内容，这也是使用请求的一个很重要的部分。通过status来获取响应状态码，text()来获取到响应内容，当然也可以之计指明编码格式为你想要的编码格式：

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get('http://httpbin.org/get') as resp:
            print(resp.status)
            print(await resp.text(encoding=utf-8))
            
"""输出结果：
200
<!doctype html>
<html lang="zh-CN">
<head>
......

"""

6、非文本内容格式

对于网络请求，有时候是去访问一张图片，这种返回值是二进制的也是可以读取到的：

await resp.read()

将text()方法换成read()方法就好。

7、请求的自定义

ClientResponse（客户端响应）对象含有request_info(请求信息)，主要是url和headers信息。 raise_for_status结构体上的信息会被复制给ClientResponseError实例。

(1) 自定义Headers

有时候做请求的时候需要自定义headers，主要是为了让服务器认为我们是一个浏览器。然后就需要我们自己来定义一个headers：

headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 (KHTML, like Gecko)"
                      " Chrome/78.0.3904.108 Safari/537.36"
    }
await session.post(url, headers=headers)

(2) 如果出现ssl验证失败的处理

import aiohttp
import asyncio
from aiohttp import TCPConnector


async def main():
    async with aiohttp.ClientSession(connector=TCPConnector(ssl=False)) as session:
		pass
asyncio.run(main())

(3) 自定义cookie

发送你自己的cookies给服务器，你可以为ClientSession对象指定cookies参数:

url = 'http://httpbin.org/cookies'
cookies = {'cookies_are': 'working'}
async with ClientSession(cookies=cookies) as session:
    async with session.get(url) as resp:
        assert await resp.json() == {
           "cookies": {"cookies_are": "working"}}

(4) 使用代理

有时候在写爬虫的时候需要使用到代理，所以aiohttp也是支持使用代理的，我们可以在发起请求的时候使用代理，只需要使用关键字proxy来指明就好，但是有一个很难受的地方就是它只支持http代理，不支持HTTPS代理。使用起来大概是这样：

proxy = "http://127.0.0.1:10809
async with aiohttp.ClientSession(headers=headers) as session:
  async with session.get(url=login_url, proxy=proxy) as response:
    resu = await response.text()

使用起来大概是这样，然后代理记得改成自己的。

8、aiofiles文件读写

8.1 概述

平常使用的file操作模式为同步，并且为线程阻塞。当程序I/O并发次数高的时候，CPU被阻塞，形成闲置。

线程开启文件读取异步模式

用线程（Thread）方式来解决。硬盘缓存可以被多个线程访问，因此通过不同线程访问文件可以部分解决。但此方案涉及线程开启关闭的开销，而且不同线程间数据交互比较麻烦。

from threading import Thread
for file in list_file:
     tr = Thread(target=file.write, args=(data,))
     tr.start()

使用已编写好的第三方插件-aiofiles，支持异步模式

使用aio插件来开启文件的非阻塞异步模式。

8.2 安装方法

pip install aiofiles

这个插件的使用和python原生open 一致，而且可以支持异步迭代

8.3 实例

打开文件

import asyncio
import aiofiles

async def main():
    async with aiofiles.open('first.m3u8', mode='r') as f:
        contents = await f.read()
        print(contents)

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

迭代

import asyncio
import aiofiles

async def main():
    async with aiofiles.open('filename') as f:
        async for line in f:
            print(line)

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

9、并发控制

semaphore，控制并发

semaphore = asyncio.Semaphore(10)

class asyncio.Semaphore(value=1)
一个信号量对象。不是线程安全的。

信号量管理一个内部计数器，该计数器由每个acquire() 调用递减，并由每个release() 调用递增。计数器永远不会低于零；当 acquire() 发现它为零时，它会阻塞，等待某些任务调用 release() 。

可选的value 参数给出内部计数器的初始值(默认为1)。如果给定值小于 0，则会引发 ValueError。

在 3.10 版中更改：删除了loop范围。

使用信号量的首选方法是 async with 语句：
sem = asyncio.Semaphore(10)

# ... later
async with sem:
    # work with shared resource

这相当于：

sem = asyncio.Semaphore(10)

# ... later
await sem.acquire()
try:
    # work with shared resource
finally:
    sem.release()

实例

#!/usr/bin/python

import asyncio
import os
import aiofiles
import aiohttp
import requests
from bs4 import BeautifulSoup


def get_page_source(web):
    headers = {
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 Safari/537.36'
    }
    response = requests.get(web, headers=headers)
    response.encoding = 'utf-8'
    return response.text


def parse_page_source(html):
    book_list = []
    soup = BeautifulSoup(html, 'html.parser')
    a_list = soup.find_all('div', attrs={'class': 'mulu-list quanji'})
    for a in a_list:
        a_list = a.find_all('a')
        for href in a_list:
            chapter_url = href['href']
            book_list.append(chapter_url)
    return book_list


def get_book_name(book_page):
    book_number = book_page.split('/')[-1].split('.')[0]
    book_chapter_name = book_page.split('/')[-2]
    return book_number, book_chapter_name


async def aio_download_one(chapter_url, signal):
    number, c_name = get_book_name(chapter_url)
    for c in range(10):
        try:
            async with signal:
                async with aiohttp.ClientSession() as session:
                    async with session.get(chapter_url) as resp:
                        page_source = await resp.text()
                        soup = BeautifulSoup(page_source, 'html.parser')
                        chapter_name = soup.find('h1').text
                        p_content = soup.find('div', attrs={'class': 'neirong'}).find_all('p')
                        content = [p.text + '\n' for p in p_content]
                        chapter_content = '\n'.join(content)
                        if not os.path.exists(f'{book_name}/{c_name}'):
                            os.makedirs(f'{book_name}/{c_name}')
                        async with aiofiles.open(f'{book_name}/{c_name}/{number}_{chapter_name}.txt', mode="w",
                                                 encoding='utf-8') as f:
                            await f.write(chapter_content)
                        print(chapter_url, "下载完毕!")
                        return ""
        except Exception as e:
            print(e)
            print(chapter_url, "下载失败!, 重新下载. ")
    return chapter_url


async def aio_download(url_list):
    tasks = []
    semaphore = asyncio.Semaphore(10)
    for h in url_list:
        tasks.append(asyncio.create_task(aio_download_one(h, semaphore)))
    await asyncio.wait(tasks)


if __name__ == '__main__':
    url = 'https://www.51shucheng.net/daomu/guichuideng'
    book_name = '鬼吹灯'
    if not os.path.exists(book_name):
        os.makedirs(book_name)
    source = get_page_source(url)
    href_list = parse_page_source(source)
    loop = asyncio.get_event_loop()
    loop.run_until_complete(aio_download(href_list))
    loop.close()

标签：__,task,协程,func,time,print,asyncio
From： https://www.cnblogs.com/hanfe1/p/17132220.html

协程

一、协程

概念

二、同步与异步

1、同步与异步的概念

2、同步与异步代码

三、asyncio模块

1、概述

2、asyncio基本使用

3、多任务

4、Task 概念及用法

5、协程嵌套与返回值

四、aiohttp与aiofiles

1、安装与使用

2、简单实例使用

3、入门

4、在URL中传递参数

5、读取响应内容

6、非文本内容格式

7、请求的自定义

(1) 自定义Headers

(2) 如果出现ssl验证失败的处理

(3) 自定义cookie

(4) 使用代理

8、aiofiles文件读写

8.1 概述

8.2 安装方法

8.3 实例

9、并发控制

相关文章

赞助商

阅读排行