【Python学习笔记】with语句与上下文管理器

你的名字 2022-02-03 02:45 349阅读 0赞
  • with语句
  • 上下文管理器
  • contextlib模块
  • 参考

with语句

with语句时在Python2.6中出现的新语句。在Python2.6以前，要正确的处理涉及到异常的资源管理时，需要使用try/finally代码结构。如要实现文件在操作出现异常时也能正确关闭，则需要像如下实现：

  1. f = open("test.txt")
  2. try:
  3.     for line in f.readlines():
  4.         print(line)
  5. finally:
  6.     f.close()

不管文件操作有没有出现异常，try/finally中的finnally语句都会执行，从而保证文件的正确关闭。但是很显然Python的设计者们并没有满足于此，他们以希望更简洁更优美的形式来实现资源的清理，而且希望这种清理工作不需要暴露给使用者，所以便出现了with语句。
with语句的基本语法结构如下:

  1. with expression [as variable]:
  2. 　　　 with-block

先看下如果用with语句代替上面的try/finally的例子，然后再讨论它的更多细节，如下：

  1. with open("text.txt") as f:
  2.     for line in f.readlines()
  3. 　　　　print(line)

是不是发现使用with语句相对try/finally来说简洁了很多，而且也不需要每一个用户都去写f.close()来关闭文件了，这是因为with语句在背后做了大量的工作。with语句的expression是上下文管理器，这个我们下文会说。with语句中的[as variable]是可选的，如果指定了as variable说明符，则variable是上下文管理器expression调用__enter__()函数返回的对象。所以，f并不一定就是expression，而是expression.enter()的返回值，至于expression.enter()返回什么就由这个函数来决定了。with-block是执行语句，with-block执行完毕时，with语句会自动进行资源清理，对应上面例子就是with语句会自动关闭文件。

下面我们来具体说下with语句在背后默默无闻地到底做了哪些事情。刚才我们说了expression是一个上下文管理器，其实现了__enter__和__exit__两个函数。当我们调用一个with语句时，执行过程如下：

1.首先生成一个上下文管理器expression，在上面例子中with语句首先以“test.txt”作为参数生成一个上下文管理器open(“test.txt”)。

2.然后执行expression.enter()。如果指定了[as variable]说明符，将__enter__()的返回值赋给variable。上例中open(“test.txt”).enter()返回的是一个文件对象给f。

3.执行with-block语句块。上例中执行读取文件。

4.执行expression.exit(),在__exit__()函数中可以进行资源清理工作。上面例子中就是执行文件的关闭操作。

with语句不仅可以管理文件，还可以管理锁、连接等等，如下面的例子：

  1. #管理锁
  2. import  threading
  3. lock = threading.lock()
  4. with lock:
  5.     #执行一些操作
  6.     pass

上下文管理器

在上文中我们提到with语句中的上下文管理器。with语句可以如此简单但强大，主要依赖于上下文管理器。那么什么是上下文管理器?上下文管理器就是实现了上下文协议的类，而上下文协议就是一个类要实现__enter__()和__exit__()两个方法。一个类只要实现了__enter__()和__exit__()，我们就称之为上下文管理器下面我们具体说下这两个方法。

enter()：主要执行一些环境准备工作，同时返回一资源对象。如果上下文管理器open(“test.txt”)的__enter__()函数返回一个文件对象。

exit()：完整形式为__exit__(type, value, traceback),这三个参数和调用sys.exec_info()函数返回值是一样的，分别为异常类型、异常信息和堆栈。如果执行体语句没有引发异常，则这三个参数均被设为None。否则，它们将包含上下文的异常信息。exit()方法返回True或False,分别指示被引发的异常有没有被处理，如果返回False，引发的异常将会被传递出上下文。如果__exit_()函数内部引发了异常，则会覆盖掉执行体的中引发的异常。处理异常时，不需要重新抛出异常，只需要返回False，with语句会检测__exit__()返回False来处理异常。

如果我们要自定义一个上下文管理器，只需要定义一个类并且是实现__enter__()和__exit__()即可。下面通过一个简单的例子是演示如果新建自定义的上下文管理器，我们以数据库的连接为例。在使用数据库时，有时要涉及到事务操作。数据库的事务操作当调用commit()执行sql命令时，如果在这个过程中执行失败，则需要执行rollback()回滚数据库,通常实现方式可能如下：

  1. def test_write():
  2.     con = MySQLdb.connection()
  3.     cursor = con.cursor()
  4.     sql = """      #具体的sql语句
  5.     """
  6.     try:
  7.         cursor.execute(sql)
  8.         cursor.execute(sql)
  9.         cursor.execute(sql)
  10.         con.commit()      #提交事务
  11.     except Exception as ex:
  12.         con.rollback()    #事务执行失败，回滚数据库

如果想通过with语句来实现数据库执行失败的回滚操作，则我们需要自定义一个数据库连接的上下文管理器，假设为DBConnection，则我们将上面例子用with语句来实现的话，应该是这样子的，如下：

  1. def test_write():
  2.     sql = """      #具体的sql语句
  3.     """
  4.     con = DBConnection()
  5.     with con as cursor:   
  6.         cursor.execute(sql)
  7.         cursor.execute(sql)
  8.         cursor.execute(sql)

