Python Tutorial 27 How to use the context manager in Python

Mondo Technology Updated on 2024-02-19

When we are writing, we often encounter situations where we need to manage resources, such as opening and closing files, if we encounter some exceptions, we need to close resources, otherwise it will lead to resource leakage, although we can close it manually, but if there are multiple exceptions to consider, in case you accidentally miss one, it will be Barbie Q. So, if there was a more elegant way to deal with resource leaks, it would be very nice. It is in this context that the Context Manager was born.

A context manager is an object in Python that is used to manage resources, perform specific operations, and handle exceptions. Context managers implement specific methods that make them available in the with statement to ensure that resources are properly acquired and released.

In Python, context managers are typically implemented using special methods in the class, enter and exit. Specifically:

1. The enter method is called when entering the with statement block, which is usually used to obtain resources or perform some initialization operations, and generally returns the manager object.

2. The exit method is called when it leaves the with block, and the method will be executed regardless of whether an exception occurs in the ** block. This method is often used to free up resources, clean up work, and handle exceptions. There are three parameters in the release method: exception type, exception instance object, and exception stack object. 

class mycontextmanager:


def __enter__(self):


print("entering the context")


Perform some initialization operations, such as opening resources. 


return self


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


print("exiting the context")


Perform some cleanup operations, such as shutting down resources. 


if exc_type is not none:


print(f"exception: ,")


A true return indicates that the exception has been handled, and a false return indicates that the exception is propagated. 


return true


Use the Context Manager. 


with mycontextmanager() as manager:


print("inside the context")


Perform operations such as reading and writing resources. 


If an exception occurs here, the exception is passed to the exit method for handling.
For example, in the example above, myContextManager is a simple context manager class that implements the Enter and Exit methods to define the behavior of the context manager. Using the context manager in the with statement block performs the appropriate actions (entering, executing, exiting the context) to ensure the correct management of resources.

Running result above:

entering the context


inside the context


exiting the context
Many people say that the with statement is used to create a context manager, but to be precise, this is not true. In the previous example,mycontextmanagerIt is a class of context managers, and what we call creating a context manager is nothing more than creating an object of a context manager. Wouldn't the following create a context manager object? 

m = mycontextmanager()
So to be precise, the with statement is a syntax structure provided by Python to manage the context, which can automatically call the enter and exit methods of the context manager. With the with statement, you can be sure that the necessary actions are automatically performed when entering and exiting the block.

For example, usingwithContext Manager for statements to open and close files:

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


content = file.read()


print(content)


The file is automatically closed after the end of the with block, and the file is closed correctly even if an exception occurs.
The file object returned by the open function is a context manager, which itself does not need to be implemented, and by using the with keyword, it ensures that the file will be closed correctly after the ** block is executed. There is no need to manually invokefile.close()Method. This improves readability and maintainability, and avoids the problem of resource leakage caused by forgetting to close files.

Of course, we can also manually implement a file context manager ourselves. 

class filecontextmanager:


def __init__(self, file_name, mode):


self.file_name = file_name


self.mode = mode


def __enter__(self):


self.file = open(self.file_name, self.mode)


return self.file


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


if self.file:


self.file.close()


Use a custom file context manager class to open a file. 


with filecontextmanager('example.txt', 'w') as file:


file.write("Here comes the programmer! ")
This is a relatively simple file context managerfilecontextmanager('example.txt', 'w')and aboveopen('example.txt', 'r')The functionality is pretty much the same.

That's it for a brief introduction to the context manager. In general, the context manager is a very convenient resource management mechanism provided by Python, which can help us better manage and release resources, simplify the logic, improve the robustness, write more elegantly, and use it very comfortably in project development.

Related Pages