使用这些神奇的方法（__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()
        ...

字符串
如上所述，将此对象与with语句一起使用（如果使用的是Python 2.5，则可能需要在文件的顶部执行from __future__ import with_statement）。

with DatabaseConnection() as mydbconn:
    # do stuff

型
PEP343 -- The 'with' statement'也有不错的文章。

如果你知道什么是上下文管理器，那么你就不需要更多的东西来理解__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__。它也被称为上下文管理器。__enter__方法在with块的开头被调用，__exit__方法在结尾被调用。
注意事项：with语句只适用于支持上下文管理协议的对象（即它们具有__enter__和__exit__方法）。实现这两种方法的类称为上下文管理器类。
现在让我们定义我们自己的context manager类。

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__魔术方法都有了基本的了解。

我发现通过Google查找__enter__和__exit__方法的python文档非常困难，所以为了帮助其他人，以下链接是：
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。
如果提供了一个异常，并且该方法希望抑制该异常（即，阻止其传播），则它应该返回一个true值。否则，在退出该方法时，将正常处理该异常。
请注意，__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的traceback对象。
请注意，此处还有更多文档：
https://docs.python.org/3/library/stdtypes.html#context-manager-types
...他们对__enter__和__exit__方法有更详细的解释，特别是__exit__应该返回一个布尔值（尽管真或假都可以，例如隐式的None返回将给予传播异常的默认行为）。

除了上面对EJB调用顺序的回答之外，

class MyClass:
    def __init__(self):
        print("__init__")

    def __enter__(self): 
        print("__enter__")

    def __exit__(self, ex_type, ex_value, ex_traceback):
        print("__exit__")
    
    def __del__(self):
        print("__del__")
    
with MyClass(): 
    print("body")

字符串
生成输出：

__init__
__enter__
body
__exit__
__del__

型
提醒一下：当使用语法with MyClass() as my_handler时，变量my_handler获取__enter__()返回的值，在上面的情况下为None！对于这样的使用，需要定义返回值，例如：

def __enter__(self): 
    print('__enter__')
    return self

型

试着加上我的答案（我对学习的想法）：
__enter__和[__exit__]都是在进入和退出“the with statement”（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'

型
现在手动尝试（遵循translate语法）：

>>> 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

型
服务器端的结果和以前一样
对不起，我的英语不好，我的解释不清楚，谢谢你。

这被称为上下文管理器，我只是想补充一下，其他编程语言也存在类似的方法。比较它们有助于理解Python中的上下文管理器。基本上，当我们处理一些资源时，会使用上下文管理器。（文件、网络、数据库）需要初始化，并且在某些时候，在Java 7及更高版本中，我们有自动资源管理，其形式为：

//Java code
try (Session session = new Session())
{
  // do stuff
}

字符串
请注意，Session需要实现AutoClosable或它的一个（许多）子接口。
在**C#**中，我们有using语句来管理资源，其形式如下：

//C# code
using(Session session = new Session())
{
  ... do stuff.
}

型
其中Session应该实现IDisposable。
在python中，我们使用的类应该实现__enter__和__exit__。所以它的形式是：

#Python code
with Session() as session:
    #do stuff

型
正如其他人指出的，你可以在所有的语言中使用try/finally语句来实现相同的机制，这只是语法糖。

当执行进入with语句的上下文并且是时候获取资源时，Python调用__enter__。当执行再次离开上下文时，Python调用__exit__来释放资源
让我们考虑一下Python中的上下文管理器和“with”语句。（或接口），这样它就可以与with语句一起使用。基本上，您需要做的就是添加enter和exit如果你想让一个对象作为一个上下文管理器，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提供的内容匹配，这可以让您的生活更轻松。