Python context manager

Functionally, the with statement is equivalent to the try…finally statement below.

instance = ContextManager()
ctx = instance.__enter__()

try:
    # do something with the text
finally:
    # do with the context
    instance.__exit__()

__enter__()method

In the __enter__() method, you can perform the necessary steps to set up the context.

Additionally, you can return an object from the __enter__() method.

__exit__()method

Python always executes the __exit__() method, even if an exception occurs within a with block.

The __exit__() method accepts three parameters: exception type, exception value, and traceback object. All of these parameters will be None if no exception occurs.

def __exit__(self, ex_type, ex_value, ex_traceback):
    ...

The __exit__() method returns a Boolean value, True or False .

If the return value is True, Python will silence any exception. Otherwise, it doesn’t silence the exception.

Application of Python context manager

As you can see from the previous examples, a common use of context managers is to automatically open and close files.

However, you can use context managers in many other situations.

1) Open – Close

If you want to automatically open and close a resource, you can use a context manager.

For example, you can use a context manager to open a socket and close it.

2) Lock-release

Context managers can help you manage object locks more efficiently. They allow you to acquire a lock and release it automatically.

Context managers also help you work in situations where start and stop phases are required.

For example, you can use a context manager to start a timer and stop it automatically.

3) change – reset

Context managers can be used for change and reset scenarios

For example, your application needs to connect to multiple data sources. And it has a default connection.

To connect to another data source:

• First, use the context manager to change the default connection to a new one.

• Second, let the new connection start working.

• Third, once you’re done working on the new connection, reset it to the default connection.

Implements the Python context management protocol

A simple implementation of the open() function using the context management protocol is shown below.

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

    def __enter__(self):
        print(f'Opening the file {<!-- -->self.filename}.')
        self.__file = open(self.filename, self.mode)
        return self.__file

    def __exit__(self, type, value, traceback):
        print(f'Closing the file {<!-- -->self.filename}.')
        if not self.__file.closed:
            self.__file.close()

        return False

With File('data.txt', 'r') as f:
    print(int(next(f)))

How it works.

• First, initialize filename and mode in the __init__() method.

• Second, open the file and return the file object in the __enter__() method.

• Third, close the file if it was opened in the __exit__() method.

Using the Python context manager to implement start and stop patterns

The following defines a Timer class that supports the context management protocol.

from time import perf_counter

class Timer:
    def __init__(self):
        self. elapsed = 0

    def __enter__(self):
        self.start = perf_counter()
        return self

    def __exit__(self, exc_type, exc_value, exc_traceback):
        self. stop = perf_counter()
        self. elapsed = self. stop - self. start
        return False

How it works.

• First, import perf_counter from the time module.

• Second, start the timer in the __enter__() method.

• Third, stop the timer in the __exit__() method and return the elapsed time.

Now, you can use the Timer class to measure the time it takes to calculate the Fibonacci function with a parameter of 1000, one million times.

def fibonacci(n):
    f1 = 1
    f2 = 1
    for i in range(n-1):
        f1, f2 = f2, f1 + f2

    return f1


with Timer() as timer:
    for _ in range(1, 1000000):
        fibonacci(1000)

print(timer. elapsed)

Summary

• When executed within a with statement, a Python context manager is used to define the runtime context.

• Implement the __enter__() and __exit__() methods to support the context management protocol.
  (full text)

Some pictures are from the source website, intruded and deleted.

In view of my lack of talent and learning, it is inevitable that there will be omissions in the translation. If you have any questions, please feel free to contact me for criticism and correction: [email protected]

I am gled fish, click here to come to my blog site:

Please indicate the translator and the original source when reprinting, and please do not use it for any commercial purposes.