The Context Manager is an object in Python that ensures the resources are properly used in the block of code and automatically frees the resources, which improves efficiency and clean code. It lets the user manage any resource using __enter__ and __exit__.
In this tutorial, we will learn about “Context Manager” in Python, and we will also see how it is helpful in managing resources, file descriptors, and database connections.
Managing Resources
Managing the resources is one of the most important parts of the Context Manager. It allows the resources to be used more efficiently. The users use resources like file operations or database connections, which are very common in any programming language.
But all these resources have a limit. Therefore, the main problem is to make sure these resources will be released after usage.
Because if they are not released, this could lead to resource leakage, which may cause either a slowdown in the system or a crash. If the machine is set up in the system of users, which can automatically tear down the resources, it can be very helpful. In Python, users can achieve this by using context managers, which are used for facilitating the proper handling of resources. The most popular way of performing file operations is by using the “with” keyword in Python.
Python Example to Manage Resources
Let us take an example to demonstrate how to manage resources in Python.
with open("text_file.txt") as file:
data = file.read() Let’s see an example of file management. When a file is opened, the file descriptors will be consumed, which is a limited resource. The process can open only a limited number of files at a time.
Another Example to demonstrate Manage Resources
Let us take another example to demonstrate how to manage resources in Python.
file_descriptors = []
for Y in range(10000):
file_descriptors.append( open ('test_file.txt', 'w')) Output:
OSError Traceback (most recent call last)
in
1 file_descriptors = []
2 for Y in range(10000):
----> 3 file_descriptors.append( open ('test_file.txt', 'w'))
OSError: [Errno 24] Too many open files: 'test_file.txt'
Explanation
The above example is the case of the file descriptor leakage. An error occurred saying, “Too many open files”. This has happened because there are so many open files, and they are not closed. There may be a chance that the users may have forgotten to close the open files.
How to Manage Resources using Context Manager?
It is tough to close a file in all the places if the block of the program raises an exception or has any complex algorithm with numerous return paths.
Most of the time, users use “try-except-finally” in other programming languages while working with the file to make sure that the file resource is closed after usage, even if there is an exception. But in Python, they can use “Context Manager” for managing resources. The users can use the “with” keyword. When it gets evaluated, it will result in an object that can perform context management. We can write context managers by using classes or functions with decorators.
How to Create a Context Manager?
When the user creates a context manager, they need to make sure that the class has the following methods: __enter__() and __exit__().
- The __enter__() method will return the resource that has to be managed.
- The __exit__() method will not return anything but perform the clean-up operations.
Let’s see an example to understand it in a better way:
First, we will create a simple class named “context_manager” for understanding the basic structure of creating a context manager by using the class method.
Python Example to Create a Context Manager
Let us take an example to demonstrate how to create a context manager in Python.
class context_manager():
def __init__(self):
print ("The 'init' method is called")
def __enter__(self):
print ("The 'enter' method is called")
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
print ("The 'exit' method is called")
with context_manager() as manager:
print ("The 'with' statement is a block") Output
The 'init' method is called
The 'enter' method is called
The 'with' statement is a block
The 'exit' method is called
Explanation
In the above code, we have created the “context_manager” object. That is assigned to the variable after the “as” keyword, that is, manager. After running the program, the following methods got executed in the sequence:
- __int__()
- __enter__()
- Body of statement, which is the code inside the “with” statement block.
- __exit__(), In this method, the parameters are used for managing the exceptions.
File Management by using Context Manager
Now, we will apply the above concept for creating the class, which can help in file resource management. The “file_manager” class will help open the file, read or write content, and then close the file.
class file_manager():
def __init__(self, file_name, mode):
self.filename = file_name
self.mode = mode
self.file = None
def __enter__(self):
self.file = open(self.filename, self.mode)
return self.file
def __exit__(self, exc_type, exc_value, exc_traceback):
self.file.close()
# At last, load the file
with file_manager('test_file.txt', 'w') as file:
file.write( )
print (file.closed) Output:
True
Performing File Management using Context Manager and “with” Statement?
After the user executes the “with” statement block, the operations will get executed in the following sequence:
- A “file_manager” object will be created with “text_file.txt” as the file name, and “w” (write) as the mode when the __init__() method will be executed.
- The __enter__() method will open the “text_file.txt” in write mode and return the “file_manager” object to the variable “file”.
- The text “TpointTech” will be written into the file.
- The __exit__() method will take care of closing the file after exiting the “with” statement block, which is a teardown operation.
- When the “print (file.closed)” statement runs, the users will get the output “True” as the “file_manager” would have already closed the file, which otherwise would need to be explicitly done.
How to Manage the Database Connection using Context Manager?
Now, we will show how to create a simple database connection management system. There is a limit on the number of database connections at a time, just as with File descriptors. Therefore, we use a context manager, as it is helpful in managing the connections to the database, as the user might have forgotten to close the collection.
Install pymongo
To manage the database connection through the content manager, the user first has to install the “pymongo” library by using the following command:
!pip3 instal pymongo Python Example to Manage the Database Connectio using Context Manager
Let us take an example to demonstrate how to manage the database connection using context manage in Python.
from pymongo import MongoClient as moc
class mongo_db_connection_manager():
def __init__(self, host_name, port = '27017'):
self.hostname = host_name
self.port = port
self.connection = None
def __enter__(self):
self.connection = moc(self.hostname, self.port)
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
self.connection.close()
# Now, connect with a localhost
with mongo_db_connection_manager('localhost', 27017) as mongo:
collection_1 = mongo.connection.SampleDb.test
data_1 = collection_1.find({'_id': 142})
print (data_1.get(name)) Output:
Test
Explanation:
In the above code, after executing the “with” statement block, the following operations will happen in the sequence.
- The “mongo_db_connection_manager” object will be created with “localhost” as the “host_name” and the port is equal to “27017” when the __init__() method is executed.
- The __enter__() method will open the “mongodb” connection, and it will return the “mongo_db_connection_manager” object to the variable “mongo”.
- The “SampleDB” database will access the “test” connection, and the document with the “_id = 147” will be retrieved. It will print the name field of the document.
- The __exit__() method will take care of closing the file after exiting the “with” statement block, which is a teardown operation.
Conclusion
In this tutorial, we have discussed Context Manager in Python, how to create Context Manager, and how it can help in Resource Management, File management, and managing Database connections.
