器→工具, 编程语言

深入理解Python with语句

钱魏Way · · 45 次浏览

什么是with语句?

with 语句是从 Python 2.6 开始引入的一种与异常处理相关的功能。with 语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的“清理”操作,释放资源,比如文件使用后自动关闭、线程中锁的自动获取和释放等。

with语句是一个新的控制流结构,其基本结构为:

with expression [as variable]:
    with-block

一个很好的例子是文件处理,你需要获取一个文件句柄,从文件中读取数据,然后关闭文件句柄。如果不用with语句,代码如下:

file = open("foo.txt")
data = file.read()
file.close()

这里有两个问题:

  • 可能忘记关闭文件句柄
  • 文件读取数据发生异常,没有进行任何处理

下面是处添加了异常处理的代码:

file = open("foo.txt")
try:
    data = file.read()
finally:
    file.close()

虽然这段代码运行良好,但是太冗长了。这时候就是with一展身手的时候了。除了有更优雅的语法,with还可以很好的处理上下文环境产生的异常。下面是with版本的代码:

with open("foo.txt") as file:
    data = file.read()

with语句是如何工作的?

Python对with的处理还聪明。基本思想是with所求值的对象必须有一个enter()方法,一个exit()方法。紧跟with后面的语句被求值后,返回对象的enter()方法被调用,这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后,将调用前面返回对象的exit()方法。

下面例子可以具体说明with如何工作:

class Sample:
    def __enter__(self):
        print("In __enter__()")
        return "Foo"

    def __exit__(self, type, value, trace):
        print("In __exit__()")


def get_sample():
    return Sample()


with get_sample() as sample:
    print("sample:", sample)

执行后的输出内容为:

In __enter__()
sample: Foo
In __exit__()

具体流程:

  • enter()方法被执行
  • enter()方法返回的值 – 这个例子中是”Foo”,赋值给变量’sample’
  • 执行代码块,打印变量”sample”的值为 “Foo”
  • exit()方法被调用

with真正强大之处是它可以处理异常。可能你已经注意到Sample类的exit方法有三个参数:val, type 和 trace。 这些参数在异常处理中相当有用。我们来改一下代码,看看具体如何工作的。

class Sample:
    def __enter__(self):
        return self

    def __exit__(self, type, value, trace):
        print("type:", type)
        print("value:", value)
        print("trace:", trace)

    def do_something(self):
        bar = 1 / 0
        return bar


with Sample() as sample:
    sample.do_something()

输出结果为:

Traceback (most recent call last):
  File "test.py", line 16, in <module>
    sample.do_something()
  File "test.py", line 11, in do_something
    bar = 1 / 0
ZeroDivisionError: division by zero
type: <class 'ZeroDivisionError'>
value: division by zero
trace: <traceback object at 0x0000029739A7F508>

这个例子中,with后面的get_sample()变成了Sample()。这没有任何关系,只要紧跟with后面的语句所返回的对象有enter()和exit()方法即可。此例中,Sample()的enter()方法返回新创建的Sample对象,并赋值给变量sample。

实际上,在with后面的代码块抛出任何异常时,exit()方法被执行。正如例子所示,异常抛出时,与之关联的type,value和stack trace传给exit()方法,因此抛出的ZeroDivisionError异常被打印出来了。开发库时,清理资源,关闭文件等等操作,都可以放在exit方法当中。

因此,Python的with语句是提供一个有效的机制,让代码更简练,同时在异常产生时,清理工作更简单。

上下文管理器

在任何一门编程语言中,文件的输入输出、数据库的连接断开等,都是很常见的资源管理操作。但资源都是有限的,在写程序时,我们必须保证这些资源在使用过后得到释放,不然就容易造成资源泄露,轻者使得系统处理缓慢,重则会使系统崩溃。

为了解决这个问题,不同的编程语言都引入了不同的机制。而在 Python 中,对应的解决方式便是上下文管理器(context manager)。上下文管理器,能够帮助你自动分配并且释放资源,其中最典型的应用便是 with 语句。

另外一个典型的例子,是 Python 中的 threading.lock 类。举个例子,比如我想要获取一个锁,执行相应的操作,完成后再释放,那么代码就可以写成下面这样:

some_lock = threading.Lock()
some_lock.acquire()
try:
    ...
finally:
    some_lock.release()

而对应的 with 语句,同样非常简洁:

some_lock = threading.Lock()
with somelock:
    ...

我们可以从这两个例子中看到,with 语句的使用,可以简化了代码,有效避免资源泄露的发生。

基于类的上下文管理器

这里,我自定义了一个上下文管理类 FileManager,模拟 Python 的打开、关闭文件操作:

class FileManager:
    def __init__(self, name, mode):
        print('calling __init__ method')
        self.name = name
        self.mode = mode
        self.file = None

    def __enter__(self):
        print('calling __enter__ method')
        self.file = open(self.name, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('calling __exit__ method')
        if self.file:
            self.file.close()


with FileManager('test.txt', 'w') as f:
    print('ready to write to file')
    f.write('hello world')

当我们用类来创建上下文管理器时,必须保证这个类包括方法”__enter__()”和方法“__exit__()”。其中,方法“__enter__()”返回需要被管理的资源,方法“__exit__()”里通常会存在一些释放、清理资源的操作,比如这个例子中的关闭文件等等。而当我们用 with 语句,执行这个上下文管理器时:

with FileManager('test.txt', 'w') as f:
    f.write('hello world')

下面这四步操作会依次发生:

  • 方法“__init__()”被调用,程序初始化对象 FileManager,使得文件名(name)是”test.txt”,文件模式 (mode) 是’w’
  • 方法“__enter__()”被调用,文件“test.txt”以写入的模式被打开,并且返回 FileManager 对象赋予变量 f
  • 字符串“hello world”被写入文件“test.txt”
  • 方法“__exit__()”被调用,负责关闭之前打开的文件流

因此,这个程序的输出是:

calling __init__ method
calling __enter__ method
ready to write to file
calling __exit__ method

方法“__exit__()”中的参数“exc_type, exc_val, exc_tb”,分别表示 exception_type、exception_value 和 traceback。当我们执行含有上下文管理器的 with 语句时,如果有异常抛出,异常的信息就会包含在这三个变量中,传入方法“__exit__()”。

基于contextlib模块装饰器和生成器实现

Python 在 contextlib 模块中还提供了一个 contextmanager 的装饰器,更进一步简化了上下文管理器的实现方式。通过 yield 将函数分割成两部分,yield 之前的语句在  __enter__  方法中执行,yield 之后的语句在 __exit__ 方法中执行。紧跟在 yield 后面的值是函数的返回值。

from contextlib import contextmanager


@contextmanager
def file_manager(name, mode):
    try:
        f = open(name, mode)
        yield f
    finally:
        f.close()


with file_manager('test.txt', 'w') as f:
    f.write('hello world')

这段代码中,函数 file_manager() 是一个生成器,当我们执行 with 语句时,便会打开文件,并返回文件对象 f;当 with 语句执行完后,finally block 中的关闭文件操作便会执行。你可以看到,使用基于生成器的上下文管理器时,我们不再用定义“__enter__()”和“__exit__()”方法,但请务必加上装饰器 @contextmanager,这一点新手很容易疏忽。

参考链接:

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注