如何防止支持with语句的Python类中enter方法被重复调用

Got it, let's work through this. You want a context manager class where the enter() method (called indirectly by __enter__ for the with statement) only runs once—even if someone accidentally calls it directly, or tries to reuse the same context instance in multiple with blocks. Here's a robust way to implement that:

Modified Implementation #

class Context(object):
    def __init__(self):
        # Use private attributes to signal internal state (underscore is a Python convention)
        self._enter_invoked = False
        self._enter_return_value = None

    def __enter__(self):
        # Delegate to our custom enter() method, which enforces single call
        return self.enter()

    def __exit__(self, exc_type, exc_val, exc_tb):
        # Required signature for __exit__ even if you don't handle exceptions
        self.exit()

    def enter(self):
        """Perform one-time setup and return a boolean status.
        
        Raises RuntimeError if called more than once per instance.
        """
        if self._enter_invoked:
            raise RuntimeError("enter() can only be called once per Context instance")
        
        self._enter_invoked = True
        # Replace this with your actual setup logic
        # Example: simulate a successful setup
        self._enter_return_value = True
        
        return self._enter_return_value

    def exit(self):
        """Add your cleanup logic here (e.g., closing resources, resetting state)"""
        pass

Key Details #

• Single Call Enforcement: The _enter_invoked flag tracks whether enter() has been run. If someone tries to call it again (directly or via reusing the same instance in another with block), we throw a clear RuntimeError—this catches mistakes early instead of silently allowing duplicate setup.
• Preserve Return Value: We store the result of enter() in _enter_return_value—if you prefer to return the same value instead of throwing an error on repeat calls, you could adjust the logic to return self._enter_return_value instead of raising an exception (though raising an error is better for catching misuse).
• Proper __exit__ Signature: The __exit__ method must accept the three exception-related parameters, even if you don't use them. Omitting them will cause a TypeError when the with block exits.

Test Cases #

Correct Usage (Works as Expected) #

with Context() as context:
    if context:
        print("Context setup succeeded!")

Misuse Cases (Caught by Our Checks) #

1. Directly Calling enter() Twice:

   ctx = Context()
   ctx.enter()
   ctx.enter()  # Raises RuntimeError: enter() can only be called once per Context instance
   

2. Reusing the Same Instance in Multiple with Blocks:

   ctx = Context()
   with ctx:
       pass
   with ctx:  # Raises RuntimeError when __enter__ calls enter() again
       pass
   

3. Invalid with Syntax (Fails Independently):
   The error case you mentioned—with Context().enter() as context:—will actually fail on its own, because enter() returns a boolean, which isn't a context manager (it doesn't have __enter__/__exit__ methods). Our code doesn't need to handle this specifically, since Python will throw an AttributeError here before our logic even runs.

内容的提问来源于stack exchange，提问作者ehacinom