Python实用代码片段(五)

使用异步 IO（异步编程）

1. 定义异步函数

声明异步函数的方式如下：

import asyncio  
async def fetch_data():  
    print("正在获取数据...")  
    await asyncio.sleep(2)  # 模拟一个 I/O 操作  
    print("数据已获取。")

2. 运行异步函数

调用异步函数并等待它们完成的方式如下：

async def main():  
    await fetch_data()  
asyncio.run(main())

3. 等待多个协程

调用多个异步函数并等待它们全部完成的方式如下：

async def main():  
    task1 = fetch_data()  
    task2 = fetch_data()  
    await asyncio.gather(task1, task2)  
asyncio.run(main())

4. 创建任务

分发任务的方式如下：

async def main():  
    task1 = asyncio.create_task(fetch_data())  
    task2 = asyncio.create_task(fetch_data())  
    await task1  
    await task2  
asyncio.run(main())

5. 异步迭代

异步遍历的方式，允许在各个项之间留出时间给其他函数：

async def fetch_item(item):  
    await asyncio.sleep(1)  # 模拟一个 I/O 操作  
    print(f"获取到 {item}")  
async def main():  
    items = ['药水', '卷轴', '魔杖']  
    for item in items:  
        await fetch_item(item)  
asyncio.run(main())

6. 使用异步上下文管理器

确保在异步函数范围内管理资源的方式如下：

async def async_context_manager():  
    print("进入上下文")  
    await asyncio.sleep(1)  
    print("退出上下文")  
async def main():  
    async with async_context_manager():  
        print("在上下文中")  
asyncio.run(main())

7. 处理异步代码中的异常

优雅地捕获和处理异步函数中的错误的方式如下：

async def risky_spell():  
    await asyncio.sleep(1)  
    raise ValueError("咒语反噬了！")  
async def main():  
    try:  
        await risky_spell()  
    except ValueError as e:  
        print(f"捕获到错误：{e}")  
asyncio.run(main())

8. 异步生成器

创建异步生成器的方式，每个项都以自己的时间到达：

async def fetch_items():  
    items = ['水晶', '护身符', '匕首']  
    for item in items:  
        await asyncio.sleep(1)  
        yield item  
async def main():  
    async for item in fetch_items():  
        print(f"发现 {item}")  
asyncio.run(main())

9. 使用信号量

限制并发任务数量的方式如下：

async def guarded_spell(semaphore, item):  
    async with semaphore:  
        print(f"处理 {item}")  
        await asyncio.sleep(1)  
async def main():  
    semaphore = asyncio.Semaphore(2)  # 允许同时进行 2 个任务  
    await asyncio.gather(*(guarded_spell(semaphore, i) for i in range(5)))  
asyncio.run(main())

10. 事件循环

直接与异步循环交互，定制执行流程的方式如下：

async def perform_spell():  
    print("释放咒语...")  
    await asyncio.sleep(1)  
    print("咒语已释放。")  
loop = asyncio.get_event_loop()  
try:  
    loop.run_until_complete(perform_spell())  
finally:  
    loop.close()

使用网络、套接字和网络接口

1. 创建套接字

用于网络通信的套接字创建方式如下：

import socket  
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

2. 连接到远程服务器

通过套接字与远程服务器建立连接的方式如下：

s.connect(('example.com', 80))  # 连接到 example.com 的 80 端口

3. 发送数据

通过网络发送数据到已连接实体的方式如下：

s.sendall(b'你好，服务器')

4. 接收数据

从网络接收数据的方式如下：

data = s.recv(1024)  # 接收最多 1024 字节  
print('接收到', repr(data))

5. 关闭套接字

优雅地关闭套接字，切断网络连接的方式如下：

s.close()

6. 创建监听套接字

打开用于监听传入连接的套接字的方式如下：

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
serversocket.bind(('localhost', 8080))  # 绑定到本地主机的 8080 端口  
serversocket.listen()  # 监听传入连接

7. 接受连接

接受并建立网络连接的方式如下：

clientsocket, address = serversocket.accept()  
print(f"来自 {address} 的连接已建立。")

8. 非阻塞套接字操作

将套接字模式设置为非阻塞的方式如下：

s.setblocking(False)

9. 使用 UDP 套接字

用于更快但不太可靠的通信的 UDP 协议创建套接字的方式如下：

udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  
udp_socket.bind(('localhost', 8081))  # 将 UDP 套接字绑定到本地主机的 8081 端口

10. 枚举网络接口

发现机器的网络接口名称和地址的方式如下：

import socket  
import netifaces  
for interface in netifaces.interfaces():  
    addr = netifaces.ifaddresses(interface).get(netifaces.AF_INET)  
    if addr:

  
        print(f"接口: {interface}, 地址: {addr[0]['addr']}")

总结

今天总结了异步IO及网络编程相关代码片段，希望对你日常工作有所帮助。