要实现上面with语句的功能，则我们的DBConnection数据库上下文管理器则需要提供一下功能：enter()要返回一个连接的cursor; 当没有异常发生是，exit()函数commit所有的数据库操作。如果有异常发生则_exit__()会回滚数据库，调用rollback()。所以我们可以实现DBConnection如下：

  1. def DBConnection(object):
  2.     def __init__(self):
  3.         pass
  5.     def cursor(self):
  6.         #返回一个游标并且启动一个事务
  7.         pass
  9.     def commit(self):
  10.         #提交当前事务
  11.         pass
  13.     def rollback(self):
  14.         #回滚当前事务
  15.         pass
  17.     def __enter__(self):
  18.         #返回一个cursor
  19.         cursor = self.cursor()
  20.         return cursor
  22.     def __exit__(self, type, value, tb):
  23.         if tb is None:
  24.             #没有异常则提交事务
  25.             self.commit() 
  26.         else:
  27.             #有异常则回滚数据库
  28.             self.rollback()

contextlib模块

contextmanage对象

上文提到如果我们要实现一个自定义的上下文管理器,需要定义一个实现了__enter__和__exit__两个方法的类, 这显示不是很方便。Python的contextlib模块给我们提供了更方便的方式来实现一个自定义的上下文管理器。contextlib模块包含一个装饰器contextmanager和一些辅助函数，装饰器contextmanager只需要写一个生成器函数就可以代替自定义的上下文管理器，典型用法如下：

需要使用yield先定义一个生成器函数:

  1. @contextmanager
  2.         def some_generator(<arguments>):
  3.             <setup>
  4.             try:
  5.                 yield <value>
  6.             finally:
  7.                 <cleanup>

然后便可以用with语句调用contextmanage生成的上下文管理器了，with语句用法如下：

  1. with some_generator(<arguments>) as <variable>:
  2.             <body>

生成器函数some_generator就和我们普通的函数一样，它的原理如下：

  1. some_generator函数在在yield之前的代码等同于上下文管理器中的__enter__函数。
  2. yield的返回值等同于__enter__函数的返回值，即如果with语句声明了as
    ，则yield的值会赋给variable

  3. 然后执行代码块，等同于上下文管理器的__exit__函数。此时发生的任何异常都会再次通过yield函数返回。
    下面举几个简单的例子:
    例子1：锁资源自动获取和释放的例子

    @contextmanager
    def locked(lock):

    1. lock.acquire()
    2. try:
    3.     yield
    4. finally:
    5.     lock.release()

    with locked(myLock):

    1. #代码执行到这里时，myLock已经自动上锁
    2. pass
    3. #执行完后会，会自动释放锁

例子2：文件打开后自动管理的实现

  1. @contextmanager
  2. def myopen(filename, mode="r"):
  3.     f = open(filename,mode)
  4.     try:
  5.         yield f
  6.     finally:
  7.         f.close()
  9. with myopen("test.txt") as f:
  10.     for line in f:
  11.         print(line)

例子3：数据库事务的处理:

  1. @contextmanager
  2. def transaction(db):
  3.     db.begin()
  4.     try：
  5.         yield 
  6.     except:
  7.         db.rollback()
  8.         raise
  9.     else:
  10.         db.commit()
  12. with transaction(mydb):
  13.     mydb.cursor.execute(sql)
  14.     mydb.cursor.execute(sql)
  15.     mydb.cursor.execute(sql)
  16.     mydb.cursor.execute(sql)

nested函数

contextlib模块还提供了一个函数给我们：nested(mgr1,mgr2…mgrn)函数，用来嵌套多个上下文管理器，等同于下面的形式:

  1. with mgr1:
  2.     with mgr2:
  3.         ...
  4.         with mgrn:
  5.             pass

但是with语句本身已经支持了多个下文管理器的使用，所以nested的意义不是很大。我们可以写一个例子来看下nested函数的使用，以及与直接使用with来嵌套多个上下文管理器的区别，如下所示：

  1. from contextlib import contextmanager
  2. from contextlib import nested
  3. from contextlib import closing
  5. @contextmanager
  6. def my_context(name):
  7.     print("enter")
  8.     try:
  9.         yield name
  10.     finally:
  11.         print("exit")
  13. #使用nested函数来调用多个管理器
  14. print("---------使用nested函数调用多个管理器-----------")
  15. with nested(my_context("管理器一"), my_context("管理器二"),my_context("管理器三")) as (m1,m2,m3):
  16.     print(m1)
  17.     print(m2)
  18.     print(m3)
  20. #直接使用with来调用调用多个管理器
  21. print("---------使用with调用多个管理器-----------")
  22. with my_context("管理器一") as m1, my_context("管理器二") as m2, my_context("管理器三") as m3:
  23.     print(m1)
  24.     print(m2)
  25.     print(m3)

在这里插入图片描述

closing对象

contextlib中还包含一个closing对象，这个对象就是一个上下文管理器，它的__exit__函数仅仅调用传入参数的close函数，closing对象的源码如下：

  1. class closing(object):
  2.     def __init__(self, thing):
  3.         self.thing = thing
  4.     def __enter__(self):
  5.         return self.thing
  6.     def __exit__(self, *exc_info):
  7.         self.thing.close()

所以closeing上下文管理器仅使用于具有close()方法的资源对象。例如，如果我们通过urllib.urlopen打开一个网页，urlopen返回的request有close方法，所以我们就可以使用closing上下文管理器，如下：

  1. import urllib, sys
  2. from contextlib import closing
  4. with closing(urllib.urlopen('http://www.yahoo.com')) as f:
  5.     for line in f:
  6.         sys.stdout.write(line)

转载自：【Python学习笔记】with语句与上下文管理器

发表评论

表情：
评论列表 （有 0 条评论，349人围观）

还没有评论，来说两句吧...

相关阅读