Python Context Managers Tutorial – Complete Guide

Managing resources efficiently is a key part of coding, and Python offers us a unique tool for this called context managers. If you’ve used the “with” keyword in Python, congratulations, you’ve used a context manager! But what exactly is a context manager and why are they so useful? Let’s explore together.

What is a Context Manager?

In Python, a context manager is an object that is designed to set up and tear down resources before and after an operation. This setup and teardown occur within the Python “with” statement.

What are Context Managers For?

Context managers are great for handling resources such as files, network connections, or locks which need to be properly cleaned up after use, regardless of whether the operation was successful or not. This can help to prevent resource leaks and make your code more robust and easier to maintain.

Why Should I Learn Context Managers?

Learning to use context managers can drastically simplify the way you manage and interact with resources in Python. It often leads to cleaner, quicker and more reliable code. Whether you’re just starting out or an experienced coder, understanding and using context managers can be a valuable addition to your Python toolbox.

CTA Small Image




Basic Use of Context Managers

Let’s start with the most common usage: opening files. Without a context manager, we might open a file, perform operations on it, and then close it:

file = open('example.txt', 'r')

But with a context manager, the file is automatically closed once we are done with it:

with open('example.txt', 'r') as file:

Even if an exception occurs within the “with” block, the file will be closed properly. You don’t need to worry about closing the file explicitly — Python’s context manager takes care of it.

Creating a Context Manager

You can create your own context manager by defining a class that has __enter__() and __exit__() methods:

class MyContextManager:
    def __enter__(self):
        print("Entering the block")

    def __exit__(self, type, value, traceback):
        print("Exiting the block")

You can then use this context manager with the “with” keyword:

with MyContextManager() as x:
    print("Inside the block")

Handling Exceptions in Context Managers

The __exit__() method can handle exceptions that occur within the “with” block. If an exception is thrown, __exit__() is still called and can decide how to respond to the exception. Here’s an example:

class ErrorHandlingContextManager:
    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        if type is not None:
            print("Handled exception:", value)
        return True # indicates that the exception was handled

with ErrorHandlingContextManager():
    raise ValueError("An error occurred")

In this example, the ValueError is handled by the __exit__() method of the ErrorHandlingContextManager. The code within the “with” block can throw an error without force-closing the entire script, which offers a greater level of safety and control in your programs.

Using Context Managers with Databases

Context managers become especially useful when dealing with databases. For instance, it can ensure that changes are committed to the database only if all operations within the “with” block complete successfully. Here’s an example of how context managers can be applied in this scenario:

import sqlite3 

class DatabaseContextManager:
    def __init__(self, db_name):
        self.db_name = db_name

    def __enter__(self):
        self.conn = sqlite3.connect(self.db_name)
        return self.conn.cursor()

    def __exit__(self, type, value, traceback):
        if type is None:
            self.conn.commit()  # commit the changes if no error occurred
            self.conn.rollback()  # roll back the changes in case of error

Context Managers in Multi-threaded Applications

Context managers also play a role in multi-threaded applications, helping you make the most out of the threading or multiprocessing Python libraries. They can be used to ensure that certain sections of your code are executed by only one thread at a time:

import threading

# a lock is a context manager in Python!
lock = threading.Lock()

with lock:
    # this block of code is executed by only one thread at a time 
    print('Hello, World!')

Writing Clean-up Code with Context Managers

In Python, using context managers becomes crucial when working with clean-up code. For instance, when creating temporary files, you can use context managers to ensure they are deleted afterwards:

import tempfile

with tempfile.TemporaryFile('w+') as f:
    # use the temporary file...
    f.write('Hello, World!')
# here, the file is automatically removed

Using Context Managers with The unittest Module

Python’s unittest module provides a Testcase class, which has methods setUp() and tearDown(). Both these methods operate as context managers as setUp() is called before the test method, and tearDown() is called after the test method.

import unittest

class MyTest(unittest.TestCase):
    def setUp(self):
        self.conn = sqlite3.connect(':memory:')

    def test_db_connection(self):
        cursor = self.conn.cursor()
        # perform tests using cursor

    def tearDown(self):

This arrangement guarantees that setUp() and tearDown() are always called, irrespective of whether the test method encounter errors or not. This results in clean, efficient unit test code.

Where to Go Next?

Having a solid understanding of Python’s context managers is a great skill in your development journey. However, learning in the world of coding never stops. There’s always something new to explore, understand and implement. So, where can you go next?

Why not dive deeper and refine your Python expertise with our comprehensive programming courses? At Zenva, we make learning coding, game creation and more accessible with high-quality, easy-to-follow content.

Python Mini-Degree

We invite you to explore our Python Mini-Degree. This comprehensive collection of courses, designed for a range of experience levels, dives into all aspects of Python programming. Here’s what you can expect:

  • Learning coding basics and advanced Python concepts
  • Deep dive into algorithms and object-oriented programming
  • Exploring and coding games with Python
  • Creating apps and real-world projects with popular libraries and frameworks such as Pygame, Tkinter and Kivy that can help you build a solid portfolio
  • Reinforcing learning with step-by-step projects and quick challenges

Python is widely adopted across different sectors including data science, AI, game development and more. However, understanding Python is just the start of your coding journey.

All our courses, including the Python mini-degree, are flexibly designed – you can access them anytime and balance learning along with your schedule. Each course comes with video lectures, interactive content, and a completion certificate that can help you kickstart or level up your coding career.

Expand Your Python Knowledge

We also offer a broad range of Python courses crafted to cater to your specific learning interests or career goals. Enjoy our flexible and comprehensive Python courses that take you from beginner to professional. Remember, the key is consistent practice and never-ending curiosity! At Zenva, we’re excited to be part of your learning journey and can’t wait to see what you’ll code next.


Context managers in Python are a powerful, elegant tool for resource management, simplifying code and making it more robust. By mastering this concept, you’re on your way to writing efficient, high-quality Python code!

At Zenva, we’re here to help you enhance your Python skills and broaden your coding horizons. Why not continue your learning by checking out our Python Mini-Degree? Get ready to put what you’ve learned into practice with our interactive, high-quality tutorials. Let’s continue this exciting coding journey together!


Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Unreal, Python, Godot and more.