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

This article mainly explains "what is the writing of Python decorator". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "what is the writing of Python decorator".

Hello, decorator

The decorator is essentially a Python function that allows other functions to add additional functionality without any code changes, and the return value of the decorator is also a function object.

It is often used in scenarios with faceted requirements, such as log insertion, performance testing, transaction processing, caching, permission verification, and so on.

Decorators are an excellent design for solving such problems, and with decorators, we can extract a lot of similar code that has nothing to do with the function itself and continue to reuse.

The use of the decorator is very fixed.

Define a decorator (hat) first

Then define your business function or class (person)

Finally, the decorator (hat) is fastened to the function (person).

Just like down there.

# define decorator def decorator (func): def wrapper (* args, * * kw): return func () return wrapper # define business functions and decorate @ decorator def function (): print ("hello, decorator")

In fact, the decorator is not necessary for coding, which means that you can do without the decorator, and its appearance should make our code

More elegant, clearer code structure

Encapsulate the code that implements specific functions into decorators to improve the code reuse rate and enhance the readability of the code

Next, I'll show you how to write a variety of simple and complex decorators with examples.

The first kind: ordinary decorator

First of all, let's write the most common decorator, which implements the following functions:

Record a line of logs before the function is executed

After the function is executed, record another line of logs

# this is the decorator function, and the argument func is the decorated function def logger (func): def wrapper (* args, * * kw): print ('I'm ready to execute: {} function: '.format (func.__name__)) # what's really executed is this line. Func (* args, * * kw) print ('master, I'm done.') Return wrapper

Suppose, my business function is to calculate the sum of two numbers. After you write it, put a hat on it directly.

@ logger def add (x, y): print ('{} + {} = {} '.format (x, y, x, y))

Then execute the add function.

Add (200,50)

Let's see what the output is.

I'm ready to start execution: the add function: 200 + 50 = 250. I'm done.

The second kind: function decorator with parameters

Through the above two simple getting started examples, you should be able to understand how the decorator works.

However, the use of decorators is far more than that, further research, but also a lot of articles. Let's learn this knowledge point together today.

Looking back at the above example, the decorator cannot accept parameters. Its usage can only be applied to some simple scenarios. Decorators that do not pass parameters can only perform fixed logic on the decorated functions.

The decorator itself is a function, as a function, if you can not pass parameters, then the function of this function will be very limited, can only execute fixed logic. This means that if the execution of the decorator's logic code needs to be adjusted according to different scenarios, if we can't pass parameters, we have to write two decorators, which is obviously unreasonable.

For example, if we want to implement a task that can send emails regularly (send one per minute), and time synchronization tasks (once a day), we can implement a periodic_task (scheduled task) decorator by ourselves, which can receive parameters of a time interval and how often the task is executed.

Can be written like the following, because this function code is more complex, not conducive to learning, it will not be posted here.

Periodic_task (spacing=60) def send_mail (): pass @ periodic_task (spacing=86400) def ntp () pass

Let's create a pseudo scene by ourselves. We can pass a parameter in the decorator to indicate the nationality and say hello in our native language before the function is executed.

# Xiaoming, Chinese @ say_hello ("china") def xiaoming (): pass # jack, American @ say_hello ("america") def jack (): pass

What if we implement this decorator so that it can pass parameters?

It will be more complex and requires two layers of nesting.

Def say_hello (contry): def wrapper (func): def deco (* args, * * kwargs): if contry = = "china": print ("Hello!") Elif contry = "america": print ('hello.') Else: return # where the function is actually executed func (* args, * * kwargs) return deco return wrapper

Let's execute it.

Xiaoming () print ("-") jack ()

Look at the output.

Hello!-hello.

The third kind: class decorator without parameters

The above are all function-based decorators, and when reading other people's code, you can often find that there are class-based decorators.

Based on the implementation of the class decorator, two built-in functions _ _ call__ and _ _ init__ must be implemented.

_ _ init__: receive decorated function

_ _ call__: implements the decoration logic.

