Python 技能提升（三）

于 2024-06-02 16:56:24 发布
阅读量287 收藏 5
点赞数 6
CC 4.0 BY-SA版权
分类专栏： # Python进阶 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/code_stream/article/details/139393791

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())
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值