应用DataAdapter对象更新数据库中的数据

with 与 上下文管理器

提示：前面的内容较为基础，重点知识在后半段。

with 这个关键字，对于每一学习Python的人，都不会陌生。

操作文本对象的时候，几乎所有的人都会让我们要用 with open ，这就是一个上下文管理的例子。你一定已经相当熟悉了，我就不再废话了。

with open('test.txt') as f:
    print f.readlines()

1.14.1 what context manager？

基本语法

with EXPR as VAR:
    BLOCK

先理清几个概念

1. 上下文表达式：with open('test.txt') as f:
2. 上下文管理器：open('test.txt')
3. f 不是上下文管理器，应该是资源对象。

1.14.2 how context manager？

要自己实现这样一个上下文管理，要先知道上下文管理协议。

简单点说，就是在一个类里，实现了__enter__和__exit__的方法，这个类的实例就是一个上下文管理器。

例如这个示例：

class Resource():
    def __enter__(self):
        print('===connect to resource===')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('===close resource connection===')

    def operate(self):
        print('===in operation===')

with Resource() as res:
    res.operate()

我们执行一下，通过日志的打印顺序。可以知道其执行过程。

===connect to resource===
===in operation===
===close resource connection===

从这个示例可以很明显的看出，在编写代码时，可以将资源的连接或者获取放在__enter__中，而将资源的关闭写在__exit__ 中。

1.14.3 why context manager？

学习时多问自己几个为什么，养成对一些细节的思考，有助于加深对知识点的理解。

为什么要使用上下文管理器？

在我看来，这和 Python 崇尚的优雅风格有关。

1. 可以以一种更加优雅的方式，操作（创建/获取/释放）资源，如文件操作、数据库连接；
2. 可以以一种更加优雅的方式，处理异常；

第一种，我们上面已经以资源的连接为例讲过了。

而第二种，会被大多数人所忽略。这里会重点讲一下。

大家都知道，处理异常，通常都是使用 try...execept.. 来捕获处理的。这样做一个不好的地方是，在代码的主逻辑里，会有大量的异常处理代理，这会很大的影响我们的可读性。

好一点的做法呢，可以使用 with 将异常的处理隐藏起来。

仍然是以上面的代码为例，我们将1/0 这个一定会抛出异常的代码写在 operate 里

class Resource():
    def __enter__(self):
        print('===connect to resource===')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('===close resource connection===')
        return True

    def operate(self):
        1/0

with Resource() as res:
    res.operate()

运行一下，惊奇地发现，居然不会报错。

这就是上下文管理协议的一个强大之处，异常可以在__exit__ 进行捕获并由你自己决定如何处理，是抛出呢还是在这里就解决了。在__exit__ 里返回 True（没有return 就默认为 return False），就相当于告诉 Python解释器，这个异常我们已经捕获了，不需要再往外抛了。

在 写__exit__ 函数时，需要注意的事，它必须要有这三个参数：

• exc_type：异常类型
• exc_val：异常值
• exc_tb：异常的错误栈信息

当主逻辑代码没有报异常时，这三个参数将都为None。

1.14.4 how contextlib?

在上面的例子中，我们只是为了构建一个上下文管理器，却写了一个类。如果只是要实现一个简单的功能，写一个类未免有点过于繁杂。这时候，我们就想，如果只写一个函数就可以实现上下文管理器就好了。

这个点Python早就想到了。它给我们提供了一个装饰器，你只要按照它的代码协议来实现函数内容，就可以将这个函数对象变成一个上下文管理器。

我们按照 contextlib 的协议来自己实现一个打开文件（with open）的上下文管理器。

import contextlib

@contextlib.contextmanager
def open_func(file_name):
    # __enter__方法
    print('open file:', file_name, 'in __enter__')
    file_handler = open(file_name, 'r')

    # 【重点】：yield
    yield file_handler

    # __exit__方法
    print('close file:', file_name, 'in __exit__')
    file_handler.close()
    return

with open_func('/Users/MING/mytest.txt') as file_in:
    for line in file_in:
        print(line)

在被装饰函数里，必须是一个生成器（带有yield），而yield之前的代码，就相当于__enter__里的内容。yield 之后的代码，就相当于__exit__ 里的内容。

上面这段代码只能实现上下文管理器的第一个目的（管理资源），并不能实现第二个目的（处理异常）。

如果要处理异常，可以改成下面这个样子。

import contextlib

