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

This article mainly introduces how to use Python decorator to modify function behavior related knowledge, the content is detailed and easy to understand, the operation is simple and fast, has a certain reference value, I believe you will have something to gain after reading this article on how to use Python decorator to modify function behavior, let's take a look.

What is the decorator in Python

The decorator is a very powerful and useful tool in Python because it allows programmers to modify the behavior of functions or classes. The decorator allows us to wrap another function to extend the behavior of the wrapper function without modifying the underlying function definition. This is also called metaprogramming because the program itself tries to modify another part of itself while the program is running.

Decorators are syntactic sweets: use more concise and fluent syntax to achieve more complex functions in your code.

We know that everything in Python is an object. This means that functions in Python can be used as arguments or passed as arguments. Properties of first-class functions:

The function is an instance of the Object type.

You can store functions in variables.

You can pass this function as an argument to another function.

You can return a function from a function.

They can be stored in data structures, such as hash tables, lists, and so on.

Let's look at an example like this.

Def hello (): print ('Welcome to Python decorators') another_hello = hello () another_hello# Welcome to Python Decorator!

Define a hello () function, then assign the hello function to the another_hello variable, then call this variable, and the result is that the hello function is executed.

Since a function in Python is an object, you can pass it to another function as an object, in addition to simply calling it.

Def print_welcome (): print ('Welcome to Python decorators') def print_hello (func): def inner (): print ('hellographies') Func () return innerdecorated = print_hello (print_welcome) decorated () # hellograms # Welcome to Python Decorator! Grammatical sugar

However, the above code uses internal functions. We can decorate the print_welcome () function simply by using the decorator function print_hello ().

The decorator can simplify our operation. The function is exactly the same, but the code is more concise. That is, the use of the decorator is simplified by the @ symbol, as follows:

Def print_hello (func): def inner (): print ('hellograms') Func () return inner@print_hellodef print_welcome (): print ('Welcome to Python decorators') print_welcome () # hellograms # Welcome to Python Decorator!

By doing so, we can eliminate the use of explicitly passing one function to another. The Python decorator implicitly handles this.

Using the Python decorator to modify function behavior timing functions using the Python decorator

To demonstrate their usefulness, let's build a function that takes another function and timing its execution. The advantage of using the decorator here is that it allows us to follow the principles of DRY programming.

The decorator can be used to measure the time required for the function to execute. If you define a simple sleep function to calculate the runtime of that function.

Import timedef timeit (func): def timed (): start = time.time () result = func () end = time.time () print (f'Program took {(end-start) * 1000} s to run') return result return timed@timeitdef print_welcome (): print ('Welcome to Python Decoratorates') print_welcome () # Welcome to Python Decoratorates # Program took 0.0s to run

Analyze the above code:

Defines a function timeit () that accepts another function

This function also has another internal function timed ()

Function tracks the start time, executes the modifier function, tracks the end time, calculates the difference and returns the result

Finally, the outer function returns the inner function

When we apply this decorator function to our function print_welcome (), we first return a welcome greeting and then show the execution time.

Use the Python decorator to record useful information to the terminal

Similar to the example above, we can use the decorator to print useful information to the terminal while the program is running. For example, we might want to know which function is running and the current time. You can also use the decorator to pass to the log file:

From datetime import datetimedef log_info (func): def inner (): print (f'Starting run at {datetime.now ()}') print (f'Running {func.__name__}') func () return inner@log_infodef print_welcome (): print ('Welcome to Python Decoratorates') print_welcome () # Starting run at 2022-03-27 2323 def inner 2638.47331mm Running print_welcome# Welcome to Python Decorator!

In the above example, our decorator prints the current date and time and the name of the function to run before running the function. This can be useful if you are running a longer script and just want to know the location of the program.

Decorators used in Web app

Let's take the use case of a Web application as an example. When you build a Web application in Flask, you always write url routing. Each route is a specific page in the Web application. Opening the page / about may call the about_page () method.

@ app.route ("/ about") def about_page (): return "Website about nachos" passes parameters to the Python decorator

So far, you have learned how to create some useful Python decorators. However, none of these decorators pass in parameters. In this section, you will learn how to create a Python decorator that accepts parameters.

To do this, we will allow magic decompression in the Python syntax. Use func_name (* args,**kwargs), which decompresses all parameters and all keyword parameters. By using it in the decorator, you can ensure that the decorator will accept any number of parameters or keyword parameters. This makes them more practical for reuse.

Def print_function_name (func): def inner (* args, * * kwargs): print (f'Running {func.__name__}...') Return func (* args, * * kwargs) return inner@print_function_namedef add_nums (a, b): print (a + b) add_nums (1,2) # Running add_nums...# 3

The beauty of the above approach is that it accepts both position and keyword parameters. Therefore, even if we execute the function in any of the following formats, the function will run:

Add_nums (1024, 2020)

Add_nums (1024, b = 2021)

Add_nums (a = 1024, b = 2222)

Use multiple Python decorators

An interesting way about Python decorators is that you can use multiple decorators at the same time. This means that you can apply multiple decorators to a single function. To understand this, look at an example:

Def one (func): def inner (* args, * * kwargs): print ('1') return func (* args, * * kwargs) return innerdef two (func): def inner (* args, * * kwargs): print ('2') return func (* args, * * kwargs) return inner@one@twodef speak (text): print (text) speak ('Hello')

The only thing our decorator function does is print out the numbers 1 and 2. By placing the decorator @ one before @ two, you can wrap the function wrapped by two () as one (). To illustrate this, you can switch the order to see how to modify the behavior:

# Changing decorator order@two@onedef speak (text): print (text) speak ('Hello') # popular Hello

This function becomes the outermost function by placing the @ two decorator first.

This is the end of the article on "how to use the Python decorator to modify function behavior". Thank you for reading! I believe you all have a certain understanding of "how to use Python decorator to modify function behavior". If you want to learn more, you are welcome to follow 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.