详解Python中with语句的用法

引言

with 语句是从 Python 2.5 开始引入的一种与异常处理相关的功能(2.5 版本中要通过 from __future__ import with_statement 导入后才可以使用),从 2.6 版本开始缺省可用(参考 What's new in Python 2.6? 中 with 语句相关部分介绍)。with 语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的“清理”操作,释放资源,比如文件使用后自动关闭、线程中锁的自动获取和释放等。

术语

要使用 with 语句,首先要明白上下文管理器这一概念。有了上下文管理器,with 语句才能工作。

下面是一组与上下文管理器和with 语句有关的概念。

上下文管理协议(Context Management Protocol):包含方法 __enter__() 和 __exit__(),支持

该协议的对象要实现这两个方法。

上下文管理器(Context Manager):支持上下文管理协议的对象,这种对象实现了

__enter__() 和 __exit__() 方法。上下文管理器定义执行 with 语句时要建立的运行时上下文,

负责执行 with 语句块上下文中的进入与退出操作。通常使用 with 语句调用上下文管理器,

也可以通过直接调用其方法来使用。

运行时上下文(runtime context):由上下文管理器创建,通过上下文管理器的 __enter__() 和

__exit__() 方法实现,__enter__() 方法在语句体执行之前进入运行时上下文,__exit__() 在

语句体执行完后从运行时上下文退出。with 语句支持运行时上下文这一概念。

上下文表达式(Context Expression):with 语句中跟在关键字 with 之后的表达式,该表达式

要返回一个上下文管理器对象。

语句体(with-body):with 语句包裹起来的代码块,在执行语句体之前会调用上下文管

理器的 __enter__() 方法,执行完语句体之后会执行 __exit__() 方法。

基本语法和工作原理

with 语句的语法格式如下:
清单 1. with 语句的语法格式

  with context_expression [as target(s)]:
    with-body

这里 context_expression 要返回一个上下文管理器对象,该对象并不赋值给 as 子句中的 target(s) ,如果指定了 as 子句的话,会将上下文管理器的 __enter__() 方法的返回值赋值给 target(s)。target(s) 可以是单个变量,或者由“()”括起来的元组(不能是仅仅由“,”分隔的变量列表,必须加“()”)。

Python 对一些内建对象进行改进,加入了对上下文管理器的支持,可以用于 with 语句中,比如可以自动关闭文件、线程锁的自动获取和释放等。假设要对一个文件进行操作,使用 with 语句可以有如下代码:
清单 2. 使用 with 语句操作文件对象

  with open(r'somefileName') as somefile:
    for line in somefile:
      print line
      # ...more code

这里使用了 with 语句,不管在处理文件过程中是否发生异常,都能保证 with 语句执行完毕后已经关闭了打开的文件句柄。如果使用传统的 try/finally 范式,则要使用类似如下代码:
清单 3. try/finally 方式操作文件对象

  somefile = open(r'somefileName')
  try:
    for line in somefile:
      print line
      # ...more code
  finally:
    somefile.close()

比较起来,使用 with 语句可以减少编码量。已经加入对上下文管理协议支持的还有模块 threading、decimal 等。

PEP 0343 对 with 语句的实现进行了描述。with 语句的执行过程类似如下代码块:
清单 4. with 语句执行过程

context_manager = context_expression
  exit = type(context_manager).__exit__
  value = type(context_manager).__enter__(context_manager)
  exc = True  # True 表示正常执行,即便有异常也忽略;False 表示重新抛出异常,需要对异常进行处理
  try:
    try:
      target = value # 如果使用了 as 子句
      with-body   # 执行 with-body
    except:
      # 执行过程中有异常发生
      exc = False
      # 如果 __exit__ 返回 True,则异常被忽略;如果返回 False,则重新抛出异常
      # 由外层代码对异常进行处理
      if not exit(context_manager, *sys.exc_info()):
        raise
  finally:
    # 正常退出,或者通过 statement-body 中的 break/continue/return 语句退出
    # 或者忽略异常退出
    if exc:
      exit(context_manager, None, None, None)
    # 缺省返回 None,None 在布尔上下文中看做是 False

执行 context_expression,生成上下文管理器 context_manager
    调用上下文管理器的 __enter__() 方法;如果使用了 as 子句,则将 __enter__() 方法的返回值赋值给 as 子句中的 target(s)
    执行语句体 with-body
    不管是否执行过程中是否发生了异常,执行上下文管理器的 __exit__() 方法,__exit__() 方法负责执行“清理”工作,如释放资源等。如果执行过程中没有出现异常,或者语句体中执行了语句 break/continue/return,则以 None 作为参数调用 __exit__(None, None, None) ;如果执行过程中出现异常,则使用 sys.exc_info 得到的异常信息为参数调用 __exit__(exc_type, exc_value, exc_traceback)
    出现异常时,如果 __exit__(type, value, traceback) 返回 False,则会重新抛出异常,让with 之外的语句逻辑来处理异常,这也是通用做法;如果返回 True,则忽略异常,不再对异常进行处理

自定义上下文管理器

开发人员可以自定义支持上下文管理协议的类。自定义的上下文管理器要实现上下文管理协议所需要的 __enter__() 和 __exit__() 两个方法:

context_manager.__enter__() :进入上下文管理器的运行时上下文,在语句体执行前调用。with 语句将该方法的返回值赋值给 as 子句中的 target,如果指定了 as 子句的话
    context_manager.__exit__(exc_type, exc_value, exc_traceback) :退出与上下文管理器相关的运行时上下文,返回一个布尔值表示是否对发生的异常进行处理。参数表示引起退出操作的异常,如果退出时没有发生异常,则3个参数都为None。如果发生异常,返回

True 表示不处理异常,否则会在退出该方法后重新抛出异常以由 with 语句之外的代码逻辑进行处理。如果该方法内部产生异常,则会取代由 statement-body 中语句产生的异常。要处理异常时,不要显示重新抛出异常,即不能重新抛出通过参数传递进来的异常,只需要将返回值设置为 False 就可以了。之后,上下文管理代码会检测是否 __exit__() 失败来处理异常

下面通过一个简单的示例来演示如何构建自定义的上下文管理器。注意,上下文管理器必须同时提供 __enter__() 和 __exit__() 方法的定义,缺少任何一个都会导致 AttributeError;with 语句会先检查是否提供了 __exit__() 方法,然后检查是否定义了 __enter__() 方法。

假设有一个资源 DummyResource,这种资源需要在访问前先分配,使用完后再释放掉;分配操作可以放到 __enter__() 方法中,释放操作可以放到 __exit__() 方法中。简单起见,这里只通过打印语句来表明当前的操作,并没有实际的资源分配与释放。
清单 5. 自定义支持 with 语句的对象

  class DummyResource:
  def __init__(self, tag):
      self.tag = tag
      print 'Resource [%s]' % tag
    def __enter__(self):
      print '[Enter %s]: Allocate resource.' % self.tag
      return self  # 可以返回不同的对象
    def __exit__(self, exc_type, exc_value, exc_tb):
      print '[Exit %s]: Free resource.' % self.tag
      if exc_tb is None:
        print '[Exit %s]: Exited without exception.' % self.tag
      else:
        print '[Exit %s]: Exited with exception raised.' % self.tag
        return False  # 可以省略,缺省的None也是被看做是False

DummyResource 中的 __enter__() 返回的是自身的引用,这个引用可以赋值给 as 子句中的 target 变量;返回值的类型可以根据实际需要设置为不同的类型,不必是上下文管理器对象本身。

__exit__() 方法中对变量 exc_tb 进行检测,如果不为 None,表示发生了异常,返回 False 表示需要由外部代码逻辑对异常进行处理;注意到如果没有发生异常,缺省的返回值为 None,在布尔环境中也是被看做 False,但是由于没有异常发生,__exit__() 的三个参数都为 None,上下文管理代码可以检测这种情况,做正常处理。

下面在 with 语句中访问 DummyResource :
清单 6. 使用自定义的支持 with 语句的对象

 with DummyResource('Normal'):
    print '[with-body] Run without exceptions.'

  with DummyResource('With-Exception'):
    print '[with-body] Run with exception.'
    raise Exception
    print '[with-body] Run with exception. Failed to finish statement-body!'

第1个 with 语句的执行结果如下:
清单 7. with 语句1执行结果

Resource [Normal]
    [Enter Normal]: Allocate resource.
    [with-body] Run without exceptions.
    [Exit Normal]: Free resource.
    [Exit Normal]: Exited without exception.

可以看到,正常执行时会先执行完语句体 with-body,然后执行 __exit__() 方法释放资源。

第2个 with 语句的执行结果如下:
清单 8. with 语句2执行结果

 Resource [With-Exception]
  [Enter With-Exception]: Allocate resource.
  [with-body] Run with exception.
  [Exit With-Exception]: Free resource.
  [Exit With-Exception]: Exited with exception raised.

  Traceback (most recent call last):
   File "G:/demo", line 20, in <module>
    raise Exception
  Exception

可以看到,with-body 中发生异常时with-body 并没有执行完,但资源会保证被释放掉,同时产生的异常由 with 语句之外的代码逻辑来捕获处理。

可以自定义上下文管理器来对软件系统中的资源进行管理,比如数据库连接、共享资源的访问控制等。Python 在线文档 Writing Context Managers 提供了一个针对数据库连接进行管理的上下文管理器的简单范例。

contextlib 模块

contextlib 模块提供了3个对象:装饰器 contextmanager、函数 nested 和上下文管理器 closing。使用这些对象,可以对已有的生成器函数或者对象进行包装,加入对上下文管理协议的支持,避免了专门编写上下文管理器来支持 with 语句。
装饰器 contextmanager

contextmanager 用于对生成器函数进行装饰,生成器函数被装饰以后,返回的是一个上下文管理器,其 __enter__() 和 __exit__() 方法由 contextmanager 负责提供,而不再是之前的迭代子。被装饰的生成器函数只能产生一个值,否则会导致异常 RuntimeError;产生的值会赋值给 as 子句中的 target,如果使用了 as 子句的话。下面看一个简单的例子。
清单 9. 装饰器 contextmanager 使用示例

from contextlib import contextmanager

  @contextmanager
  def demo():
    print '[Allocate resources]'
    print 'Code before yield-statement executes in __enter__'
    yield '*** contextmanager demo ***'
    print 'Code after yield-statement executes in __exit__'
    print '[Free resources]'

  with demo() as value:
    print 'Assigned Value: %s' % value

结果输出如下:
清单 10. contextmanager 使用示例执行结果

 [Allocate resources]
  Code before yield-statement executes in __enter__
  Assigned Value: *** contextmanager demo ***
  Code after yield-statement executes in __exit__
  [Free resources]

可以看到,生成器函数中 yield 之前的语句在 __enter__() 方法中执行,yield 之后的语句在 __exit__() 中执行,而 yield 产生的值赋给了 as 子句中的 value 变量。

需要注意的是,contextmanager 只是省略了 __enter__() / __exit__() 的编写,但并不负责实现资源的“获取”和“清理”工作;“获取”操作需要定义在 yield 语句之前,“清理”操作需要定义 yield 语句之后,这样 with 语句在执行 __enter__() / __exit__() 方法时会执行这些语句以获取/释放资源,即生成器函数中需要实现必要的逻辑控制,包括资源访问出现错误时抛出适当的异常。
函数 nested

nested 可以将多个上下文管理器组织在一起,避免使用嵌套 with 语句。
清单 11. nested 语法

 with nested(A(), B(), C()) as (X, Y, Z):
     # with-body code here

类似于:
清单 12. nested 执行过程

  with A() as X:
    with B() as Y:
      with C() as Z:
         # with-body code here

需要注意的是,发生异常后,如果某个上下文管理器的 __exit__() 方法对异常处理返回 False,则更外层的上下文管理器不会监测到异常。
上下文管理器 closing

closing 的实现如下:
清单 13. 上下文管理 closing 实现

  class closing(object):
    # help doc here
    def __init__(self, thing):
      self.thing = thing
    def __enter__(self):
      return self.thing
    def __exit__(self, *exc_info):
      self.thing.close()

上下文管理器会将包装的对象赋值给 as 子句的 target 变量,同时保证打开的对象在 with-body 执行完后会关闭掉。closing 上下文管理器包装起来的对象必须提供 close() 方法的定义,否则执行时会报 AttributeError 错误。
清单 14. 自定义支持 closing 的对象

class ClosingDemo(object):
    def __init__(self):
      self.acquire()
    def acquire(self):
      print 'Acquire resources.'
    def free(self):
      print 'Clean up any resources acquired.'
    def close(self):
      self.free()

  with closing(ClosingDemo()):
    print 'Using resources'

结果输出如下:
清单 15. 自定义 closing 对象的输出结果

  Acquire resources.
  Using resources
  Clean up any resources acquired.

closing 适用于提供了 close() 实现的对象,比如网络连接、数据库连接等,也可以在自定义类时通过接口 close() 来执行所需要的资源“清理”工作。

(0)

相关推荐

  • Python的词法分析与语法分析

    词法分析(Lexical Analysis):分析由字符组成的单词是否合法,如果没有问题的话,则产生一个单词流. 语法分析(Syntactic Analysis):分析由单词组成的句子是否合法,如果没有问题的话,则产生一个语法树. 在词法分析器分析源代码文本的时候,有一个概念需要明确: 1.物理行:由回车字符序列(在Windows上是CR LF,在Unix上是LF)结尾的字符序列组成一个物理行. 2.逻辑行:由一个或者多个物理行组成,可以明确地使用反斜杠(\)来连接多个物理行使之成为一个逻辑行:

  • 简单谈谈python中的语句和语法

    python程序结构 python"一切皆对象",这是接触python听到最多的总结了.在python中最基层的单位应该就是对象了,对象需要靠表达式建立处理,而表达式往往存在于语句中,多条语句组成代码块,多个代码块再组成一整个程序.python的核心其实是由语句和表达式组成.所以在这里简单探讨一下python中的语句和表达式. 因为以后可能会接触到两个版本的python,所以这里讲一讲python2与python3的语句差异: 1.python2中没有nolocal语句. 2.prin

  • 详解Python中的循环语句的用法

    一.简介 Python的条件和循环语句,决定了程序的控制流程,体现结构的多样性.须重要理解,if.while.for以及与它们相搭配的 else. elif.break.continue和pass语句. 二.详解 1.if语句 Python中的if子句由三部分组成:关键字本身.用于判断结果真假的条件表达式以及当表达式为真或者非零时执行的代码块.if 语句的语法如下: if expression: expr_true_suite if 语句的expr_true_suite代码块只有在条件表达式的结

  • 详解Python中break语句的用法

    在Python中的break语句终止当前循环,继续执行下一个语句,就像C语言中的break一样. break最常见的用途是当一些外部条件被触发,需要从一个循环中断退出. break语句可以在while和for循环使用. 如果正在使用嵌套循环(即一个循环里内嵌另一个循环),break语句可以用于停止最内层循环的执行,并执行外循环的下一行代码的程序. 语法 在Python中break语句的语法如下: break 流程图: #!/usr/bin/python for letter in 'Python

  • 详解Python中with语句的用法

    引言 with 语句是从 Python 2.5 开始引入的一种与异常处理相关的功能(2.5 版本中要通过 from __future__ import with_statement 导入后才可以使用),从 2.6 版本开始缺省可用(参考 What's new in Python 2.6? 中 with 语句相关部分介绍).with 语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的"清理"操作,释放资源,比如文件使用后自动关闭.线程中锁的自动获取和释放等. 术

  • 一文详解Python中logging模块的用法

    目录 一.低配logging 1.v1 2.v2 3.v3 二.高配logging 1.配置日志文件 2.使用日志 三.Django日志配置文件 一.低配logging 日志总共分为以下五个级别,这个五个级别自下而上进行匹配 debug-->info-->warning-->error-->critical,默认最低级别为warning级别. 1.v1 import logging logging.debug('调试信息') logging.info('正常信息') logging

  • 详解Python中openpyxl模块基本用法

    Python操作EXCEL库的简介 1.1 Python官方库操作excel Python官方库一般使用xlrd库来读取Excel文件,使用xlwt库来生成Excel文件,使用xlutils库复制和修改Excel文件,这三个库只支持到Excel2003. 1.2 第三方库openpyxl介绍 第三方库openpyxl(可读写excel表),专门处理Excel2007及以上版本产生的xlsx文件,xls和xlsx之间转换容易. 注意:如果文字编码是"gb2312" 读取后就会显示乱码,请

  • 举例详解Python中循环语句的嵌套使用

    Python编程语言允许在一个循环内嵌套另一个循环.下面将介绍几个例子来说明这一概念. 语法 在Python中嵌套循环语句的语法如下: for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s) Python编程语言允许在一个循环内嵌套另一个循环.下面将介绍几个例子来说明这一概念. 语法 在Python中嵌套循环语句的语法如下: for iterating_var in seq

  • 详解python中的index函数用法

    1.函数的创建 def fun(): #定义 print('hellow') #函数的执行代码 retrun 1 #返回值 fun() #执行函数 2.函数的参数 普通参数 :要按照顺序输入参数 def fun(a,b,c): print(a) print(b) print(c) return a fun(11,22,33) #输出:11 #输出:22 #输出:33 指定参数:输入参数时可以不按照顺序输入 def fun(a,b,c): print(a) print(b) print(c) re

  • 详解Python中 sys.argv[]的用法简明解释

    因为是看书自学的python,开始后不久就遇到了这个引入的模块函数,且一直在IDLE上编辑了后运行,试图从结果发现它的用途,然而结果一直都是没结果,也在网上查了许多,但发现这个问题的比较详细的解释只有一个版本,大部分都是转裁和复制的.给的都是简明python教程上那个一长串代码的例子,说看了就明白了,可我看得晕头转向的还是没真正明白,只知道"sys.argv[0]表示代码本身文件路径"这点,其实还是不明其意.后来经过大量努力,多方求教才真正明悟了,谨以记录和分享,希望能从另一个角度给同

  • 详解Python中heapq模块的用法

    heapq 模块提供了堆算法.heapq是一种子节点和父节点排序的树形数据结构.这个模块提供heap[k] <= heap[2*k+1] and heap[k] <= heap[2*k+2].为了比较不存在的元素被人为是无限大的.heap最小的元素总是[0]. 打印 heapq 类型 import math import random from cStringIO import StringIO def show_tree(tree, total_width=36, fill=' '): ou

  • 举例详解Python中yield生成器的用法

    yield是生成的意思,但是在python中则是作为生成器理解,生成器的用处主要可以迭代,这样简化了很多运算模型(还不是很了解是如何简化的). yield是一个表达式,是有返回值的. 当一个函数中含有yield时,它不再是一个普通的函数,而是一个生成器.当该函数被调用时不会自动执行,而是暂停,见第一个例子: 例1: >>> def mygenerator(): ... print 'start...' ... yield 5 ... >>> mygenerator()

  • 详解Python中where()函数的用法

    where()的用法 首先强调一下,where()函数对于不同的输入,返回的只是不同的. 1当数组是一维数组时,返回的值是一维的索引,所以只有一组索引数组 2当数组是二维数组时,满足条件的数组值返回的是值的位置索引,因此会有两组索引数组来表示值的位置 例如 >>>b=np.arange(10) >>>b array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>>np.where(b>5) (array([6, 7, 8,

随机推荐