Python中return self的作用与适用场景？结合上下文管理器实例解惑

Great question! Let's unpack why your output stays the same, and when return self in a context manager actually matters.

First, let's recap your two code snippets to set the stage:

Original code with return self #

from contextlib import contextmanager, ContextDecorator

class makepara(ContextDecorator):
    def __enter__(self):
        print("<p>")
        return self  # This line is present here
    
    def __exit__(self, *args):
        print("</p>")
        return False

@makepara()
def emit_data():
    print(" here is HTML code")

emit_data()

Modified code without return self #

from contextlib import contextmanager, ContextDecorator

class makepara(ContextDecorator):
    def __enter__(self):
        print("<p>")
        # No return statement here
    
    def __exit__(self, *args):
        print("</p>")

@makepara()
def emit_data():
    print(" here is HTML code")

emit_data()

Both snippets output:

<p>
 here is HTML code
</p>

Why the output doesn't change #

In your example, you're using makepara as a decorator via ContextDecorator. When you decorate a function with a ContextDecorator subclass, the decorator wraps the function to run it inside the context manager—but it doesn't capture or use the return value of __enter__ at all. The only thing that matters here is that __enter__ runs before the function, and __exit__ runs after. So omitting return self has no visible effect in this specific usage.

When return self actually matters #

return self becomes critical when you use the context manager with the with ... as syntax, or when you need to interact with the context manager instance inside the context block. Here are the key scenarios:

1. Accessing the context instance with with ... as #

If you write:

with makepara() as para_instance:
    # Do something with para_instance

The variable para_instance will be set to whatever __enter__ returns.

• If __enter__ returns self, para_instance is the actual makepara object, so you can call methods or access attributes on it.
• If you omit the return, para_instance will be None, and any attempt to use it will throw an error.

Let's extend your class to show this:

class makepara(ContextDecorator):
    def __enter__(self):
        print("<p>")
        return self  # Now this matters
    
    def __exit__(self, *args):
        print("</p>")
    
    def add_class(self, class_name):
        print(f'Adding class "{class_name}" to paragraph')

# Using with ... as to access the instance
with makepara() as p:
    p.add_class("highlight")
    print(" here is HTML code")

This outputs:

<p>
Adding class "highlight" to paragraph
 here is HTML code
</p>

If you removed return self, p would be None, and p.add_class(...) would raise an AttributeError.

2. Maintaining state between __enter__ and __exit__ #

Sometimes context managers track state that needs to be modified inside the context block. Returning self lets you update that state, which __exit__ can then use.

For example, a context manager that tracks whether an error occurred:

class ErrorTracker(ContextDecorator):
    def __enter__(self):
        self.error_occurred = False
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.error_occurred:
            print("An error was caught during execution")
        return False  # Don't suppress exceptions

with ErrorTracker() as tracker:
    try:
        1 / 0
    except ZeroDivisionError:
        tracker.error_occurred = True

Here, return self lets us update tracker.error_occurred inside the block, which __exit__ then checks to print a message. Without returning self, we couldn't access the error_occurred attribute.

3. Supporting method chaining #

Less common, but if your context manager has methods that return the instance, returning self from __enter__ lets you chain calls when entering the context:

class ConfigManager(ContextDecorator):
    def __enter__(self):
        self.config = {}
        return self
    
    def set(self, key, value):
        self.config[key] = value
        return self
    
    def __exit__(self, *args):
        print(f"Saving config: {self.config}")

with ConfigManager() as cfg:
    cfg.set("theme", "dark").set("font_size", 14)

This works because __enter__ returns the instance, allowing us to chain set() calls immediately.

Summary #

• In your decorator-only usage, return self doesn't affect output because the decorator doesn't use the return value of __enter__.
• Use return self when:
  • You need to access the context manager instance via with ... as.
  • You need to modify or read state on the instance inside the context block.
  • You want to support method chaining with the context instance.

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