【python】async异步编程_python async def

1.协程

协程不是计算机提供的（计算机提供线程和进程），是程序员人为创造的。
协程(Coroutine)，也可以被称为微线程，是一种用户态内的上下文切换技术，简而言之，就是通过一个线程实现代码块相互切换执行。例如:

def func1():
	print(1)
	...
	print(2)

def func2():
	print(3)
	...
	print(4) 

func1()
func2()
1
2
3
4
5
6
7
8
9
10
11
12

一般思路先执行func1，再执行func2
协程会让两个函数来回切换

实现协程方法：

• greenlet 早期模块
• yield关键字
• asyncio装饰器（python3.4引入）
• async、await关键字（python3.5）【推荐】

1.1 greenlet实现协程

pip install greenlet
1

from greenlet import greenlet


def func1():
    print(1)        # 第2步：输出1
    gr2.switch()    # 第3步：切换到func2函数
    print(2)        # 第6步：输出2
    gr2.switch()    # 第7步：切换到func2函数，从上一次执行的位置继续向后执行
    
def func2():
    print(3)        # 第4步：输出3
    gr1.switch()    # 第5步：切换到func1函数，从上一次执行的位置继续向后执行
    print(4)        # 第8步：输出4
    
gr1 = greenlet(func1)
gr2 = greenlet(func2)

gr1.switch          # 第1步：去执行func1函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.2 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
2
3
4
5
6
7
8
9
10
11
12

1.3 asyncio模块

python3.4及之后版本

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)


# 协程函数不能直接func1()执行，通过以下方式执行
# loop = asyncio.get_event_loop()
# loop.run_until_complete(func1())

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

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1.4 async&await关键字

python3.5及之后版本

import asyncio


async def func1():  # async关键字替换修饰器
    print(1)
    await asyncio.sleep(2)  # await关键字替换yield from
    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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2. 协程意义

在一个线程中如果遇到IO等待时间，线程不会一直等待，利用空闲时间做其他事情。
案例：下载三张图片（网络IO）

• 普通方式 （同步）

""" pip install requests """
import requests


def download_image(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)
if __name__ == '__main__':
    url_list = [
        'https://c-ssl.duitang.com/uploads/blog/202110/26/20211026141603_cb6eb.jpg',
        'https://c-ssl.duitang.com/uploads/blog/202110/22/20211022063257_4b93d.jpg',
        'https://c-ssl.duitang.com/uploads/blog/202109/21/20210921165524_d1074.jpg'
    ]
    for item in url_list:
        download_image(item)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 协程方式（异步）

"""
下载图片使用第三方模块aiohttp，请提前安装：pip install aiohttp
"""
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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:<
1
2
3
4
5
6
7
8
9
10
11
12
13
14