Or take the simple example of log printing as an example.

Class logger (object): def _ init__ (self, func): self.func = func def _ call__ (self, * args, * * kwargs): print ("[INFO]: the function {func} () is running..."\ .format (func=self.func.__name__)) return self.func (* args * * kwargs) @ logger def say (something): print ("say {}!" .format (something)) say ("hello")

Execute it and look at the output

[INFO]: the function say () is running... Say hello!

The fourth kind: class decorator with parameters

The above example without parameters, you found no, can only print INFO-level logs, normally, we also need to print DEBUG WARNING-level logs. This requires passing parameters to the class decorator and assigning a level to the function.

Class decorators with and without parameters are very different.

_ _ init__: no longer receives decorated functions, but receives incoming parameters.

_ _ call__: receives the decorated function to implement the decoration logic.

Class logger (object): def _ init__ (self, level='INFO'): self.level = level def _ call__ (self, func): # accept function def wrapper (* args, * * kwargs): print ("[{level}]: the function {func} () is running..."\ .format (level=self.level) Func=func.__name__) func (* args, * * kwargs) return wrapper # returns the function @ logger (level='WARNING') def say (something): print ("say {}!" .format (something)) say ("hello")

Let's specify the WARNING level, run it, and look at the output.

[WARNING]: the function say () is running... Say hello!

Fifth: using partial functions and classes to implement decorators

Most decorators are based on functions and closures, but this is not the only way to make decorators.

In fact, Python has only one requirement as to whether an object can be used in the form of a decorator (@ decorator): decorator must be an object that can be called (callable).

For this callable object, we are most familiar with functions.

In addition to functions, a class can also be a callable object, as long as the _ _ call__ function is implemented (I've already touched on the above examples).

There are also partial functions that are easily overlooked, which are actually callable objects.

Next, let's talk about how to use a combination of classes and partial functions to achieve a distinctive decorator.

As shown below, DelayFunc is a class that implements _ _ call__, and delay returns a partial function, where delay can be used as a decorator. (the following code is from the Python craftsman: tips for using decorators.)

Import time import functools class DelayFunc: def _ init__ (self, duration, func): self.duration = duration self.func = func def _ _ call__ (self, * args, * * kwargs): print (f'Wait for {self.duration} seconds...') Time.sleep (self.duration) return self.func (* args, * * kwargs) def eager_call (self, * args, * * kwargs): print ('Call without delay') return self.func (* args, * * kwargs) def delay (duration): decorator: delay the execution of a function. It also provides the .eager _ call method to execute immediately "" # here to avoid defining additional functions, # use functools.partial directly to help construct the DelayFunc instance return functools.partial (DelayFunc, duration)

Our business function is very simple, which is to add

@ delay (duration=2) def add (a, b): return astatb

Let's take a look at the implementation process.

> add # it can be seen that add has become an instance of Delay > add (3pime5) # call the instance directly and enter _ _ call__ Wait for 2 seconds... 8 > add.func # implements the instance method

The sixth kind: decorators that can be decorated.

When writing singleton mode with Python, there are three common ways to write it. One of them is implemented with a decorator.

The following is the singleton writing of my own decorator version.

Instances = {} def singleton (cls): def get_instance (* args, * * kw): cls_name = cls.__name__ print ('= 1 =') if not cls_name in instances: print ('= 2 =') instance = cls (* args * * kw) instances [CLS _ name] = instance return instances [CLS _ name] return get_instance @ singleton class User: _ instance = None def _ init__ (self, name): print ('= 3 =') self.name = name

You can see that we decorate the User class with the decorating function singleton. It is not common for a decorator to be used on a class, but as long as you are familiar with the implementation process of the decorator, it is not difficult to decorate the class. In the above example, the decorator simply implements control over the generation of class instances.

In fact, the process of instantiation, you can refer to my debugging process here to understand.

Thank you for your reading, the above is the content of "what is the writing of Python decorator". After the study of this article, I believe you have a deeper understanding of what the writing method of Python decorator is, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.