Python 上下文管理器

最新推荐文章于 2024-04-28 19:18:17 发布

gledfish

最新推荐文章于 2024-04-28 19:18:17 发布

阅读量253

点赞数

分类专栏： Python 文章标签： python 开发语言

原文链接：https://www.pythontutorial.net/advanced-python/python-context-managers/

版权

Python 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

这篇文章翻译自https://www.pythontutorial.net/advanced-python/python-context-managers/

Python 上下文管理器

摘要：在本教程中，你将学习 Python 上下文管理器以及如何有效地使用它们

Python 上下文管理器的介绍

上下文管理器是一个在 with 语句中执行的对象，它定义了一个运行时上下文。

让我们从一个简单的例子开始来理解上下文管理器的概念。

假设你有一个名为 data.txt 的文件，其中包含一个整数 100 。

下面的程序读取 data.txt 文件，将其内容转换为数字，并将结果显示在标准输出端。

f = open('data.txt')
data = f.readlines()

# 将数字转换为整数，并展示它
print(int(data[0]))

f.close()

代码是简单而直接的。

然而， data.txt 可能包含不能被转换为数字的数据。在这种情况下，该代码将导致一个异常。

例如，如果 data.txt 包含字符串 ‘100’ 而不是数字100，你会得到以下错误。

ValueError: invalid literal for int() with base 10: '100'

因为这个异常，Python 可能无法正确关闭文件。

为了解决这个问题，你或许会使用 try…except…finally 语句。

try:
    f = open('data.txt')
    data = f.readlines()
    print(int(data[0]))

except ValueError as error:
    print(error)

finally:
    f.close()

由于 finally 块中的代码总是在执行，所以代码将总是正确地关闭文件。

这个解决方案按预期工作。然而，它是相当冗长的。

因此，Python 为你提供了一个更好的方法，允许你在完成处理后自动关闭文件。

这就是上下文管理器发挥作用的地方。

下面显示了如何使用上下文管理器来处理 data.txt 文件。

with open('data.txt') as f:
    data = f.readlines()
    print(int(data[0]))

在这个例子中，我们使用 open() 函数和 with 语句。在 with 语句结束之后，Python 将自动关闭文件。

Python with 语句

下面是 with 语句的典型语法：

with context as ctx：
    # use the object
    
# context is cleaned up

它是如何工作的。

当 Python 遇到 with 语句时，它会创建一个新的上下文对象。上下文可以选择性地返回一个 object 。
在 with 块之后，Python 会自动清理上下文。
ctx 和 with 语句具有相同的作用域。这意味着你可以在 with 语句内部或之后访问</font color=red> ctx 。

下面展示了如何在 with 语句后访问 f 变量

with open('data.txt') as f:
    data = f.readlines()
    print(int(data[0]))


print(f.closed)  # True

Python 上下文管理器协议

Python 上下文管理器是基于上下文管理器协议工作的。

上下文管理器协议有以下方法。

__enter__() - 设置上下文，可选择返回一些对象。
__exit__() - 清理该对象。

如果你想让一个类支持上下文管理器协议，你需要实现这两个方法。

假设 ContextManager 是一个支持上下文管理器协议的类。

下面展示了如何使用 ContextManager 类：

with ContextManager() as ctx:
    # do something

# done with the context

当你在 with 语句中使用 ContextManager 类时，Python 隐含地创建了一个 ContextManager 类的实例 ( instance ) 并自动在该实例上调用 __enter__() 方法。

__enter__() 方法可以选择性地返回一个对象。如果是这样的话，Python 会将返回的对象分配给 ctx .

注意， ctx 引用了由 __enter__() 方法返回的对象。它并没有引用 ContextManager 类的实例。

如果一个异常发生在 with 块内或 with 块之后，Python会调用 instance 对象上的 exit() 方法。

在功能上， with 语句等同于下面的 try…finally 语句。


instance = ContextManager()
ctx = instance.__enter__()

try:
    # do something with the text
finally:
    # do with the context
    instance.__exit__()

`enter()`方法

在 __enter__() 方法中，你可以进行必要的步骤来设置上下文。

另外，你可以从 __enter__() 方法中返回一个对象。

`exit()`方法

Python总是执行 __exit__() 方法，即使在 with 语句块中发生了异常。

这个 __exit__() 方法接受三个参数：异常类型，异常值，和回溯对象。如果没有发生异常，所有这些参数都将是 None 。


def __exit__(self, ex_type, ex_value, ex_traceback):
    ...

__exit__() 方法返回一个布尔值， True 或 False 。

如果返回值为 True，Python 将使任何异常静默化。否则，它不会使异常静默。

Python 上下文管理器的应用

正如你从前面的例子中看到的，上下文管理器的常见用法是自动打开和关闭文件。

然而，你可以在许多其他情况下使用上下文管理器。

1）打开 - 关闭

如果你想自动打开和关闭一个资源，你可以使用一个上下文管理器。

例如，你可以使用上下文管理器打开一个套接字并关闭它。

2）锁定-释放

上下文管理器可以帮助你更有效地管理对象的锁。它们允许你获得一个锁并自动释放它。

上下文管理器还可以帮助你在需要启动和停止阶段的情况下工作。

例如，你可以使用一个上下文管理器来启动一个定时器并自动停止它。

3）改变 - 重置

上下文管理器可以适用于变化与重置的场景

例如，你的应用程序需要连接到多个数据源。而它有一个默认的连接。

要连接到另一个数据源：

首先，使用上下文管理器将默认连接改为新的连接。
第二，让新的连接开始工作。
第三，一旦你完成了新连接的工作，就把它重置为默认连接。

实现Python上下文管理协议

下面显示了使用上下文管理协议的 open() 函数的简单实现。

class File:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        print(f'Opening the file {self.filename}.')
        self.__file = open(self.filename, self.mode)
        return self.__file

    def __exit__(self, type, value, traceback):
        print(f'Closing the file {self.filename}.')
        if not self.__file.closed:
            self.__file.close()

        return False    

With File('data.txt', 'r') as f:
    print(int(next(f)))

它是如何工作的。

首先，在 __init__() 方法中初始化 filename 和 mode 。
第二，在 __enter__() 方法中打开文件并返回文件对象。
第三，如果文件是在 __exit__() 方法中打开的，就关闭它。

使用Python上下文管理器来实现启动和停止模式

下面定义了一个支持上下文管理协议的 Timer 类。

from time import perf_counter

class Timer:
    def __init__(self):
        self.elapsed = 0

    def __enter__(self):
        self.start = perf_counter()
        return self

    def __exit__(self, exc_type, exc_value, exc_traceback):
        self.stop = perf_counter()
        self.elapsed = self.stop - self.start
        return False

它是如何工作的。

首先，从 time 模块导入 perf_counter 。
第二，在 __enter__() 方法中启动定时器。
第三，在 __exit__() 方法中停止定时器，并返回经过的时间。

现在，你可以用 Timer 类来测量计算参数为1000的斐波那契函数所需的时间，计算一百万次。

def fibonacci(n):
    f1 = 1
    f2 = 1
    for i in range(n-1):
        f1, f2 = f2, f1 + f2

    return f1


with Timer() as timer:
    for _ in range(1, 1000000):
        fibonacci(1000)

print(timer.elapsed)