解释Python的'__enter__'和'__exit__'


360

我在某人的代码中看到了这一点。这是什么意思?

    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


7
@StevenVascellaro编辑问题代码通常不是一个好主意,尤其是当代码中有错误时。这个问题是在考虑Py2的情况下提出的,因此没有理由将其更新为Py3。
jpaugh

Answers:


419

使用这些魔术方法(__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语句一起使用(from __future__ import with_statement如果您使用的是Python 2.5,则可能需要在文件顶部执行此操作)。

with DatabaseConnection() as mydbconn:
    # do stuff

PEP343-'with'语句'也有不错的写法。


20
可能__enter__self始终返回,因为这样只能在上下文中调用该类的其他方法。
ViFI '16

3
@ViFI def __enter__(self)在PEP 343中有4个示例,没有一个示例return selfpython.org/dev/peps/pep-0343。你为什么这么认为?
悲伤

4
@Grief:有两个原因,我认为:1)我将无法self按以下说明在对象上调用其他方法:stackoverflow.com/questions/38281853/…2)self.XYZ只是self对象的一部分,并且从维护的角度来看,仅将手柄归还给我似乎不合适。我宁愿返回句柄以完成对象,然后仅向那些组件self对象提供公共API ,我希望向用户公开这些对象,例如 with open(abc.txt, 'r') as fin: content = fin.read()
ViFI 2016年

4
文件对象self从返回__enter__,这就是您可以在f内部处理文件的方式with open(...) as f
holdenweb

2
我必须了解的一个微妙之处:如果对象需要参数进行初始化,则这些参数应位于init而不是self上
dfrankow

70

如果您知道上下文管理器是什么,那么您就不需要了解__enter__和使用__exit__魔术方法。让我们看一个非常简单的例子。

在此示例中,我将借助open函数打开myfile.txt。在尝试/终于块确保即使发生意外的异常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)attribute 来检查它-返回True

这是因为open函数返回的文件对象(在我的示例中为fp)具有两个内置方法__enter____exit__。它也称为上下文管理器。__enter__方法在with块的开头__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__


52

我发现通过Googling 定位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是Exception实例。

大概traceback是一个Python 回溯对象。


2
同意。这个网址很难找到。
Shihao Xu

可能很重要的一点是要注意PEP参考文件中的此埋藏位,并注意使用arg:python.org/dev/peps/pep-0343/#generator-decorator
Tcll

43

除了上述答案以例证调用顺序外,一个简单的运行示例

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

3
并且即使定义的顺序被切换,执行顺序也保持不变!
肖恩

1
这非常有帮助。谢谢。
Reez0

5

尝试添加我的答案(我的学习思想):

__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

服务器端的结果与以前相同

对不起,我的英语不好,解释不清楚,谢谢。


1

这称为上下文管理器,我只想补充一下,其他编程语言也存在类似的方法。比较它们可能有助于理解python中的上下文管理器。基本上,当我们处理一些需要初始化的资源(文件,网络,数据库),并且在某些时候需要拆除(配置)时,使用上下文管理器。在Java 7及更高版本中,我们具有以下形式的自动资源管理:

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

请注意,会话需要实现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语句来实现相同的机制。这只是语法糖。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.