Was sind Dekoratoren in Python? Einführung in Dekoratoren in Python

Der Inhalt dieses Artikels befasst sich mit der Frage, was Dekoratoren in Python sind. Die Einführung von Dekoratoren in Python hat einen gewissen Referenzwert. Ich hoffe, dass es für Sie hilfreich ist.

1. Was ist ein Dekorator?

Ein Dekorator ist im Wesentlichen eine Python-Funktion, die es anderen Funktionen ermöglicht, ohne Codeänderungen zu funktionieren Der Wert des Dekorators ist ebenfalls ein Funktionsobjekt.

Dekoratoren verbessern die Funktionalität von Kerncodeteilen, ohne den Kerncode zu ändern. Fügen Sie beispielsweise Protokolle, Berechtigungsüberprüfung, Transaktionsverarbeitung und andere Szenarien vor Funktionen ein.
Und Sie können eine große Menge ähnlichen Codes extrahieren, der nichts mit Funktionsfunktionen zu tun hat, und ihn wiederverwenden.

2. Frühe Implementierung: Dekoratoren, die keine Dekoratoren sind

• Eine Funktion in Python kann auch als Objekt betrachtet und zugewiesen werden eine Variable und rufen Sie die Funktion über die Variable auf.

Zum Beispiel:

def foo():
   print("2017-06-08")
f = foo    # 将函数赋值给变量，f为函数对象
f()
# 返回结果：
2017-06-08

3. Syntaktischer Zucker @ Implementieren Sie einen einfachen Dekorator

Angenommen, Sie möchten foo verbessern () Funktionalität, z. B. Drucken von Protokollen vor Funktionsaufrufen. Aber ich möchte die Definition der Funktion foo() nicht ändern. Diese Art des dynamischen Hinzufügens von Funktionalität während der Codeausführung wird als „Decorator“ bezeichnet.
lautet wie folgt:

def testfunc(func):
    print('testfunc')
    def wrapper():
        print("%s %s() called" %(time.ctime(),func.__name__))
        return func()
    return wrapper
@testfunc 
def foo():
    print('foo1()')

foo()  # 相当于执行testfunc(foo) ->wrapper(foo) -> foo()

Ausführungsergebnis:

testfunc
Wed Sep 12 15:01:13 2018 foo() called
foo1()

Erklärung: Bevor Sie foo() ausführen, führen Sie zunächst testfunc(foo) aus. , und führen Sie dann wrapper() aus und rufen Sie bei der Rückkehr foo() selbst auf.

4. Dekoratoren, die bestimmte Parametertypen empfangen

• Dekoratoren können Parameter empfangen, wenn die vom Dekorator zurückgegebene Funktion aufgerufen wird Die Wrapping-Funktion wird aufgerufen und übergibt die Parameter an die Wrapping-Funktion, die die Parameter an die dekorierte Funktion übergibt.

lautet wie folgt:

def testfunc_with_args(func):
    def wrapper_argus(arg1, arg2):
        print("I got args! Look:", arg1, arg2)
        func(arg1, arg2)
    return wrapper_argus
@testfunc_with_args
def full_name(first_name, last_name):  # 带参数，将参数传给被装饰的函数
    print("My name is", first_name, last_name)

full_name("Peter", "Venkman")  # 调用

Ausführungsergebnis:

I got args! Look: Peter Venkman
My name is Peter Venkman

5. Decorator mit unbestimmten Parametern

Wenn es mehrere Funktionen gibt, die den Dekorator aufrufen müssen, die Parameter der Funktionen jedoch unterschiedlich sind, wie implementiert man das? Es kann nicht eine Funktion geben, die einem Dekorateur entspricht. Derzeit kann es mithilfe eines Dekorators mit variablen Parametern implementiert werden.
Wie folgt:

def log(func):
    def wrapper(*args,**kwargs):        # 可接受各种参数
        print('call %s():'% func.__name__)
        return func(*args,**kwargs)     # 返回一个函数
    return wrapper                      # 装饰器返回一个函数，进入到wrapper()

@log      # @log放到now()的定义处，相当于执行语句：now = log(now)
def now_1(a,b):
    print('now()1:a+b = ',a+b)
@log
def now_2(a,b,c):
    print('now_2():a+b+c = ',a+b+c)

now_1(1,2)
now_2(1,2,3)

Führen Sie es aus~

6. Mehrere Dekoratoren

Wenn eine Funktion mehrere Funktionen hinzufügen möchte, können Sie darüber nachdenken Verwenden Sie mehrschichtige Dekoratoren, Sie müssen jedoch auf die Ausführungsreihenfolge der Dekoratoren achten.
Zum Beispiel:

# 注意代码的执行顺序
def deco_1(func):
    print('------111111------')
    def wrapper(*args,**kwargs):    # 包裹函数，参数与原函数的参数一致
        print('start: this is deco_1.')
        func(*args,**kwargs)
        print('end: deco_1.')
    return wrapper  # 返回值是一个包裹函数
def deco_2(func):
    print('------222222------')
    def wrapper(*args,**kwargs):
        print('start: this is deco_2.')
        func(*args,**kwargs)
        print('end: deco_2.')
    return wrapper

@deco_1
@deco_2
def now_1(a,b):
    print('now()1:a+b = ',a+b)

now_1(1,2)

Laufendes Ergebnis:

# 结果，注意执行顺序：
------222222------
------111111------
start: this is deco_1.
start: this is deco_2.
now()1:a+b =  3
end: deco_2.
end: deco_1.

7. Der Dekorateur selbst bringt Parameter

Zusätzlich zu den Parametern, die er zum Dekorieren bringt Funktionsparameter, der Dekorateur selbst kann auch Parameter annehmen.

def logging(level):
    def wrapper(func):
        def inner_wrapper(*args, **kwargs):
            print("[{level}]: enter function {func}()".format(level=level, func=func.__name__))
            return func(*args, **kwargs)
        return inner_wrapper
    return wrapper
    
@logging(level='INFO')
def say(something):
    print("say {}!".format(something))

@logging(level='DEBUG')
def do(something):
    print("do {}...".format(something))

say('hello')
do("my work")

Ausführungsergebnis:

# 执行结果：
[INFO]: enter function say()
say hello!
[DEBUG]: enter function do()
do my work...

Verwandte Empfehlungen:

Detaillierte Erklärung der Dekoratoren in Python

Detaillierte Erklärung verschiedener Dekoratoren in Python

Das obige ist der detaillierte Inhalt vonWas sind Dekoratoren in Python? Einführung in Dekoratoren in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!