如何检查一个对象是否是用`with`语句创建的？
How to check if an object is created with `with` statement?
我想确保 class 仅在 "with" 语句中实例化。
即这个还可以：
with X() as x:
...
这不是：
x = X()
我怎样才能保证这样的功能？
据我所知，没有直接的方法。但是，您可以有一个布尔标志，以在调用对象中的实际方法之前检查是否调用了 __enter__。
class MyContextManager(object):
def __init__(self):
self.__is_context_manager = False
def __enter__(self):
print "Entered"
self.__is_context_manager = True
return self
def __exit__(self, exc_type, exc_value, traceback):
print "Exited"
def do_something(self):
if not self.__is_context_manager:
raise Exception("MyContextManager should be used only with `with`")
print "I don't know what I am doing"
与with、
一起使用时
with MyContextManager() as y:
y.do_something()
你会得到
Entered
I don't know what I am doing
Exited
但是，当您手动创建对象并调用 do_something、
x = MyContextManager()
x.do_something()
你会得到
Traceback (most recent call last):
File "/home/thefourtheye/Desktop/Test.py", line 22, in <module>
x.do_something()
File "/home/thefourtheye/Desktop/Test.py", line 16, in do_something
raise Exception("MyContextManager should be used only with `with`")
Exception: MyContextManager should be used only with `with`
注：这不是固解。有人可以在调用任何其他方法之前单独直接调用 __enter__ 方法，在这种情况下可能永远不会调用 __exit__ 方法。
如果你不想在每个函数中重复检查，你可以让它成为一个装饰器，就像这样
class MyContextManager(object):
def __init__(self):
self.__is_context_manager = False
def __enter__(self):
print "Entered"
self.__is_context_manager = True
return self
def __exit__(self, exc_type, exc_value, traceback):
print "Exited"
def ensure_context_manager(func):
def inner_function(self, *args, **kwargs):
if not self.__is_context_manager:
raise Exception("This object should be used only with `with`")
return func(self, *args, **kwargs)
return inner_function
@ensure_context_manager
def do_something(self):
print "I don't know what I am doing"
没有万无一失的方法来确保在 with 子句中构造实例，但您可以在 __enter__ 方法和 return 中创建一个实例，而不是 self;这是将分配给 x 的值。因此，您可以将 X 视为在其 __enter__ 方法中创建实际实例的工厂，例如：
class ActualInstanceClass(object):
def __init__(self, x):
self.x = x
def destroy(self):
print("destroyed")
class X(object):
instance = None
def __enter__(self):
# additionally one can here ensure that the
# __enter__ is not re-entered,
# if self.instance is not None:
# raise Exception("Cannot reenter context manager")
self.instance = ActualInstanceClass(self)
def __exit__(self, exc_type, exc_value, traceback):
self.instance.destroy()
return None
with X() as x:
# x is now an instance of the ActualInstanceClass
当然这仍然是可重用的，但是每个 with 语句都会创建一个新实例。
当然可以手动调用 __enter__，或者获取对 ActualInstanceClass 的引用，但更多的是 滥用 而不是使用。
对于更臭的方法，调用 X() 时实际上会创建一个 XFactory 实例，而不是 X 实例；这又在用作上下文管理器时创建 ActualX 实例，它是 X 的子类，因此 isinstance(x, X) 将 return 为真。
class XFactory(object):
managed = None
def __enter__(self):
if self.managed:
raise Exception("Factory reuse not allowed")
self.managed = ActualX()
return self.managed
def __exit__(self, *exc_info):
self.managed.destroy()
return
class X(object):
def __new__(cls):
if cls == X:
return XFactory()
return super(X, cls).__new__(cls)
def do_foo(self):
print("foo")
def destroy(self):
print("destroyed")
class ActualX(X):
pass
with X() as x:
print(isinstance(x, X)) # yes it is an X instance
x.do_foo() # it can do foo
# x is destroyed
newx = X()
newx.do_foo() # but this can't,
# AttributeError: 'XFactory' object has no attribute 'do_foo'
您可以更进一步，让 XFactory 创建一个带有特殊关键字参数的实际 X 实例 __new__，但我认为它太黑魔法了，没有用处.
不幸的是，你不能很干净。
上下文管理器需要 __enter__ 和 __exit__ 方法，因此您可以使用它在 class 上分配一个成员变量以签入您的代码。
class Door(object):
def __init__(self, state='closed'):
self.state = state
self.called_with_open = False
# When being called as a non-context manger object,
# __enter__ and __exit__ are not called.
def __enter__(self):
self.called_with_open = True
self.state = 'opened'
def __exit__(self, type, value, traceback):
self.state = 'closed'
def was_context(self):
return self.called_with_open
if __name__ == '__main__':
d = Door()
if d.was_context():
print("We were born as a contextlib object.")
with Door() as d:
print('Knock knock.')
有状态对象方法有一个很好的附加好处，即能够判断 __exit__ 方法是否稍后被调用，或者在以后的调用中干净地处理方法要求：
def walk_through(self):
if self.state == 'closed':
self.__enter__
walk()
到目前为止的所有答案都没有提供（我认为）OP 想要的直接。
（我认为）OP 想要这样的东西：
>>> with X() as x:
... # ok
>>> x = X() # ERROR
Traceback (most recent call last):
File "run.py", line 18, in <module>
x = X()
File "run.py", line 9, in __init__
raise Exception("Should only be used with `with`")
Exception: Should only be used with `with`
这是我想出来的，它可能不是很健壮，但我认为它最接近OP的意图。
import inspect
import linecache
class X():
def __init__(self):
if not linecache.getline(__file__,
inspect.getlineno(inspect.currentframe().f_back)).lstrip(
).startswith("with "):
raise Exception("Should only be used with `with`")
def __enter__(self):
return self
def __exit__(self, *exc_info):
pass
只要在使用上下文管理器时 with 与 X() 在同一行，这将给出与我上面显示的完全相同的输出。
这是一个装饰器，可以自动确保方法不会在上下文管理器之外调用：
from functools import wraps
BLACKLIST = dir(object) + ['__enter__']
def context_manager_only(cls):
original_init = cls.__init__
def init(self, *args, **kwargs):
original_init(self, *args, **kwargs)
self._entered = False
cls.__init__ = init
original_enter = cls.__enter__
def enter(self):
self._entered = True
return original_enter(self)
cls.__enter__ = enter
attrs = {name: getattr(cls, name) for name in dir(cls) if name not in BLACKLIST}
methods = {name: method for name, method in attrs.items() if callable(method)}
for name, method in methods.items():
def make_wrapper(method=method):
@wraps(method)
def wrapper_method(self, *args, **kwargs):
if not self._entered:
raise Exception("Didn't get call to __enter__")
return method(self, *args, **kwargs)
return wrapper_method
setattr(cls, name, make_wrapper())
return cls
下面是一个使用示例：
@context_manager_only
class Foo(object):
def func1(self):
print "func1"
def func2(self):
print "func2"
def __enter__(self):
print "enter"
return self
def __exit__(self, *args):
print "exit"
try:
print "trying func1:"
Foo().func1()
except Exception as e:
print e
print "trying enter:"
with Foo() as foo:
print "trying func1:"
foo.func1()
print "trying func2:"
foo.func2()
print "trying exit:"
这是对 的回答。
OP 的问题 , and the 确实（也？）hacky。
我真的不知道 OP 最初的“X 问题”，但我认为其动机并不是字面意义上的“阻止 x = X() ASSIGNMENT 工作”。相反，它可能会强制 API 用户始终使用 x 作为上下文管理器，这样它的 __exit__(...) 就会始终被触发，这就是设计 class X 首先成为上下文管理器。至少，这就是让我参加这个问答的原因 post.
class Holder(object):
def __init__(self, **kwargs):
self._data = allocate(...) # Say, it allocates 1 GB of memory, or a long-lived connection, etc.
def do_something(self):
do_something_with(self._data)
def tear_down(self):
unallocate(self._data)
def __enter__(self):
return self
def __exit__(self, *args):
self.tear_down()
# This is desirable
with Holder(...) as holder:
holder.do_something()
# This might not free the resource immediately, if at all
def foo():
holder = Holder(...)
holder.do_something()
就是说，在学习了这里的所有对话之后，我最终只留下了我的 Holder class as-is，好吧，我只是为我的 [=17 添加了一个文档字符串=]:
def tear_down(self):
"""You are expect to call this eventually; or you can simply use this class as a context manager."""
...
毕竟我们这里都是自愿的成年人...
我想确保 class 仅在 "with" 语句中实例化。
即这个还可以：
with X() as x:
...
这不是：
x = X()
我怎样才能保证这样的功能？
据我所知，没有直接的方法。但是，您可以有一个布尔标志，以在调用对象中的实际方法之前检查是否调用了 __enter__。
class MyContextManager(object):
def __init__(self):
self.__is_context_manager = False
def __enter__(self):
print "Entered"
self.__is_context_manager = True
return self
def __exit__(self, exc_type, exc_value, traceback):
print "Exited"
def do_something(self):
if not self.__is_context_manager:
raise Exception("MyContextManager should be used only with `with`")
print "I don't know what I am doing"
与with、
with MyContextManager() as y:
y.do_something()
你会得到
Entered
I don't know what I am doing
Exited
但是，当您手动创建对象并调用 do_something、
x = MyContextManager()
x.do_something()
你会得到
Traceback (most recent call last):
File "/home/thefourtheye/Desktop/Test.py", line 22, in <module>
x.do_something()
File "/home/thefourtheye/Desktop/Test.py", line 16, in do_something
raise Exception("MyContextManager should be used only with `with`")
Exception: MyContextManager should be used only with `with`
注：这不是固解。有人可以在调用任何其他方法之前单独直接调用 __enter__ 方法，在这种情况下可能永远不会调用 __exit__ 方法。
如果你不想在每个函数中重复检查，你可以让它成为一个装饰器，就像这样
class MyContextManager(object):
def __init__(self):
self.__is_context_manager = False
def __enter__(self):
print "Entered"
self.__is_context_manager = True
return self
def __exit__(self, exc_type, exc_value, traceback):
print "Exited"
def ensure_context_manager(func):
def inner_function(self, *args, **kwargs):
if not self.__is_context_manager:
raise Exception("This object should be used only with `with`")
return func(self, *args, **kwargs)
return inner_function
@ensure_context_manager
def do_something(self):
print "I don't know what I am doing"
没有万无一失的方法来确保在 with 子句中构造实例，但您可以在 __enter__ 方法和 return 中创建一个实例，而不是 self;这是将分配给 x 的值。因此，您可以将 X 视为在其 __enter__ 方法中创建实际实例的工厂，例如：
class ActualInstanceClass(object):
def __init__(self, x):
self.x = x
def destroy(self):
print("destroyed")
class X(object):
instance = None
def __enter__(self):
# additionally one can here ensure that the
# __enter__ is not re-entered,
# if self.instance is not None:
# raise Exception("Cannot reenter context manager")
self.instance = ActualInstanceClass(self)
def __exit__(self, exc_type, exc_value, traceback):
self.instance.destroy()
return None
with X() as x:
# x is now an instance of the ActualInstanceClass
当然这仍然是可重用的，但是每个 with 语句都会创建一个新实例。
当然可以手动调用 __enter__，或者获取对 ActualInstanceClass 的引用，但更多的是 滥用 而不是使用。
对于更臭的方法，调用 X() 时实际上会创建一个 XFactory 实例，而不是 X 实例；这又在用作上下文管理器时创建 ActualX 实例，它是 X 的子类，因此 isinstance(x, X) 将 return 为真。
class XFactory(object):
managed = None
def __enter__(self):
if self.managed:
raise Exception("Factory reuse not allowed")
self.managed = ActualX()
return self.managed
def __exit__(self, *exc_info):
self.managed.destroy()
return
class X(object):
def __new__(cls):
if cls == X:
return XFactory()
return super(X, cls).__new__(cls)
def do_foo(self):
print("foo")
def destroy(self):
print("destroyed")
class ActualX(X):
pass
with X() as x:
print(isinstance(x, X)) # yes it is an X instance
x.do_foo() # it can do foo
# x is destroyed
newx = X()
newx.do_foo() # but this can't,
# AttributeError: 'XFactory' object has no attribute 'do_foo'
您可以更进一步，让 XFactory 创建一个带有特殊关键字参数的实际 X 实例 __new__，但我认为它太黑魔法了，没有用处.
不幸的是，你不能很干净。
上下文管理器需要 __enter__ 和 __exit__ 方法，因此您可以使用它在 class 上分配一个成员变量以签入您的代码。
class Door(object):
def __init__(self, state='closed'):
self.state = state
self.called_with_open = False
# When being called as a non-context manger object,
# __enter__ and __exit__ are not called.
def __enter__(self):
self.called_with_open = True
self.state = 'opened'
def __exit__(self, type, value, traceback):
self.state = 'closed'
def was_context(self):
return self.called_with_open
if __name__ == '__main__':
d = Door()
if d.was_context():
print("We were born as a contextlib object.")
with Door() as d:
print('Knock knock.')
有状态对象方法有一个很好的附加好处，即能够判断 __exit__ 方法是否稍后被调用，或者在以后的调用中干净地处理方法要求：
def walk_through(self):
if self.state == 'closed':
self.__enter__
walk()
到目前为止的所有答案都没有提供（我认为）OP 想要的直接。
（我认为）OP 想要这样的东西：
>>> with X() as x:
... # ok
>>> x = X() # ERROR
Traceback (most recent call last):
File "run.py", line 18, in <module>
x = X()
File "run.py", line 9, in __init__
raise Exception("Should only be used with `with`")
Exception: Should only be used with `with`
这是我想出来的，它可能不是很健壮，但我认为它最接近OP的意图。
import inspect
import linecache
class X():
def __init__(self):
if not linecache.getline(__file__,
inspect.getlineno(inspect.currentframe().f_back)).lstrip(
).startswith("with "):
raise Exception("Should only be used with `with`")
def __enter__(self):
return self
def __exit__(self, *exc_info):
pass
只要在使用上下文管理器时 with 与 X() 在同一行，这将给出与我上面显示的完全相同的输出。
这是一个装饰器，可以自动确保方法不会在上下文管理器之外调用：
from functools import wraps
BLACKLIST = dir(object) + ['__enter__']
def context_manager_only(cls):
original_init = cls.__init__
def init(self, *args, **kwargs):
original_init(self, *args, **kwargs)
self._entered = False
cls.__init__ = init
original_enter = cls.__enter__
def enter(self):
self._entered = True
return original_enter(self)
cls.__enter__ = enter
attrs = {name: getattr(cls, name) for name in dir(cls) if name not in BLACKLIST}
methods = {name: method for name, method in attrs.items() if callable(method)}
for name, method in methods.items():
def make_wrapper(method=method):
@wraps(method)
def wrapper_method(self, *args, **kwargs):
if not self._entered:
raise Exception("Didn't get call to __enter__")
return method(self, *args, **kwargs)
return wrapper_method
setattr(cls, name, make_wrapper())
return cls
下面是一个使用示例：
@context_manager_only
class Foo(object):
def func1(self):
print "func1"
def func2(self):
print "func2"
def __enter__(self):
print "enter"
return self
def __exit__(self, *args):
print "exit"
try:
print "trying func1:"
Foo().func1()
except Exception as e:
print e
print "trying enter:"
with Foo() as foo:
print "trying func1:"
foo.func1()
print "trying func2:"
foo.func2()
print "trying exit:"
这是对
OP 的问题
我真的不知道 OP 最初的“X 问题”，但我认为其动机并不是字面意义上的“阻止 x = X() ASSIGNMENT 工作”。相反，它可能会强制 API 用户始终使用 x 作为上下文管理器，这样它的 __exit__(...) 就会始终被触发，这就是设计 class X 首先成为上下文管理器。至少，这就是让我参加这个问答的原因 post.
class Holder(object):
def __init__(self, **kwargs):
self._data = allocate(...) # Say, it allocates 1 GB of memory, or a long-lived connection, etc.
def do_something(self):
do_something_with(self._data)
def tear_down(self):
unallocate(self._data)
def __enter__(self):
return self
def __exit__(self, *args):
self.tear_down()
# This is desirable
with Holder(...) as holder:
holder.do_something()
# This might not free the resource immediately, if at all
def foo():
holder = Holder(...)
holder.do_something()
就是说，在学习了这里的所有对话之后，我最终只留下了我的 Holder class as-is，好吧，我只是为我的 [=17 添加了一个文档字符串=]:
def tear_down(self):
"""You are expect to call this eventually; or you can simply use this class as a context manager."""
...
毕竟我们这里都是自愿的成年人...