Python新增功能 详解上下文管理器(1)(2)

除此之外，还有一些需要强调的事情：

如何处理异常

我们完全忽视了语句块内部可能出现的问题。

如果语句块内部发生了异常，__exit__方法将被调用，而异常将会被重新抛出(re-raised)。当处理文件写入操作时，大部分时间你肯定不希望隐藏这些异常，所以这是可以的。而对于不希望重新抛出的异常，我们可以让__exit__方法简单的返回True来忽略语句块中发生的所有异常(大部分情况下这都不是明智之举)。

我们可以在异常发生时了解到更多详细的信息，完备的__exit__函数签名应该是这样的：

def __exit__(self, exc_type, exc_val, exc_tb) 

这样__exit__函数就能够拿到关于异常的所有信息(异常类型，异常值以及异常追踪信息)，这些信息将帮助异常处理操作。在这里我将不会详细讨论异常处理该如何写，以下是一个示例，只负责抛出SyntaxErrors异常。

class RaiseOnlyIfSyntaxError:  
   
    def __enter__(self):  
        pass 
   
    def __exit__(self, exc_type, exc_val, exc_tb):  
        return SyntaxError != exc_type 

4. 谈一些关于上下文库(contextlib)的内容

contextlib是一个Python模块，作用是提供更易用的上下文管理器。

contextlib.closing

假设我们有一个创建数据库函数，它将返回一个数据库对象，并且在使用完之后关闭相关资源(数据库连接会话等)

我们可以像以往那样处理或是通过上下文管理器：

with contextlib.closing(CreateDatabase()) as database:  
    database.query() 

contextlib.closing方法将在语句块结束后调用数据库的关闭方法。

contextlib.nested

另一个很cool的特性能够有效地帮助我们减少嵌套：

假设我们有两个文件，一个读一个写，需要进行拷贝。

以下是不提倡的：

with open('toReadFile', 'r') as reader:  
    with open('toWriteFile', 'w') as writer:  
        writer.writer(reader.read()) 

可以通过contextlib.nested进行简化：

with contextlib.nested(open('fileToRead.txt', 'r'),  
                       open('fileToWrite.txt', 'w')) as (reader, writer):  
    writer.write(reader.read()) 

在Python2.7中这种写法被一种新语法取代：

with open('fileToRead.txt', 'r') as reader, \  
        open('fileToWrite.txt', 'w') as writer:  
        writer.write(reader.read()) 

contextlib.contextmanager

对于Python高级玩家来说，任何能够被yield关键词分割成两部分的函数，都能够通过装饰器装饰的上下文管理器来实现。任何在yield之前的内容都可以看做在代码块执行前的操作，而任何yield之后的操作都可以放在exit函数中。

这里我举一个线程锁的例子：

锁机制保证两段代码在同时执行时不会互相干扰。例如我们有两块并行执行的代码同时写一个文件，那我们将得到一个混合两份输入的错误文件。但如果我们能有一个锁，任何想要写文件的代码都必须首先获得这个锁，那么事情就好办了。如果你想了解更多关于并发编程的内容，请参阅相关文献。

下面是线程安全写函数的例子：

import threading  
   
lock = threading.Lock()  
   
def safeWriteToFile(openedFile, content):  
    lock.acquire()  
    openedFile.write(content)  
    lock.release() 

接下来，让我们用上下文管理器来实现，回想之前关于yield和contextlib的分析：

@contextlib.contextmanager  
def loudLock():  
    print 'Locking' 
    lock.acquire()  
    yield 
    print 'Releasing' 
    lock.release()  
   
with loudLock():  
    print 'Lock is locked: %s' % lock.locked()  
    print 'Doing something that needs locking' 
   
#Output:  
#Locking  
#Lock is locked: True  
#Doing something that needs locking  
#Releasing 

特别注意，这不是异常安全(exception safe)的写法。如果你想保证异常安全，请对yield使用try语句。幸运的是threading。lock已经是一个上下文管理器了，所以我们只需要简单地：

@contextlib.contextmanager  
def loudLock():  
    print 'Locking' 
    with lock:  
        yield 
    print 'Releasing' 

因为threading.lock在异常发生时会通过__exit__函数返回False，这将在yield被调用是被重新抛出。这种情况下锁将被释放，但对于“print ‘Releasing’”的调用则不会被执行，除非我们重写try-finally。

如果你希望在上下文管理器中使用“as”关键字，那么就用yield返回你需要的值，它将通过as关键字赋值给新的变量。

译文链接： http://blog.jobbole.com/64175/