Detailed explanation of decorators in Python

I remember when I first learned Python several years ago, when I looked at decorators, I felt that I couldn’t understand the strange words in Jiuyin Manual. Indeed, decorators are a very difficult concept to understand. I believe many beginners must There is also such confusion, so this article mainly introduces relevant information about decorators in Python. Friends in need can refer to it.

This article will lead you to take a closer look at what this decorator is. After reading this article, decorators are no longer difficult.

1. What is a decorator?

Some people on the Internet commented on decorators like this. I think the writing is very interesting and the metaphor is very vivid

• The underwear that everyone has is mainly used to cover our shame, but in winter it cannot protect us from wind and cold, what can we do?

• One way we thought of was to transform the underwear to make it thicker and longer. In this way, it not only has the function of covering shame, but also provides warmth. However, there is a The problem is, after we transformed this underwear into trousers, although it still has a shame-covering function, it is essentially no longer a real pair of underwear. So smart people invented trousers

• and put the trousers directly on the outside of the underwear without affecting the underwear. In this way, the underwear is still underwear. After having trousers, it no longer needs to be worn. It's cold

The decorator is like the trousers we are talking about here. It provides warmth to our bodies without affecting the function of underwear

2. The prequel 4 steps of decorators

Why should I talk about decorators at the end of the introductory chapter? Because this article is too difficult and there are many The prerequisite must be understood. I believe everyone understands Python’s functions, but do you know that functions are also objects and can be passed like parameters? Let’s look at the following example:

1) Functions are also objects

def message(word='hello'):
 return word.upper()+'!'
print message()
>>
HELLO!
my_message=message
print my_message
>>
<function message at 0x000000000288E198>

print my_message()
>>
HELLO!

That is to say, message can be assigned to another variable

2) Functions can be nested and defined inside another function

def show():
 print 'Run in show()'
 def message(word='hello'):
 return word
 print message()
 
show()
>>
Run in show()
hello

message It can be nested in the show function. When calling show, the message function will also run.

3) The function returns as a parameter

A function can also be used as The return value of another function, if you don’t believe it, look at the following example

>>
<function lower at 0x00000000027DAD68>
hello...

4) The function is passed in as a parameter

We first create a getName function, and then pass this function as a parameter to the foo function

>>
I will call the getName function later
leo

3. The true face of decorators

1). After the previous steps, everyone should understand that functions can be passed in as parameters, can also be returned as parameters, and can also be nested
Decorations In fact, the function is repackaged. It can increase the function of the function without changing the function. It can execute a piece of code before or after the function is executed.

a_stand_alone_function()
>>
I am a stand alone function,don't you dare modify me
a_stand_alone_function_decorated=my_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
>>
Before the function runs
I am a stand alone function,don't you dare modify me
After the function runs

2). Use a decorator

Look it’s so simple. The decorator has a syntactic sugar @, just @my_new_decorator just put it above A bunch of code is easily resolved. This is Pythonic code, simple and efficient

is actually equivalent to:

another_stand_alone_function=my_new_decorator(another_stand_alone_function)

4. Why use decorators

Decorators provide several advantages related to code maintainability and aesthetics. And as structuring tools, decorators naturally facilitate code encapsulation, which reduces redundancy and makes future maintenance and extension easier.

If you have studied Django and Flask, you will know that a large number of decorators are used in web frameworks to encapsulate code. Let’s look at a simple example below:

We have a theme functionword() outputs a string. We have a function that makes the string bold and another that makes it italic. With decorators, we can combine them very flexibly to extend the functions of the function:

>>
<b><i>hello</i></b>

One thing to note is that if the order of the decorators changes, the result will be different. Same.

@makeitalic
@makebold
def word():
 return "hello"
print word()
>>
<i><b>hello</b></i>

That’s it for getting started with decorators. If you don’t understand anything, you can leave a message with me to discuss and communicate. In fact, there are many advanced uses of decorators, such as passing parameters through decorators, class decorators, etc. We will explain them later.

Summarize

The above is the detailed content of Detailed explanation of decorators in Python. For more information, please follow other related articles on the PHP Chinese website!