Detailed explanation of keyword "with" and context manager

If you have the habit of reading source code, you may see statements with the "with" keyword often appearing in some excellent codes. In what scenarios is it usually used? Today let’s talk about with and context managers.

For system resources such as files, database connections, and sockets, after the application opens these resources and executes the business logic, one thing it must do is to close (disconnect) the resource.

For example Python The program opens a file and writes content to the file. After writing, the file must be closed. Otherwise, what will happen? In extreme cases, "Too many open files" errors may occur because the maximum number of files the system allows you to open is limited.

Similarly, for the database, if there are too many connections and they are not closed in time, "Can not connect to MySQL server Too many connections" may appear, because the database connection is a Very expensive resources that cannot be created unlimitedly.

Let’s see how to close a file correctly.

Normal version:

def m1():
    f = open("output.txt", "w")
    f.write("python之禅")
    f.close()

There is a potential problem with writing this way. If an exception occurs during the call to write and the subsequent code cannot continue to execute, close The method cannot be called normally, so the resources will always be released by the occupier of the program. So how can we improve the code?

Advanced version:

def m2():
    f = open("output.txt", "w")
    try:
        f.write("python之禅")
    except IOError:
        print("oops error")
    finally:
        f.close()

The improved version of the program is to try to capture the code where exceptions may occur, using the try/finally statement, which means if If an exception occurs in the program in the try code block, subsequent code will no longer be executed and will jump directly to the except code block. No matter what, the code in the finally block will eventually be executed. Therefore, as long as close is placed in the finally code, the file will definitely be closed.

Advanced version:

def m3():
    with open("output.txt", "r") as f:
        f.write("Python之禅")

A more concise and elegant way is to use the with keyword. The return value of the open method is assigned to the variable f. When leaving the with code block, the system will automatically call the f.close() method. The function of with is the same as using the try/finally statement. So what is its implementation principle? Before talking about the principle of with, another concept needs to be mentioned, which is the context manager.

Context Manager

Any object that implements the enter() and exit() methods can be called As a context manager, the context manager object can use the with keyword. Obviously, file objects also implement context managers.

So how does the file object implement these two methods? We can simulate the implementation of a file class of our own and let the class implement the enter() and exit() methods.

class File():

    def init(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def enter(self):
        print("entering")
        self.f = open(self.filename, self.mode)
        return self.f

    def exit(self, *args):
        print("will exit")
        self.f.close()

enter() The method returns the resource object, which is the file object you are about to open. The exit() method handles some cleanup Work.

Because the File class implements a context manager, you can now use the with statement.

with File('out.txt', 'w') as f:
    print("writing")
    f.write('hello, python')

In this way, you don’t need to explicitly call the close method. The system will automatically call it. Even if an exception is encountered in the middle, the close method will be called.

contextlib

Python also provides a contextmanager decorator, which further simplifies the implementation of the context manager. The function is split into two parts by yield. The statement before yield is executed in the enter method, and the statement after yield is executed in the exit method. The value immediately following yield is the return value of the function.

from contextlib import contextmanager

@contextmanager
def my_open(path, mode):
    f = open(path, mode)
    yield f
    f.close()

Calling

with my_open('out.txt', 'w') as f:
    f.write("hello , the simplest context manager")

Summary

Python provides the with syntax to simplify subsequent clearing operations of resource operations, which is An alternative to try/finally, the implementation principle is based on the context manager. In addition, Python also provides a contextmanager decorator to further simplify the implementation of context managers.

The above is the detailed content of Detailed explanation of keyword "with" and context manager. For more information, please follow other related articles on the PHP Chinese website!