The with statement wraps a block of code in a context manager, guaranteeing that setup and cleanup logic (like opening and closing a file) run automatically, even if an exception occurs.

Syntax

with open("file.txt") as f:
    data = f.read()
# f is automatically closed here

Deep Dive Course

A with statement calls the context manager's __enter__ method at the start of the block, binding whatever it returns to the `as` name, and guarantees the context manager's __exit__ method runs when the block ends — whether it ends normally or because an exception was raised inside it. For files, __enter__ returns the file object itself and __exit__ closes it, which is why using with for files is the standard, safe way to work with them instead of manually pairing open() with close(). Multiple context managers can be combined in one with statement, and it's not limited to files — locks, database connections, and many other resources implement the same protocol.

1Understanding with Statement

A with statement calls the context manager's __enter__ method at the start of the block, binding whatever it returns to the as name, and guarantees the context manager's __exit__ method runs when the block ends — whether it ends normally or because an exception was raised inside it. For files, __enter__ returns the file object itself and __exit__ closes it, which is why using with for files is the standard, safe way to work with them instead of manually pairing open() with close(). Multiple context managers can be combined in one with statement, and it's not limited to files — locks, database connections, and many other resources implement the same protocol.

💡

Any object that implements __enter__ and __exit__ works with `with` — you can write your own context manager for any 'setup, then guaranteed cleanup' pattern, not just file handling, often more concisely using the contextmanager decorator from the contextlib module.

editor.html

with open("data.txt", "w") as f:
    f.write("Some data")
print(f.closed)

localhost:3000

2Practical Example

Here is a real-world application of with Statement showing how it is used in production Python code.

editor.html

class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        print(f"Elapsed: {time.time() - self.start:.2f}s")

with Timer():
    total = sum(range(1000000))

localhost:3000

3Best Practices

Follow these guidelines when working with with Statement:

1. Use with open(...) as f: instead of manual open()/close() pairs for every file operation

2. Write your own context manager, via a class with __enter__/__exit__, or the contextmanager decorator, for any resource that needs guaranteed cleanup, like a database connection or a lock

3. Combine multiple context managers in one with statement when you need more than one resource at once, instead of nesting separate with blocks unnecessarily

⚠️

Tip: Any object that implements __enter__ and __exit__ works with `with` — you can write your own context manager for any 'setup, then guaranteed cleanup' pattern, not just file handling, often more concisely using the contextmanager decorator from the contextlib module.

editor.html

with open("data.txt", "w") as f:
    f.write("Some data")
print(f.closed)

localhost:3000

Examples

Example 01Basic Usage

with open("data.txt", "w") as f:
    f.write("Some data")
print(f.closed)

Example 02Advanced Example

class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        print(f"Elapsed: {time.time() - self.start:.2f}s")

with Timer():
    total = sum(range(1000000))

Best Practices

Use with open(...) as f: instead of manual open()/close() pairs for every file operation
Write your own context manager, via a class with __enter__/__exit__, or the contextmanager decorator, for any resource that needs guaranteed cleanup, like a database connection or a lock
Combine multiple context managers in one with statement when you need more than one resource at once, instead of nesting separate with blocks unnecessarily

Interview Question

How does the with statement guarantee cleanup even if an exception is raised inside the block?▼

Hint: Think about the two methods a context manager must implement.

A with statement calls the context manager's __enter__ method before the block runs, and unconditionally calls its __exit__ method when the block finishes, whether that's because the code completed normally or because an exception propagated out of it. __exit__ receives details about any exception that occurred as arguments, so it can perform cleanup regardless, and can even choose to suppress the exception by returning a truthy value, though most implementations, like file closing, let the exception continue propagating after cleanup runs.

Exercises

MediumPractice using with Statement in a real scenario.

View Solution

with open("data.txt", "w") as f:
    f.write("Some data")
print(f.closed)

Frequently Asked Questions

How does the with statement guarantee cleanup even if an exception is raised inside the block?▼

Related Functions

open()close()class-keyword