当前位置：首页 > article >正文

python从0快速上手（十二）高级特性2

article 2024/10/19 17:52:18

Python学习：高级特性2

在前一章中，我们探索了装饰器的魔法，生成器的懒惰，以及迭代器的耐心。现在，让我们继续我们的探险，揭开上下文管理器的神秘面纱，然后跳入并发编程的快速河流。

4. 上下文管理器

上下文管理器是一种确保代码在进入和退出特定上下文时执行某些操作的机制。它就像是你在图书馆借书时的管理员，确保你借的书在离开时被正确记录。

使用上下文管理器：
在Python中，上下文管理器通常与with语句一起使用。

with open('file.txt', 'r') as file:
    content = file.read()
    print(content)

在这个例子中，open函数返回一个文件对象，它是一个上下文管理器。with语句确保在代码块执行完毕后，文件被正确关闭。

创建自定义上下文管理器：
你可以使用__enter__和__exit__方法来创建自定义上下文管理器。

class MyContextManager:
    def __enter__(self):
        print("Entering the context.")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context.")
        if exc_type:
            print(f"An error occurred: {exc_value}")
        return False  # 重新抛出异常

# 使用自定义上下文管理器
with MyContextManager() as manager:
    print("Inside the context.")
    raise ValueError("Something went wrong!")

在这个例子中，MyContextManager是一个自定义的上下文管理器，它在进入和退出上下文时打印消息，并处理任何发生的异常。

实例：创建一个文件锁的上下文管理器

import fcntl

class FileLock:
    def __init__(self, file):
        self.file = file

    def __enter__(self):
        self.file_handle = open(self.file, 'w')
        fcntl.lockf(self.file_handle, fcntl.LOCK_EX)

    def __exit__(self, exc_type, exc_value, traceback):
        fcntl.lockf(self.file_handle, fcntl.LOCK_UN)
        self.file_handle.close()

# 使用文件锁上下文管理器
with FileLock('lockfile.txt') as lock:
    print("File is locked.")
    # 执行需要文件锁的代码

在这个例子中，FileLock是一个自定义的上下文管理器，它确保在处理文件时不会有其他进程干扰。

5. 并发编程

并发编程是一种让程序同时执行多个任务的技术。在Python中，你可以使用多线程、多进程或异步编程来实现并发。

多线程：
线程是操作系统能够进行运算调度的最小单位。Python的threading模块允许你创建和管理线程。

import threading

def print_numbers():
    for i in range(1, 6):
        print(i)

# 创建线程
thread = threading.Thread(target=print_numbers)
thread.start()  # 启动线程
thread.join()  # 等待线程结束

在这个例子中，我们创建了一个线程来执行print_numbers函数。

多进程：
进程是操作系统进行资源分配和调度的一个独立单位。Python的multiprocessing模块允许你创建和管理进程。

from multiprocessing import Process

def print_numbers():
    for i in range(1, 6):
        print(i)

# 创建进程
process = Process(target=print_numbers)
process.start()  # 启动进程
process.join()  # 等待进程结束

在这个例子中，我们创建了一个进程来执行print_numbers函数。

异步编程：
异步编程是一种通过非阻塞方式执行任务的技术。Python的asyncio模块提供了异步编程的基础设施。

import asyncio

async def print_numbers():
    for i in range(1, 6):
        print(i)
        await asyncio.sleep(1)  # 非阻塞等待

# 运行异步函数
asyncio.run(print_numbers())

在这个例子中，我们创建了一个异步函数print_numbers，它在打印每个数字之间等待一秒钟。

实例：创建一个异步Web服务器

import asyncio

async def handle_client(reader, writer):
    request = await reader.read(100)  # 读取请求
    message = 'Hello, world!'  # 响应消息
    writer.write(message.encode())  # 写入响应
    await writer.drain()  # 确保响应被发送
    writer.close()  # 关闭连接

async def main():
    server = await asyncio.start_server(
        handle_client, '127.0.0.1', 8888)
    async with server:
        await server.serve_forever()

asyncio.run(main())

在这个例子中，我们创建了一个异步Web服务器，它监听来自客户端的连接，并发送一个简单的响应。

实例：使用多线程下载文件

import threading
import requests

def download_file(url, chunk_size=1024):
    local_filename = url.split('/')[-1]
    with requests.get(url, stream=True) as r:
        with open(local_filename, 'wb') as f:
            for chunk in r.iter_content(chunk_size):
                if chunk:  # 过滤掉保持连接的新块
                    f.write(chunk)
    return local_filename

# 创建线程下载文件
thread = threading.Thread(target=download_file, args=("https://example.com/largefile.zip",))
thread.start()
thread.join()