vlambda博客
学习文章列表

＃它不是黑魔法，只是给包装（wrapper）传递参数：
def a_decorator_passing_arguments(function_to_decorate): def a_wrapper_accepting_arguments(arg1, arg2): print("I got args! Look: {0}, {1}".format(arg1, arg2)) function_to_decorate(arg1, arg2) return a_wrapper_accepting_arguments
＃因为当您调用装饰器返回的函数时，调用的包装器（wrapper），将参数传递给被包装器包装的函数
@a_decorator_passing_argumentsdef print_full_name(first_name, last_name): print("My name is {0} {1}".format(first_name, last_name))
print_full_name("Peter", "Venkman")# 输出:#I got args! Look: Peter Venkman#My name is Peter Venkman

＃装饰器是普通函数def my_decorator(func): print("I am an ordinary function") def wrapper(): print("I am function returned by the decorator") func() return wrapper
# 因此，你可以调用它，而不用 "@"
def lazy_function(): print("zzzzzzzz")
decorated_function = my_decorator(lazy_function)#输出: I am an ordinary function
# 它输出了 "I am an ordinary function", 因为你只是调用了装饰器，而没有调用函数:# 这里没有什么神奇的地方，使用'@'
@my_decoratordef lazy_function(): print("zzzzzzzz")
#outputs: I am an ordinary function

def decorator_maker():
 print("I make decorators! I am executed only once: " "when you make me create a decorator.")
 def my_decorator(func):
 print("I am a decorator! I am executed only when you decorate a function.")
 def wrapped(): print("I am the wrapper around the decorated function. " "I am called when you call the decorated function. " "As the wrapper, I return the RESULT of the decorated function.") return func()
 print("As the decorator, I return the wrapped function.")
 return wrapped
 print("As a decorator maker, I return a decorator") return my_decorator
#让我们新建一个装饰器new_decorator = decorator_maker() #输出:#I make decorators! I am executed only once: when you make me create a decorator.#As a decorator maker, I return a decorator
# 让我们装饰这个函数def decorated_function(): print("I am the decorated function.")
decorated_function = new_decorator(decorated_function)#输出:#I am a decorator! I am executed only when you decorate a function.#As the decorator, I return the wrapped function
# 让我们调用这个函数decorated_function()
#输出:#I am the wrapper around the decorated function. I am called when you call the decorated function.#As the wrapper, I return the RESULT of the decorated function.#I am the decorated function.

def decorated_function(): print("I am the decorated function.")decorated_function = decorator_maker()(decorated_function)#输出:#I make decorators! I am executed only once: when you make me create a decorator.#As a decorator maker, I return a decorator#I am a decorator! I am executed only when you decorate a function.#As the decorator, I return the wrapped function.
# Finally:decorated_function() #输出:#I am the wrapper around the decorated function. I am called when you call the decorated function.#As the wrapper, I return the RESULT of the decorated function.#I am the decorated function.

@decorator_maker()def decorated_function(): print("I am the decorated function.")#输出:#I make decorators! I am executed only once: when you make me create a decorator.#As a decorator maker, I return a decorator#I am a decorator! I am executed only when you decorate a function.#As the decorator, I return the wrapped function.
#最终: decorated_function() #输出:#I am the wrapper around the decorated function. I am called when you call the decorated function.#As the wrapper, I return the RESULT of the decorated function.#I am the decorated function.

def decorator_maker_with_arguments(decorator_arg1, decorator_arg2):
 print("I make decorators! And I accept arguments: {0}, {1}".format(decorator_arg1, decorator_arg2))
 def my_decorator(func): ＃这里传递的参数是闭包的。 ＃如果您对封包感到不舒服，可以忽略这点。 print("I am the decorator. Somehow you passed me arguments: {0}, {1}".format(decorator_arg1, decorator_arg2))
 ＃不要混淆装饰器参数和函数参数！ def wrapped(function_arg1, function_arg2) : print("I am the wrapper around the decorated function.\n" "I can access all the variables\n" "\t- from the decorator: {0} {1}\n" "\t- from the function call: {2} {3}\n" "Then I can pass them to the decorated function" .format(decorator_arg1, decorator_arg2, function_arg1, function_arg2)) return func(function_arg1, function_arg2)
 return wrapped
 return my_decorator
@decorator_maker_with_arguments("Leonard", "Sheldon")def decorated_function_with_arguments(function_arg1, function_arg2): print("I am the decorated function and only knows about my arguments: {0}" " {1}".format(function_arg1, function_arg2))
decorated_function_with_arguments("Rajesh", "Howard")#输出:#I make decorators! And I accept arguments: Leonard Sheldon#I am the decorator. Somehow you passed me arguments: Leonard Sheldon#I am the wrapper around the decorated function. #I can access all the variables # - from the decorator: Leonard Sheldon # - from the function call: Rajesh Howard #Then I can pass them to the decorated function#I am the decorated function and only knows about my arguments: Rajesh Howard

c1 = "Penny"c2 = "Leslie"
@decorator_maker_with_arguments("Leonard", c1)def decorated_function_with_arguments(function_arg1, function_arg2): print("I am the decorated function and only knows about my arguments:" " {0} {1}".format(function_arg1, function_arg2))
decorated_function_with_arguments(c2, "Howard")#输出:#I make decorators! And I accept arguments: Leonard Penny#I am the decorator. Somehow you passed me arguments: Leonard Penny#I am the wrapper around the decorated function. #I can access all the variables # - from the decorator: Leonard Penny # - from the function call: Leslie Howard #Then I can pass them to the decorated function#I am the decorated function and only know about my arguments: Leslie Howard