Skip to content

Automatic Resource Management and Cleanup with the with Statement in Python

Updated: at 03:01 AM

In Python, properly managing resources like files, network connections, and database handles is important to avoid issues like resource leaks and race conditions. The with statement provides an elegant and Pythonic way to automatically manage resources to ensure proper acquisition and release.

In this comprehensive guide, we will cover the following topics:

Table of Contents

Open Table of Contents

The Problem with Manual Resource Management

Before delving into the with statement, it’s important to understand the problems with manual resource management in Python. Consider this code to open a file, read its contents, and close it:

file = open('data.txt')
data =

This seems straightforward, but has a few potential issues:

To handle exceptions properly, we would have to wrap it in a try/finally block:

file = open('data.txt')

  data =

This ensures the file is closed even if an exception occurs. But as code complexity increases, this approach leads to indentation spaghetti with multiple nested try/finally blocks.

The with statement provides a cleaner and more Pythonic solution to this issue.

Introducing the with Statement

The with statement simplifies automatic resource management in Python by acquiring and releasing resources precisely when needed. Its syntax is:

with EXPR as VAR:


How the with Statement Works

Under the hood, the with statement leverages context managers to acquire and release resources. When control enters the with block, it calls the __enter__ method on the context manager. It assigns the return value to VAR, making the resource available within the block.

Upon completion of BLOCK, the __exit__ method is called on the context manager to properly release the resource. Exceptions raised within BLOCK are also handled by the __exit__ method.

This ensures proper acquisition and release of resources, similar to a try/finally approach, but in a simpler and more readable way.

Basic Usage

The with statement integrates cleanly with many built-in Python objects that represent resources requiring management.

Opening and Closing Files

A common example is opening and closing file handles. Instead of manual open and close calls, we can use the with statement:

with open('data.txt') as f:
  data =


This acquires the file handle, assigns it to f in the code block, and automatically closes it upon block exit.

Acquiring and Releasing Locks

Another example is acquiring and releasing locks in multi-threaded code:

import threading

lock = threading.Lock()

with lock:
  # Critical section of code

# Lock is released automatically

The with statement provides a clean API for scoping lock acquisition and release.

The contextlib Module

While many Python objects work as context managers, we can also write custom context managers using the contextlib module for more complex cases.

contextlib provides utility functions and decorators to define context managers without needing to implement the special methods __enter__ and __exit__ ourselves.

Let’s look at some examples.

Writing Context Managers with contextlib

A simple context manager can be written using the @contextmanager decorator:

import contextlib

def open_read_only(filename):
  file = open(filename, 'r')
  yield file

with open_read_only('data.txt') as f:
  data =

This allows opening files in a read-only mode for the scope of the with block.

For more control, we can use the Contextmanager class:

import contextlib

class ConnectionManager():
  def __init__(self):
    self.connection = create_connection()

  def __enter__(self):
    return self.connection

  def __exit__(self, exc_type, exc_value, traceback):

with ConnectionManager() as conn:
  # Use connection

This abstracts out network connection creation and teardown logic using a custom context manager class.

Creating Context Managers as Classes

Besides using the contextlib module, we can create context managers by writing classes that implement __enter__ and __exit__ methods.

For example:

class FileManager():
  def __init__(self, filename, mode):
    self.filename = filename
    self.mode = mode

  def __enter__(self):
    self.file = open(self.filename, self.mode)
    return self.file

  def __exit__(self, exc_type, exc_value, traceback):

with FileManager('data.txt', 'r') as f:
  data =

This encapsulates handling files for reading and writing.

Context manager classes provide the most flexibility but require more code than contextlib approaches.

Nested with Statements

A powerful feature of the with statement is the ability to nest acquisition of multiple resources.

For example:

with open('file1.txt') as f1, open('file2.txt') as f2:
  data1 =
  data2 =

This acquires two file handles, assigned to f1 and f2 respectively in the nested block. Both files will be closed automatically when control exits the with.

Nesting with statements can result in cleaner code compared to nested try/finally blocks.

Using else and finally Clauses

The with statement supports optional else and finally blocks like try/except/finally:

with open('file.txt') as f:
  data =
  print('no exceptions!')
  print('cleaning up')

The finally block allows executing cleanup code like logging or metrics, while else lets you avoid an extra indentation level instead of putting code after the with.

Advantages of the with Statement

Some key advantages of using the with statement for resource management:

By tying resource management to block scope, with statements reduce bugs and lead to more robust and maintainable code.

Common Pitfalls

While the with statement makes resource handling easier, there are some common pitfalls to avoid:

Properly implementing __enter__ and __exit__ is key to correct behavior. Unit testing context managers helps catch issues early.


The with statement in Python enables automatic resource management in an elegant, readable way. By acquiring resources at the start of a block and releasing them at the end, it prevents issues like leaks and race conditions.

Used properly, with statements can dramatically simplify programs by encapsulating acquisition and release logic. They make handling resources like files, locks, and connections more reliable and maintainable.

Both built-in context managers and custom implementations using contextlib or class-based approaches give flexibility in managing resources. By leveraging with blocks consistently, Python programmers can reduce bugs and improve code quality.