python decorator

Q1. what is decorator in python

Q2.  how do decorated functions work in flask/python? (app.route)

引申:  

Metaprogramming is a programming technique in which computer programs have the ability to treat programs as their data. It means that a program can be designed to read, generate, analyse or transform other programs, and even modify itself while running.^[1][2] In some cases, this allows programmers to minimize the number of lines of code to express a solution, thus reducing the development time.^[3] It also allows programs greater flexibility to efficiently handle new situations without recompilation.

wiki:

A decorator is any callable Python object that is used to modify a function, method or class definition. A decorator is passed the original object being defined and returns a modified object, which is then bound to the name in the definition. Python decorators were inspired in part by Java annotations, and have a similar syntax; the decorator syntax is pure syntactic sugar, using @as the keyword:

@viking_chorus
def menu_item():
    print("spam")

is equivalent to

def menu_item():
    print("spam")
menu_item = viking_chorus(menu_item)

Decorators are a form of metaprogramming; they enhance the action of the function or method they decorate. For example, in the sample below, viking_chorus might cause menu_item to be run 8 times (see Spam sketch) for each time it is called:

def viking_chorus(myfunc):
    def inner_func(*args, **kwargs):
        for i in range(8):
            myfunc(*args, **kwargs)
    return inner_func

Canonical uses of function decorators are for creating class methods or static methods, adding function attributes, tracing, setting pre- and postconditions, and synchronisation,^[23] but can be used for far more besides, including tail recursion elimination,^[24] memoization and even improving the writing of decorators.^[25]

Decorators can be chained by placing several on adjacent lines:

@invincible
@favourite_colour("Blue")
def black_knight():
    pass

is equivalent to

def black_knight():
    pass
black_knight = invincible(favourite_colour("Blue")(black_knight))

or, using intermediate variables

def black_knight():
    pass
blue_decorator = favourite_colour("Blue")
decorated_by_blue = blue_decorator(black_knight)
black_knight = invincible(decorated_by_blue)

In the example above, the favourite_colour decorator factory takes an argument. Decorator factories must return a decorator, which is then called with the object to be decorated as its argument:

def favourite_colour(colour):
    def decorator(func):
        def wrapper():
            print(colour)
            func()
        return wrapper
    return decorator

This would then decorate the black_knight function such that the colour, "Blue", would be printed prior to the black_knight function running. Closure ensures that the colour argument is accessible to the innermost wrapper function even when it is returned and goes out of scope, which is what allows decorators to work.

In Python prior to version 2.6, decorators apply to functions and methods, but not to classes. Decorating a (dummy) __new__ method can modify a class, however.^[26] Class decorators are supported^[27] starting with Python 2.6.

Despite the name, Python decorators are not an implementation of the decorator pattern. The decorator pattern is a design pattern used in statically typed object-oriented programming languages to allow functionality to be added to objects at run time; Python decorators add functionality to functions and methods at definition time, and thus are a higher-level construct than decorator-pattern classes. The decorator pattern itself is trivially implementable in Python, because the language is duck typed, and so is not usually considered as such.^{[clarification needed]}

url: 

https://en.wikipedia.org/wiki/Python_syntax_and_semantics#Decorators