Python 上下文管理器（contextmanager ）

概念：实现了上下文协议的对象即为上下文管理器。参考link

上下文协议：__enter__、__exit__

作用：用于资源的获取和释放。

当我们使用open( )打开一个文件时，要自己进行关闭。此时可以定义上下文管理器进行自动关闭。

例如withopen的用法：

with open（‘文件名’，‘w’） as file：

        file.write(数据)

实现原理：

class File(object):

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

    def __enter__(self):
        print("entering")
        self.f = open(self.filename, self.mode)
        return self.f

    def __exit__(self, *args):
        print("will exit")
        self.f.close()

with File('a.txt', 'w') as file:
    file.write('ssssss')

也就是说，具备了__enter__()和__exit__()方法的类就可以实现上下文管理，从而实现文件的自动关闭

open()函数的实现内部就是使用了以上两种方法

Python 提供了 with 语法用于简化资源操作的后续清除操作，是 try/finally 的替代方法，实现原理建立在上下文管理器之上。此外，Python 还提供了一个 contextmanager 装饰器，更进一步简化上下管理器的实现方式。
 

问题：对于系统资源如文件、数据库连接、socket 而言，应用程序打开这些资源并执行完业务逻辑之后，必须做的一件事就是要关闭（断开）该资源,否则如果在关闭前程序出现了异常进而导致后续代码无法继续执行，close 方法无法被正常调用，因此资源就会一直被该程序占用而无法释放。

解决方法：

      方法1.使用try-finally方式捕获异常的方式

def Method():
    f = open("a.txt", "w")
    try:
        f.write("人生苦短,我用python")
    except IOError:
        print("oops error")
    finally:
        f.close()

改良版本的程序是对可能发生异常的代码处进行 try 捕获，使用 try/finally 语句，该语句表示如果在 try 代码块中程序出现了异常，后续代码就不再执行，而直接跳转到 except 代码块。而无论如何，finally 块的代码最终都会被执行。因此，只要把 close 放在 finally 代码中，文件就一定会关闭。

方法2：使用上下文管理器 。任何实现了 _ enter _ () 和 _ exit _ () 方法的对象都可称之为上下文管理器，上下文管理器对象可以使用 with 关键字。显然，文件（file）对象也是实现了上下文管理器协议。那么文件对象是如何实现这两个方法的呢？我们可以模拟实现一个自己的文件类，让该类实现 _ enter_() 和 _ exit_() 方法。

# 实例:使用上下文管理器实现数据库的封装
from pymysql import connect

class OpenSql(object):
    # 
    def __init__(self, passWord, databaseName):
        self.conn = connect(host="localhost", port=3306, user="root", password=passWord, database=databaseName, charset="utf8")

    def __enter__(self):
        self.cs = self.conn.cursor()
        return self.cs

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.cs.close()
        self.conn.close()

 _ enter_() 方法返回资源对象，这里就是你将要打开的数据库对象，_ exit_() 方法处理一些清除工作。因为 OpenSql 类实现了上下文管理器，现在就可以使用 with 语句了。

# 使用定义好的上下文管理器(Context Manager)
with OpenSql('mysql','TB') as cs:
    sql = 'select * from goods;'
    print(cs.execute(sql), type(cs.execute(sql)))
    data = cs.fetchall()
# 处理数据
for item in data:
    print(item)

方式3：Python 还提供了一个 contextmanager 的装饰器，更进一步简化了上下文管理器的实现方式。通过 yield 将函数分割成两部分，yield 之前的语句在 _ enter_ 方法中执行，yield 之后的语句在 _ exit_ 方法中执行。紧跟在 yield 后面的值是函数的返回值。这种方式需要使用@contextlib装饰器。yield用法简谈

from contextlib import contextmanager

@contextmanager
def MyOpen(path, mode):
    f = open(path, mode)
    yield f
    f.close()

使用定义好的上下文管理器

with MyOpen('a.txt', 'w') as f:
    f.write("Life is short, I use python!")

例子1：锁资源自动获取和释放的例子
@contextmanager
def locked(lock):
    lock.acquire()
    try:
        yield
    finally:
        lock.release()

with locked(myLock):
    #代码执行到这里时，myLock已经自动上锁
    pass
    #执行完后会，会自动释放锁
	


例子2：文件打开后自动管理的实现
@contextmanager
def myopen(filename, mode="r"):
    f = open(filename,mode)
    try:
        yield f
    finally:
        f.close()

with myopen("test.txt") as f:
    for line in f:
        print(line)
		

例子3：数据库事务的处理
@contextmanager
def transaction(db):
    db.begin()
    try：
        yield 
    except:
        db.rollback()
        raise
    else:
        db.commit()

with transaction(mydb):
    mydb.cursor.execute(sql)
    mydb.cursor.execute(sql)
    mydb.cursor.execute(sql)
    mydb.cursor.execute(sql)

三、总结
1、try-expec-finally是我们常用的捕获异常的方式，finally的代码不管程序是否出现异常，都会执行，可以较好的解决文件等需要关闭的操作，但是还不是最优的，他仍然需要程序员手动关闭。 
2、定义上下文管理器（Context Manager）可以帮助程序员很好的解决文件打开或者链接建立等需要频繁关闭的麻烦，也可以避免文件未关闭或链接未有效断开导致不能及时释放空间而造成的资源浪费，推荐使用。

contextmanager应用实例