Introduction

Yes. Returning from inside a Python with block still triggers cleanup, so a file opened with with open(...) is closed before control leaves the block. That behavior is the whole point of the context manager protocol: cleanup happens on normal completion, on return, and even when an exception is raised.

Why the file still closes

A with statement calls the context manager's __enter__ method when the block starts and its __exit__ method when the block ends. The block can end for several reasons, including falling off the end, hitting return, or raising an exception. In all of those cases, Python still runs __exit__.

1class DemoContext:
2    def __enter__(self):
3        print("enter")
4        return self
5
6    def __exit__(self, exc_type, exc, tb):
7        print("exit")
8
9
10def work():
11    with DemoContext():
12        print("inside")
13        return "done"
14
15
16print(work())

The output shows exit before the function finishes returning. File objects use the same idea internally.

What that means for files

When you write code like this, Python guarantees that the file object's cleanup runs when the block exits.

1from pathlib import Path
2
3
4def first_line(path: Path) -> str:
5    with path.open("r", encoding="utf-8") as handle:
6        return handle.readline().strip()
7
8
9sample = Path("sample.txt")
10sample.write_text("alpha\nbeta\n", encoding="utf-8")
11print(first_line(sample))

This is safe because the file is closed as the with block unwinds. You do not need an extra handle.close() after the return.

return is different from skipping cleanup

Some people mentally model return as a jump that bypasses the rest of the function. That is not how context managers behave. Python translates the with statement into a structure that ensures cleanup still happens.

The important implication is that with is better than manual open and close for early returns. If you open a file manually and forget one return path, you can leak a resource. With a context manager, all exit paths funnel through cleanup.

Exceptions are handled the same way

The guarantee is not limited to return. If an error occurs inside the block, __exit__ still runs.

1from pathlib import Path
2
3path = Path("data.txt")
4path.write_text("42\n", encoding="utf-8")
5
6try:
7    with path.open("r", encoding="utf-8") as handle:
8        value = int(handle.readline())
9        raise RuntimeError("stop here")
10except RuntimeError:
11    print("exception handled")

The file is closed before the exception continues propagating. That is why with is the standard pattern for files, sockets, locks, and database transactions.

You can verify the behavior explicitly

If you want proof in a debugging session, inspect the file outside the block. The file object exposes a closed property.

1handle = None
2with open("sample.txt", "r", encoding="utf-8") as file_handle:
3    handle = file_handle
4    result = file_handle.readline()
5
6print(result.strip())
7print(handle.closed)

After the block ends, handle.closed is True. The same would be true if the block had ended through return.

Use custom context managers the same way

This behavior is not limited to files. Any object that implements the context manager protocol can guarantee cleanup on early return. That is why with is so useful for locks, temporary state changes, and transaction scopes.

Once you understand that return still triggers __exit__, you can structure functions more directly instead of saving results into temporary variables just to avoid an early return.

Common Pitfalls

• Calling close() manually inside the with block even though the context manager already handles it.
• Thinking return skips cleanup and writing more complicated code than necessary.
• Reusing the file handle after the block has ended, which fails because the handle is already closed.
• Confusing file closure with flushing application-level buffers elsewhere in the program.
• Forgetting that custom context managers can suppress exceptions if their __exit__ method is written to do so.

Summary

• Returning inside a with block still closes the file.
• Cleanup happens because Python always calls the context manager's __exit__ method.
• The same guarantee applies when an exception occurs.
• 'with is safer than manual open and close when functions have multiple exit paths.'
• After the block ends, the resource should be treated as closed and no longer reused.