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

This article introduces "Python with... The detailed explanation of the as statement "related knowledge, in the actual case operation process, many people will encounter such a dilemma, then let Xiaobian lead you to learn how to deal with these situations! I hope you can read carefully and learn something!

When it comes to with, what you usually see is this:

Examples 1

with open('courses.txt') as f:

for i in f:

print(i.strip())

Open a file and loop through something. But do you know why there is a with? Can we ourselves write objects that can be applied to the with keyword?

Now, let's talk about the origin of with and context manager related content with the above two questions.

The purpose of the with statement is to simplify the try/finally pattern. This pattern is used to ensure that a given action is performed after a piece of code has run, even if that piece of code aborts due to an exception, return statement, or sys.exit() call. The code in the finally clause is usually used to free important resources or restore temporarily changed states.

The functionality of Example 1 can be implemented using the try/finally pattern:

Example 2

try:

f = open('courses.txt')

for i in f:

print(i.strip())

finally:

f.close()

Except and else in try are not necessary, so for simplicity we use only finally.

Comparing the two examples, we can see that Example 1 is relatively concise, which is where with comes from.

In fact, some characteristics of language or some eye-catching characteristics must have an evolutionary process. As latecomers and users, we should spend more time thinking about the realization process behind them. I believe you will gain more.

So what is a context manager?

The context manager protocol contains two methods__enter__and__exit__. When the with statement starts running, the__enter__method is called on the context manager object. When the with statement finishes running, it calls the__exit__method on the context manager object to play the role of the finally clause. The most common example is making sure to close the file object (Example 1).

Here's a simple example to get a feel for it:

class T:

def __enter__(self):

print('T.__ enter__')

return 'I am the return value of__enter__'

def __exit__(self, exc_type, exc_val, exc_tb):

print('T.__ exit__')

with T() as t:

print(t)

Output:

T.__ enter__I am__enter__return value T.__ exit__

Example 3 implements a class T whose object contains__enter__and__exit__methods that allow you to use with to process the object. Executing the expression T() after with gets the context manager object, which is bound to the variable t by the as clause.

Looking at the output, you can see that the with block calls the__enter__method first, and then the exit method after processing the internal logic (print(t)), and t is actually the return value of the__enter__method.

Of course, this example is just for our convenience in understanding context managers. Let's look at a more interesting example:

Example 4

obj1 = HaHa ('Your phone is upside down')

with obj1 as content:

print ('Haha Mirror Flower Edge')

print(content)

print ('#### with ')

print(content)

Output:

The edge of the flower mirror haha reverse hold your hand ### with after the execution, in the output content: ####your phone is reversed

In Example 4, the context manager is an instance of the HaHa class, and Python calls the__enter__method of this instance to bind the return result to the variable content.

Print a string and then print the value of the content variable. You can see that everything printed is reversed.

Finally, when the with block has been executed. As you can see, the value returned by the__enter__method-the value stored in the content variable--is the string 'Your phone is upside down.'

The output is no longer reversed.

HaHa class implementation:

import sys

class HaHa:

def __init__(self, word):

self.word = word

def reverse_write(self, text):

self.original_write(text[::-1])

def __enter__(self):

self.original_write = sys.stdout.write

sys.stdout.write = self.reverse_write

return self.word

def __exit__(self, exc_type, exc_value, traceback):

sys.stdout.write = self.original_write

return True

In the__enter__method, we take over the standard output and replace it with our own method reverse_write, which inverts the parameter content. In the__exit__method, we restore the standard output.__ The exit__method needs to return True.

In short, with is to context managers what for is to iterators. With is to facilitate the use of context managers.

The context manager feature has several applications in the standard library:

Used to manage transactions in sqlite3 module;

Used to maintain locks, conditions and signals in threading module;

In addition, speaking of context managers, we have to mention the @contextmanager decorator, which reduces the amount of boilerplate code needed to create context managers because instead of writing a complete class defining the__enter__and__exit__methods, we only need to implement a generator with a yield statement that generates the value we want the__enter__method to return.

In a generator decorated with @contextmanager, the yield statement divides the function definition body into two parts:

All code preceding the yield statement executes at the beginning of the with block (that is, when the interpreter calls the__enter__method)

The code following the yield statement executes at the end of the with block (that is, when the__exit__method is called).

Let's use the @contextmanager decorator to implement the functionality of Example 4:

Example 5

import sys

import contextlib

@contextlib.contextmanager

def WoHa(n):

original_write = sys.stdout.write

def reverse_write(text):

original_write(text[::-1])

sys.stdout.write = reverse_write

yield n

sys.stdout.write = original_write

return True

obj1 = WoHa ('Your phone is upside down')

with obj1 as content:

print ('Haha Mirror Flower Edge')

print(content)

print ('#### with ')

print(content)

Output:

The mirror, haha.

Take your hand instead.

#### with After execution, output content: ####

Your phone's upside down.

Note here that when the code executes to yield, it produces a value that is bound to the variable in the as clause of the with statement. When the code in the with block is executed, the function pauses at yield. At this point, it is equivalent to executing the__enter__method in Example 4. Once control exits the with block (code execution within the block is complete), it continues to execute code after the yield statement.

The @contextmanager decorator is elegant and practical, combining three different Python features: function decorators, generators, and with statements.

"Python with... The content of the detailed explanation of the as sentence is introduced here. Thank you for reading it. If you want to know more about industry-related knowledge, you can pay attention to the website. Xiaobian will output more high-quality practical articles for everyone!

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.