Shulou(Shulou.com)06/01 Report--

Most people don't understand the knowledge points of this article "how to understand python's with and context manager", so Xiaobian summarizes the following contents for everyone. The contents are detailed, the steps are clear, and they have certain reference value. I hope everyone can gain something after reading this article. Let's take a look at this article "how to understand python's with and context manager".

For system resources such as files, database connections, sockets, one of the things an application must do after opening them and executing business logic is to close (disconnect) the resource.

For example, Python programs open a file, write content to the file, and when they are finished, they close the file. Otherwise, what happens? The "Too many open files" error occurs in extreme cases because the maximum number of files the system allows you to open is limited.

Similarly, for databases,"Can not connect to MySQL server Too many connections" may occur if the number of connections is too large and not closed in time, because database connections are a very expensive resource and cannot be created indefinitely.

See how to close a file correctly.

Normal version: def m1():

f = open("output.txt", "w")

f.write("Python Zen")

f.close()

There is a potential problem with writing this way. If an exception occurs during the call to write that prevents subsequent code execution, the close method cannot be called properly, and therefore resources are always released by the program occupant. So how can I improve the code?

Advanced version: def m2():

f = open("output.txt", "w")

try:

f.write("Python Zen")

except IOError:

print("oops error")

finally:

f.close()

The improved version of the program catches code where exceptions may occur, using the try/finally statement, which indicates that if an exception occurs in the try code block, the subsequent code will not be executed, but will jump directly to the except code block. Eventually, however, the finally block code will be executed regardless of whether an exception occurs. Therefore, even if an error is reported during the write process, it will eventually execute to finally close the file.

Advanced version: def m3():

with open("output.txt", "r") as f:

f.write("Python Zen")

A more concise and elegant way is to use the keyword with. The return value of open is assigned to the variable f, and when leaving the with block, the system automatically calls the f.close() method, which works the same way as using the try/finally statement. So what is the principle of its realization? Before we talk about the principle of with, we need to involve another concept, that is, context manager.

context manager

Any object that implements the__enter__() and__exit__() methods can be called a context manager, and any object that implements a context manager 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 implementing a file class of our own that implements 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()

The__enter__() method returns the resource object, in this case the file object you are about to open, and the__exit__() method handles some cleanup.

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

with File('out.txt', 'w') as f:

print("writing")

f.write('hello, python')

This way, you don't have to explicitly call the close method. These have systems to call. Even if an exception is encountered in the middle, the close method will be called.

contextlib

Python also provides a decorator for context manager, which further simplifies the implementation of context manager. Divide the function into two parts by yield, with statements before yield executed in the__enter__method and statements after yield executed in the__exit__method. The value immediately following yield is the return value of the function. For example:

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") The above is about the content of this article about "python with and how to understand context manager". I believe everyone has a certain understanding. I hope the content shared by Xiaobian will be helpful to everyone. If you want to know more about relevant knowledge content, please pay attention to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.