What is and how to use With in Python

4 min
Intermediate

The with statement is a construct in Python that simplifies the management of resources that need to be cleaned up after use. For example, files, database connections, or code blocks that need to release specific resources.

The main purpose of with is to ensure that resources are properly released or closed after the code block has completed (even if an exception occurs).

The benefits of using with are:

Simplicity: Simplifies code that handles resources
Safety: Ensures resources are released appropriately
Readability: Makes code more readable and easier to follow

with Syntax

The basic syntax of the with statement is as follows:

with expression as variable:
    # Code that uses the variable

Copied!

expression represents an object that implements the context protocol
variable is a reference to that object within the with block.

Basic Example

Let’s look at a simple example. One of the most common uses of with is for handling files. The with construct ensures that the file is properly closed after you finish working with it, thus avoiding potential resource leaks.

# Using with to handle a file
with open('file.txt', 'r') as file:
    content = file.read()
    print(content)
# The file is automatically closed upon exiting the with block

Copied!

In this example, open('archivo.txt', 'r') returns a file object that implements the context protocol. The file is opened for reading, and upon exiting the with block, the file is automatically closed, even if an exception occurs within the block.

Context Managers

The with statement works with objects known as context managers. These objects implement the special methods __enter__ and __exit__, and control the setup and cleanup of the resource.

__enter__: This method is executed upon entering the with block. It can perform initial setup and return an object that will be assigned to the specified variable (if as variable is used).
__exit__: This method is executed upon exiting the with block. It handles cleanup, such as closing files or releasing resources. It can also handle exceptions if necessary.

Implementing Context Managers

Creating a Context Manager with Classes

We can create our own context managers using classes and implementing the __enter__ and __exit__ methods.

class MyContext:
    def __enter__(self):
        print("Entering the context")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")
        # You can handle exceptions here if necessary
        return False

# Using the custom context
with MyContext() as context:
    print("Inside the with block")
    
# Output:
# Entering the context
# Inside the with block
# Exiting the context

Copied!

In this example,

MiContexto is a class that defines the __enter__ and __exit__ methods
When the with block starts, the message “Entering the context” is displayed
Inside the with block, the block’s body prints “Inside the with block”
The with block ensures that the message “Exiting the context” is printed when the block finishes, regardless of whether an exception occurs or not.

Creating a Context Manager with Generators

Another way to create a context manager is by using the contextlib library’s contextmanager function from the Python standard library, which provides the @contextmanager decorator.

This decorator allows you to define a custom context manager in a simpler way than implementing the full __enter__ and __exit__ interface.

from contextlib import contextmanager

@contextmanager
def my_context():
    print("Entering the context")
    yield
    print("Exiting the context")

with my_context():
    print("Inside the with block")

# Output:
# Entering the context
# Inside the with block
# Exiting the context

Copied!

In this example,

The decorator converts the mi_contexto function into a context manager that can be used with the with statement
The context will have pre-actions and post-actions. Between them, we must place a yield, and here the actions of the block will be executed
The behavior is the same as the previous case, but the creation syntax is simpler