我在某人的代码中看到了这一点。这是什么意思？
def __enter__(self):
return self
def __exit__(self, type, value, tb):
self.stream.close()
from __future__ import with_statement#for python2.5
class a(object):
def __enter__(self):
print 'sss'
return 'sss111'
def __exit__(self ,type, value, traceback):
print 'ok'
return False
with a() as s:
print s
print s
使用这些神奇的方法 ( __enter__, __exit__) 可以让您实现可以在with语句中轻松使用的对象。
这个想法是，它可以很容易地构建需要执行一些“清理”代码的代码（将其视为一个try-finally块）。这里有更多的解释。
一个有用的示例可能是数据库连接对象（一旦相应的“with”语句超出范围，它就会自动关闭连接）：
class DatabaseConnection(object):
def __enter__(self):
# make a database connection and return it
...
return self.dbconn
def __exit__(self, exc_type, exc_val, exc_tb):
# make sure the dbconnection gets closed
self.dbconn.close()
...
如上所述，将此对象与语句一起使用（如果您使用的是 Python 2.5，则with可能需要在文件顶部执行此操作）。from __future__ import with_statement
with DatabaseConnection() as mydbconn:
# do stuff
PEP343 - 'with' 语句'也有很好的文章。
如果您知道上下文管理器是什么，那么您不需要更多了解__enter__和__exit__魔术方法。让我们看一个非常简单的例子。
在这个例子中，我在open函数的帮助下打开myfile.txt文件。try / finally块确保即使发生意外异常myfile.txt也会被关闭。
fp=open(r"C:\Users\SharpEl\Desktop\myfile.txt")
try:
for line in fp:
print(line)
finally:
fp.close()
现在我用with语句打开同一个文件：
with open(r"C:\Users\SharpEl\Desktop\myfile.txt") as fp:
for line in fp:
print(line)
如果您查看代码，我没有关闭文件并且没有try/finally块。因为with语句会自动关闭 myfile.txt。您甚至可以通过调用print(fp.closed)返回的属性来检查它True。
这是因为open函数返回的文件对象（在我的示例中为 fp）有两个内置方法__enter__和__exit__. 它也被称为上下文管理器。方法在with块__enter__的开头调用， 方法在结尾调用。__exit__
注意：with语句仅适用于支持上下文管理协议的对象（即它们具有__enter__和__exit__方法）。实现这两种方法的类称为上下文管理器类。
现在让我们定义我们自己的上下文管理器类。
class Log:
def __init__(self,filename):
self.filename=filename
self.fp=None
def logging(self,text):
self.fp.write(text+'\n')
def __enter__(self):
print("__enter__")
self.fp=open(self.filename,"a+")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("__exit__")
self.fp.close()
with Log(r"C:\Users\SharpEl\Desktop\myfile.txt") as logfile:
print("Main")
logfile.logging("Test1")
logfile.logging("Test2")
__enter__我希望您现在对这两种方法和__exit__魔术方法都有基本的了解。
我发现通过谷歌搜索很难找到 python 文档__enter__和__exit__方法，所以为了帮助其他人，这里是链接：
https://docs.python.org/2/reference/datamodel.html#with-statement-context-managers
https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers
（两个版本的细节相同）
object.__enter__(self)
输入与此对象相关的运行时上下文。该with语句将将此方法的返回值绑定到该语句的 as 子句中指定的目标（如果有）。
object.__exit__(self, exc_type, exc_value, traceback)
退出与此对象相关的运行时上下文。参数描述导致上下文退出的异常。如果上下文无异常退出，则所有三个参数都是None.如果提供了一个异常，并且该方法希望抑制该异常（即，防止它被传播），它应该返回一个真值。否则，异常将在退出该方法时正常处理。
请注意，
__exit__()方法不应重新引发传入的异常；这是调用者的责任。
我希望能清楚地描述__exit__方法参数。这是缺乏的，但我们可以推断出它们......
大概exc_type是类的异常。
它说您不应该重新引发传入的异常。这向我们表明，其中一个参数可能是一个实际的 Exception 实例……或者您应该自己从类型和值中实例化它？
我们可以通过查看这篇文章来回答： http:
//effbot.org/zone/python-with-statement.htm
例如，以下
__exit__方法吞下任何 TypeError，但允许所有其他异常通过：
def __exit__(self, type, value, traceback):
return isinstance(value, TypeError)
...很明显value是一个异常实例。
并且大概traceback是一个 Python回溯对象。
除了以上举例说明调用顺序的答案，一个简单的运行示例
class myclass:
def __init__(self):
print("__init__")
def __enter__(self):
print("__enter__")
def __exit__(self, type, value, traceback):
print("__exit__")
def __del__(self):
print("__del__")
with myclass():
print("body")
产生输出：
__init__
__enter__
body
__exit__
__del__
提醒：当使用语法时with myclass() as mc，变量 mc 获取返回的值__enter__()，在上述情况下None！对于这样的使用，需要定义返回值，如：
def __enter__(self):
print('__enter__')
return self
This is called context manager and I just want to add that similar approaches exist for other programming languages. Comparing them could be helpful in understanding the context manager in python. Basically, a context manager is used when we are dealing with some resources (file, network, database) that need to be initialized and at some point, tear downed (disposed). In Java 7 and above we have automatic resource management that takes the form of:
//Java code
try (Session session = new Session())
{
// do stuff
}
Note that Session needs to implement AutoClosable or one of its (many) sub-interfaces.
In C#, we have using statements for managing resources that takes the form of:
//C# code
using(Session session = new Session())
{
... do stuff.
}
In which Session should implement IDisposable.
In python, the class that we use should implement __enter__ and __exit__. So it takes the form of:
#Python code
with Session() as session:
#do stuff
And as others pointed out, you can always use try/finally statement in all the languages to implement the same mechanism. This is just syntactic sugar.
尝试添加我的答案（我的学习想法）：
__enter__并且[__exit__]两者都是在进入和退出“ with语句”（PEP 343）的主体时调用的方法，并且两者的实现都称为上下文管理器。
with 语句旨在隐藏 try finally 子句的流程控制，使代码难以理解。
with 语句的语法是：
with EXPR as VAR:
BLOCK
转换为（如 PEP 343 中所述）：
mgr = (EXPR)
exit = type(mgr).__exit__ # Not calling it yet
value = type(mgr).__enter__(mgr)
exc = True
try:
try:
VAR = value # Only if "as VAR" is present
BLOCK
except:
# The exceptional case is handled here
exc = False
if not exit(mgr, *sys.exc_info()):
raise
# The exception is swallowed if exit() returns true
finally:
# The normal and non-local-goto cases are handled here
if exc:
exit(mgr, None, None, None)
尝试一些代码：
>>> import logging
>>> import socket
>>> import sys
#server socket on another terminal / python interpreter
>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
>>> s.listen(5)
>>> s.bind((socket.gethostname(), 999))
>>> while True:
>>> (clientsocket, addr) = s.accept()
>>> print('get connection from %r' % addr[0])
>>> msg = clientsocket.recv(1024)
>>> print('received %r' % msg)
>>> clientsocket.send(b'connected')
>>> continue
#the client side
>>> class MyConnectionManager:
>>> def __init__(self, sock, addrs):
>>> logging.basicConfig(level=logging.DEBUG, format='%(asctime)s \
>>> : %(levelname)s --> %(message)s')
>>> logging.info('Initiating My connection')
>>> self.sock = sock
>>> self.addrs = addrs
>>> def __enter__(self):
>>> try:
>>> self.sock.connect(addrs)
>>> logging.info('connection success')
>>> return self.sock
>>> except:
>>> logging.warning('Connection refused')
>>> raise
>>> def __exit__(self, type, value, tb):
>>> logging.info('CM suppress exception')
>>> return False
>>> addrs = (socket.gethostname())
>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
>>> with MyConnectionManager(s, addrs) as CM:
>>> try:
>>> CM.send(b'establishing connection')
>>> msg = CM.recv(1024)
>>> print(msg)
>>> except:
>>> raise
#will result (client side) :
2018-12-18 14:44:05,863 : INFO --> Initiating My connection
2018-12-18 14:44:05,863 : INFO --> connection success
b'connected'
2018-12-18 14:44:05,864 : INFO --> CM suppress exception
#result of server side
get connection from '127.0.0.1'
received b'establishing connection'
现在手动尝试（按照翻译语法）：
>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #make new socket object
>>> mgr = MyConnection(s, addrs)
2018-12-18 14:53:19,331 : INFO --> Initiating My connection
>>> ext = mgr.__exit__
>>> value = mgr.__enter__()
2018-12-18 14:55:55,491 : INFO --> connection success
>>> exc = True
>>> try:
>>> try:
>>> VAR = value
>>> VAR.send(b'establishing connection')
>>> msg = VAR.recv(1024)
>>> print(msg)
>>> except:
>>> exc = False
>>> if not ext(*sys.exc_info()):
>>> raise
>>> finally:
>>> if exc:
>>> ext(None, None, None)
#the result:
b'connected'
2018-12-18 15:01:54,208 : INFO --> CM suppress exception
服务器端的结果和以前一样
对不起我的英语不好和我不清楚的解释，谢谢....
__enter__当执行进入 with 语句的上下文并且是时候获取资源时，Python 调用。当执行再次离开上下文时，Python 调用__exit__以释放资源
让我们考虑一下上下文管理器和 Python 中的“with”语句。上下文管理器是一个简单的“协议”（或接口），您的对象需要遵循它，因此它可以与 with 语句一起使用。基本上，如果您希望对象用作上下文管理器，您需要做的就是向对象添加进入和退出方法。Python 会在资源管理周期的适当时候调用这两个方法。
让我们来看看这在实际中会是什么样子。下面是 open() 上下文管理器的简单实现的样子：
class ManagedFile:
def __init__(self, name):
self.name = name
def __enter__(self):
self.file = open(self.name, 'w')
return self.file
def __exit__(self, exc_type, exc_val, exc_tb):
if self.file:
self.file.close()
我们的 ManagedFile 类遵循上下文管理器协议，现在支持 with 语句。
>>> with ManagedFile('hello.txt') as f:
... f.write('hello, world!')
... f.write('bye now')`enter code here`
当执行进入 with 语句的上下文并且是时候获取资源时，Python 调用enter 。当执行再次离开上下文时，Python 调用exit来释放资源。
编写基于类的上下文管理器并不是在 Python 中支持 with 语句的唯一方法。标准库中的 contextlib 实用程序模块提供了一些构建在基本上下文管理器协议之上的抽象。如果您的用例与 contextlib 提供的相匹配，这可以让您的生活更轻松。