@contextlib.contextmanager
def open_func(file_name):
    # __enter__方法
    print('open file:', file_name, 'in __enter__')
    file_handler = open(file_name, 'r')

    try:
        yield file_handler
    except Exception as exc:
        # deal with exception
        print('the exception was thrown')
    finally:
        print('close file:', file_name, 'in __exit__')
        file_handler.close()

        return

with open_func('/Users/MING/mytest.txt') as file_in:
    for line in file_in:
        1/0
        print(line)

好像只要讲到上下文管理器，大多数人都会谈到打开文件这个经典的例子。

但是在实际开发中，可以使用到上下文管理器的例子也不少。我这边举个我自己的例子。

在OpenStack中，给一个虚拟机创建快照时，需要先创建一个临时文件夹，来存放这个本地快照镜像，等到本地快照镜像创建完成后，再将这个镜像上传到Glance。然后删除这个临时目录。

这段代码的主逻辑是创建快照，而创建临时目录，属于前置条件，删除临时目录，是收尾工作。

虽然代码量很少，逻辑也不复杂，但是“创建临时目录，使用完后再删除临时目录”这个功能，在一个项目中很多地方都需要用到，如果可以将这段逻辑处理写成一个工具函数作为一个上下文管理器，那代码的复用率也大大提高。

代码是这样的

总结起来，使用上下文管理器有三个好处：

1. 提高代码的复用率；
2. 提高代码的优雅度；
3. 提高代码的可读性；

Python面试题：with的用法与自我实现

with 语句的作用
with 语句的基本作用：构建对资源创建与释放的

with open('a','r) as f:
    for line in f:
        print line.strip()
以上代码使用with as 语句来操作一个文件，其作用为 打开一个文件，如果一切正常则，将文件对下赋值给f，然后使用迭代器遍历文件中的每一行，当最终遍历完成后，再关闭文件。且即使发生了异常，该文件仍然会被关闭。

with执行原理
当with 执行时，执行 上下文表达式（context_expr) 来获得一个上下文管理器，上下文管理器的职责是提供一个上下文对象，用于在with语句块中处理细节：
1、 一旦获取的上下文对象，就会调用它的 enter() 方法，将完成 with语句 块执行前的所有准备功能工作。
2、如果with 语句后面跟了 as 语句，则用 enter() 方法的返回值来赋值；
3、当with语句块结束时，无论是正常结束，还是由于异常，都会调用上下文对象的__exit__()方法，exit()方法有3个参数，如果with语句正常结束，三个参数全部都是 None；如果发生异常，三个参数的值分别等于调用sys.exc_info()函数返回的三个值：类型（异常类）、值（异常实例）和跟踪记录（traceback），相应的跟踪记录对象。

with支持对象
通过以上的原理可以知道，我们不能对任意的python 对象都使用 with 语句， 对象需要支持 上下文管理协议。
也就是说，只有内建了“上下文管理”的对象可以和with一起工作，目前支持该协议的对象有：

file
decimal.Context
thread.LockType
threading.Lock
threading.RLock
threading.Condition
threading.Semaphore
threading.BoundedSemaphore
with语句的自我实现
通过以上的运行原理可知，我们可以在类中自行创建 enter() 和 exit() 方法，来配合 with 语句创建类实例：

class Test:
    def __enter__(self):
        print 'begin connect ...'

    def __exit__(self,exc_type, exc_val, exc_tb):
        print 'close connect...'

if __name__ == '__main__':
    with Test() as f:
        print 'run...'
with语句的自我实现
通过调用 python 的 contextlib 模块，可以不需要构造含有 enter,exit 的类就可以使用with, 注意需结合yield 使用 (目前仅知道该用法）

from contextlib import contextmanager

@contextmanager
def test():
    print 'begin connect ...'
    yield 'ddd'
    print 'close connect...'

if __name__ == '__main__':
    #未赋值，则不输出函数中的返回值
    with test():
        print 'a'
        #赋值，输出函数中的返回值
    with test() as f:
        print f
        print 'a'
python 上下文管理协议
上下文管理协议 即 enter 和 exit

python 上下文管理器（Contextor）
上下文管理器即 实现了 上下文管理协议，当Contextor 调用/实例化时，则创建了 上下文管理器，类似实现迭代器协议类调用生成迭代器一样。运行的执行原理：

1、执行contextor 以获取上下文管理器
2、加载上下文管理器的exit()方法，备用
3、调用上下文管理器的enter()方法
4、如果有 as 语句，则将enter() 方法的返回值赋值给 变量名
5、执行语句with 中的代码
6、调用上下文管理器的 exit() 方法，如果退出使用由于异常导致的，那么该异常的 type、value 和 traceback 会作为参数传给 exit()，否则传三个 None

　test