global 和 nonlocal
b = '全局变量 global variable'
def foo():
a = '局部变量 local variable'
# 在局部里面操作全局变量，需要加上声明
global b
b = b + '！！！'
print(b)
foo()
# 全局变量 global variable！！！
b = '全局变量 global variable'
def foo():
a = '局部变量 local variable'
# 在二级局部变量里面操作一级局部变量，则使用 nonlocal 进行声明
def inner_foo():
nonlocal a
a = a + '！！！'
print(a)
inner_foo()
print(a)
foo()
# 局部变量 local variable！！！
# 局部变量 local variable！！！
协程
概念
基本认识
- 协程不是计算机提供的，它由程序员认为创造
- 协程（Coroutine），也可以被称为微线程，是一种用户态内的上下文切换技术
- 简单来说，就是通过一个线程实现代码块相互切换执行
实现协程的方式
- 通过第三方模块
greenlet - yield 关键字
- asyncio 装饰器（Python 3.4）
- async、await 关键字（Python 3.5）【推荐】
实现
通过 greenlet 实现（了解）
pip install greenlet
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 函数
通过 yield 关键字（了解）
def func1():
yield 1
yield from func2()
yield 2
def func2():
yield 3
yield 4
# 调用生成器函数，返回生成器对象
obj = func1()
print(obj)
# for...in... 背后会不断调用 next(obj) 来获取 yield 产生的数据
for i in obj:
print(i)
# <generator object func1 at 0x0000025CB2A84E80>
# 1
# 3
# 4
# 2
"""
从上面的输出结果来看，我们通过 yield 实现了协程：先在func1中输出1，然后切换到func2中输出3，
接着继续输出4，最后又切换到func1中输出2
"""
通过 asyncio 模块（了解）
- 在 Python 3.4 版本中引入了
asyncio模块
import asyncio
@asyncio.coroutine
def func1():
print('正在发送请求下载图片A')
yield from asyncio.sleep(2) # 遇到IO耗时操作，自动切换到task_list中的其他任务
print('图片A下载完成')
@asyncio.coroutine
def func2():
print('正在发送请求下载图片B')
yield from asyncio.sleep(2) # 遇到IO耗时操作，自动切换到task_list中的其他任务
print('图片B下载完成')
task_list = [
asyncio.ensure_future(func1()),
asyncio.ensure_future(func2()),
]
# 创建一个事件循环对象
loop = asyncio.get_event_loop()
# 让事件循环对象，执行"任务列表"里面的任务
loop.run_until_complete(asyncio.wait(task_list))
通过 async 和 await 关键字（掌握）
- 在 Python 3.5 版本中引入了
async和await关键字
import asyncio
async def func1():
print('正在发送请求下载图片A')
await asyncio.sleep(3) # 遇到IO耗时操作，自动切换到task_list中的其他任务
print('图片A下载完成')
async def func2():
print('正在发送请求下载图片B')
await asyncio.sleep(1) # 遇到IO耗时操作，自动切换到task_list中的其他任务
print('图片B下载完成')
task_list = [
asyncio.ensure_future(func1()),
asyncio.ensure_future(func2()),
]
loop = asyncio.get_event_loop() # 创建一个事件循环对象
loop.run_until_complete(asyncio.wait(task_list)) # 让事件循环对象，执行"任务列表"里面的任务
# 在 Python 3.7 版本中，可以使用 asyncio.run() 来替代上面两行代码
# 运行结果：
# 正在发送请求下载图片A
# 正在发送请求下载图片B
# 图片B下载完成
# 图片A下载完成
协程函数与协程对象
import asyncio
import time
# 协程函数
async def func():
print('执行中...')
await asyncio.sleep(3)
print('执行完毕！')
# 协程对象
obj = func() # 注意：在创建协程对象时，函数内部代码不会执行
# 执行协程函数
# loop = asyncio.get_event_loop() # 创建一个事件循环对象
# loop.run_until_complete(obj) # 让事件循环对象做一些任务
asyncio.run(obj) # 此行代码可以替代上面两行代码
await
# await + 可等待对象（协程对象、Future对象、Task对象）
import asyncio
async def foo1():
print('开始执行 foo1 内部代码')
# 遇到IO操作时，挂起当前协程（任务），等IO操作完成之后再继续往下执行
# 当协程挂起时，事件循环可以去执行其他协程（任务）
response = await foo2()
print('IO请求结束，结果为', response)
print('结束执行 foo1 内部代码')
async def foo2():
print('Start foo2')
await asyncio.sleep(2)
print('End foo2')
return 'OK'
asyncio.run(foo1())
# 开始执行 foo1 内部代码
# Start foo2
# End foo2
# IO请求结束，结果为 OK
# 结束执行 foo1 内部代码
import asyncio
async def foo1():
print('开始执行 foo1 内部代码')
response = await foo2()
print('IO请求结束，结果为', response)
response = await foo2()
print('IO请求结束，结果为', response)
print('结束执行 foo1 内部代码')
async def foo2():
print('Start foo2')
await asyncio.sleep(2)
print('End foo2')
return 'OK'
asyncio.run(foo1())
# 开始执行 foo1 内部代码
# Start foo2
# End foo2
# IO请求结束，结果为 OK
# Start foo2
# End foo2
# IO请求结束，结果为 OK
# 结束执行 foo1 内部代码
task 对象
- 用于在事件循环中添加多个任务的
import asyncio
async def foo2(name: str):
print(f'{name}开始执行')
await asyncio.sleep(2)
print(f'{name}结束执行')
return f'{name} OK'
async def foo1():
print('foo1 开始')
# 创建task对象，将当前执行func函数任务添加到事件循环中
task1 = asyncio.create_task(foo2('task_1'))
# 创建task对象，将当前执行func函数任务添加到事件循环中
task2 = asyncio.create_task(foo2('task_2'))
response1 = await task1
print(response1)
response2 = await task2
print(response2)
print('foo1 结束')
asyncio.run(foo1()) # 通过协程函数创建一个协程对象，充当参数传入asyncio.run()函数中
# foo1 开始
# task_1开始执行
# task_2开始执行
# task_1结束执行
# task_2结束执行
# task_1 OK
# task_2 OK
# foo1 结束
import asyncio
async def foo2(name: str):
print(f'{name}开始执行')
await asyncio.sleep(2)
print(f'{name}结束执行')
return f'{name} OK'
async def foo1():
print('foo1 开始')
task_list = [
asyncio.create_task(foo2('task_1')),
asyncio.create_task(foo2('task_2')),
]
return_value, pending = await asyncio.wait(task_list, timeout=2) # 默认 timeout=None。如果超时，pending里面会有一个"待处理的任务"对象
print(return_value) # 返回一个集合
print(pending) # 返回一个集合
print('foo1 结束')
asyncio.run(foo1())
future 对象
- task 继承 future，task 对象内部 await 结果的处理基于 future 对象来的
import asyncio
async def set_after(future):
await asyncio.sleep(2)
future.set_result('666')
async def main():
# 获取当前事件循环
loop = asyncio.get_running_loop()
# 创建一个任务(future对象),这个任务什么都不干
future = loop.create_future()
# 创建一个任务(task对象),绑定了set_after函数,函数内部在2s之后,会给future赋值
# 即:手动设置future任务的最终结果,那么future就可以结束了
await loop.create_task(set_after(future))
# 等待任务最终结果,没有结果会一直等待下去
data = await future
print(data) # 666
asyncio.run(main())
异步迭代器
import asyncio
import random
class Reader(object):
"""自定义异步迭代器"""
def __init__(self):
self.count = 0
def __aiter__(self):
return self
async def readline(self):
await asyncio.sleep(random.randint(1, 5))
self.count += 1
if self.count == 100:
return None
return self.count
async def __anext__(self):
val = await self.readline()
if val is None:
raise StopAsyncIteration
return val
async def func():
obj = Reader()
async for i in obj: # 背后会不断的调用 __anext__() 方法
print(i)
asyncio.run(func())
2796
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
