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

This article mainly introduces what the Python decorator grammar is like, has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let the editor take you to understand it.

Detailed explanation of decorator syntax in Python

Decorators are a very interesting part of python. They are used to encapsulate function code and explicitly apply wrappers to encapsulated functions so that they choose to add to the functions specified by the decorator. Decorators are useful for handling common preconditions (such as confirming authorization) before the function runs, or for ensuring cleanup (output cleanup or exception handling) after the function runs.

To put it simply, the decorator implements a general function, and then applies the general function to different functions that need to use it, so as to avoid writing the same function code on different functions every time.

The essence of the decorator is a function that accepts the decorated function as a positional parameter, and the decorator performs something by using that parameter, and then returns a function reference, which can be the original function or another function.

As an example, decorators are functions that take a decorated callable function as the only argument and return a callable function.

Registry = []

Def register (decorated):

Registry.append (decorated)

Return decorated

Def foo ():

Return 3

Foo = register (foo)

Print (registry [0])

The register method is a simple decorator, which adds the decorated function to a list, and then returns the unchanged decorated function. As you can see, the decorator usually passes in the reference of the decorated function, and then after some specified processing, the final return value is also a function reference.

There is also a simpler form of grammar:

Syntax sugar for decorators: the way we see decorating foo here is to use the

Another simple use of the foo = register (foo) statement is to apply the decorator where the function is declared, making the code easier to read and immediately aware of the decorator being used.

Registry = []

Def register (decorated):

Registry.append (decorated)

Return decorated

@ register

Def foo (Xero3):

Return x

@ register

Def bar (Xero5):

Return 5

For func in registry:

Print (func ())

three

five

Let's take a look at a more complex and general decorator function. The essence of the decorator is to add some additional functions while executing the original function (the decorated function).

Def requires_ints (decorated):

Def inner (* args, * * kwargs):

Kwarg_values = [i for i in kwargs.values ()]

For arg in list (args) + kwarg_values:

If not isinstance (arg, int):

Raise TypeError ('{} only accepts integers as arguments'.format (decorated.__name__))

Return decorated (* args, * * kwargs)

Return inner

In this decorator function requires_ints we can see that he defines an embedded function inner, the parameters of this embedded function first collect all the parameters of the decorated function, and then determine whether it is an integer type (this is the additional function added by the decorator), and then call the decorated function itself, and finally return the embedded function. Therefore, when we call with the original function name, the reference of the original decorated function can point to the new embedded function, which can add additional functions to the original function.

At the same time, let's refine a few important and difficult points:

First, in requires_ints, the variable decorated is a variable with built-in scope, and the returned inner function can remember this variable after he calls to exit.

Second, python does not support the polymorphism of a function's argument list, that is, a function name can only correspond to a unique argument list form.

Third, when calling the decorated function inside the embedded function, use the unpack parameter, which is described in detail in the previous section about the parameter form of this args, * kwargs.

Then we also use this decorator to decorate a function.

@ requires_ints

Def foo (XBI y):

Print (xroomy)

Foo (3 and 5)

eight

Here, the name foo is assigned to the inner function instead of to the originally defined function. If you run foo (3Power5), you will run the inner function with these two parameters, and the inner function will perform type checking, and then run the decorated method. If the number passed in is not an integer number, for example, the following example, then the additional function of the decorator will check the type:

@ requires_ints

Def foo (XBI y):

Print (xroomy)

Foo ('axiaophone5)

Traceback (most recent call last):

File "E:/12homework/12homework.py", line 15, in

Foo ('axiaophone5)

File "E:/12homework/12homework.py", line 7, in inner

Raise TypeError ('{} only accepts integers as arguments'.format (decorated.__name__))

TypeError: foo only accepts integers as arguments

Secondly, the parameter form of the embedded function and the decorated function must be exactly the same, the general form of the args, * kwargs profile function parameters used here, so it is exactly corresponding.

Finally, talk about the parameters of the decorator.

Finally, let's introduce this more complex topic, decorator parameters. In the regular example we cited earlier, the decorator has only one parameter, which is the way it is decorated. However, sometimes it is useful to let the decorator itself carry some necessary information so that the decorator can decorate in an appropriate way.

These parameters are not juxtaposed with the decorated function as parameter signatures, but add an additional layer of encapsulation to the original decorator, so the essence is that the decorator that accepts other parameters is not an actual decorator, but a function that returns the decorator.

The final returned embedded function inner is the function that ends up using the indent and sort_keys parameters, which is no problem.

Import json

Def json_output (indent=None, sort_keys=False):

Def actual_decorator (decorated):

Def inner (* args, * * kwargs):

Result = decorated (* args, * * kwargs)

Return json.dumps (result, indent=indent, sort_keys=sort_keys)

Return inner

Return actual_decorator

@ json_output (indent=8)

Def do_nothing ():

Return {'status':'done','func':'yes'}

Print (do_nothing ())

{

"status": "done"

"func": "yes"

}

What we explain in detail here is the order of operation. It looks like we are using @ jsonoutput (indent=8), which looks a little different from the previous decorator syntax sugar. In fact, this is not the final decorator function. By calling jsonoutput (indent=8) and returning the function pointer actual_decorator, this function is the decorator function that is really placed after @. The original decorated function finally gets a richer inner function object. The decoration process is completed, and it is worth mentioning that the so-called decorator parameters are finally passed to the innermost inner function.

Remember, after defining the decorator function, the real decorator function has only one parameter, that is, the decorated function pointer, and the function with other parameters is essentially the peripheral function of the decorator. he can further customize the decorator based on the parameters. Bottom line: it is impossible for a function to accept decorated methods and other parameters

In syntax sugar, @ func without parentheses is directly decorated with the decorator function. If it is @ func () with parentheses, it essentially calls the func () function to return the real decorator, and then calls it with @.

Thank you for reading this article carefully. I hope the article "what is the grammar of decorators in Python" shared by the editor will be helpful to you. At the same time, I also hope that you will support us and pay attention to the industry information channel. More related knowledge is waiting for you to learn!

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.