Detailed explanation of the keyword 'with' and context manager in python

This article mainly introduces the relevant information about the keyword "with" and context manager in python. The introduction in the article is very detailed. I believe it has certain reference value for everyone to learn or use python. Friends who need it can come below Let’s take a look.

Preface

If you have the habit of reading source code, you may see that some excellent codes often appear with the "with" keyword statement, 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, a Python 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 database connections are a very expensive resource and cannot be closed in time. May be created without limit.

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 in writing like this. If an exception occurs during the call to write, which will cause subsequent code to be unable to continue execution, the close method cannot be Called normally, 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 indicates that if the program occurs in the try code block If an exception occurs, 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", "w") 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 should be involved, which is the context manager (Context Manager).

Context Manager

Any implementation of the __enter__() and __exit__() methods Objects can be called context managers, and context manager objects 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 divided 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()

Call

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

Summary

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