Detailed explanation of the usage examples of with and contextlib in Python basic tutorial

This article mainly introduces the usage of with and contextlib in Python. It analyzes the functions, usage methods and related precautions of with and contextlib in detail in the form of examples. Friends in need can refer to it

The examples in this article describe the usage of with and contextlib in Python. Share it with everyone for your reference, the details are as follows:

In the normal coding process, the with scenario that is often used is (opening a file for file processing, and then implicitly executing the closing of the file handle, which is also suitable for sockets) Classes, these classes provide support for with):

with file('test.py','r') as f :
  print f.readline()

The role of with is similar to try...finally..., providing a context mechanism, To apply the with statement, the class must provide two built-in functions __enter__ and __exit__. The former is executed before the main code is executed, and the latter is executed after the main code is executed. The variables after as are returned in the __enter__ function. Through the following code snippet and comments, you can clearly understand the usage of __enter__ and __exit__:

##

#!encoding:utf-8
class echo :
  def output(self) :
    print 'hello world'
  def __enter__(self):
    print 'enter'
    return self #返回自身实例，当然也可以返回任何希望返回的东西
  def __exit__(self, exception_type, exception_value, exception_traceback):
    #若发生异常，会在这里捕捉到，可以进行异常处理
    print 'exit'
    #如果改__exit__可以处理改异常则通过返回True告知该异常不必传播，否则返回False
    if exception_type == ValueError :
      return True
    else:
      return False
with echo() as e:
  e.output()
  print 'do something inside'
print '-----------'
with echo() as e:
  raise ValueError('value error')
print '-----------'
with echo() as e:
  raise Exception('can not detect')

Running results:

contextlib is a module that strengthens the with statement and provides a context mechanism. It is implemented through Generator. Context management by defining classes and writing __enter__ and __exit__ is not difficult, but it is tedious. The contextmanager in contextlib serves as a decorator to provide a function-level context management mechanism. Commonly used frameworks are as follows:

from contextlib import contextmanager
@contextmanager
def make_context() :
  print 'enter'
  try :
    yield {}
  except RuntimeError, err :
    print 'error' , err
  finally :
    print 'exit'
with make_context() as value :
  print value

contextlib also has two important things, one is nested and the other is closing. The former is used to create nested contexts, and the latter is used to Help you execute the defined close function. But nested is obsolete, because with can already be directly nested through multiple contexts. Here is an example:

from contextlib import contextmanager
from contextlib import nested
from contextlib import closing
@contextmanager
def make_context(name) :
  print 'enter', name
  yield name
  print 'exit', name
with nested(make_context('A'), make_context('B')) as (a, b) :
  print a
  print b
with make_context('A') as a, make_context('B') as b :
  print a
  print b
class Door(object) :
  def open(self) :
    print 'Door is opened'
  def close(self) :
    print 'Door is closed'
with closing(Door()) as door :
  door.open()

Running results:

Summary: Python has many Powerful features, because we are usually accustomed to some previous programming habits of C++ or Java, we often overlook these good mechanisms. Therefore, we must learn to use these python features to make the python programs we write more like python.

The above is the detailed content of Detailed explanation of the usage examples of with and contextlib in Python basic tutorial. For more information, please follow other related articles on the PHP Chinese website!