Lassen Sie uns über Python-Dekoratoren sprechen

【Verwandte Lernempfehlungen: Python-Tutorial】

Decorator

1. Im Wesentlichen handelt es sich um eine Funktion, die Parameter als Funktionen akzeptiert.
2. Funktion: Fügen Sie einer bereits implementierten Methode zusätzliche allgemeine Funktionen hinzu, wie z. B. Protokollierung, Laufzeitmessung usw.

Beispiel

Decorator ohne Parameter, ohne @

# 不带参数的装饰器def deco_test(func):
    def wrapper(*args, **kwargs):
        print("before function")
        f = func(*args, **kwargs)
        print("after function")
        return f    return wrapperdef do_something(a,b,c):
    print(a)
    time.sleep(1)
    print(b)
    time.sleep(1)
    print(c)
    return aif __name__ == '__main__':
    # 不用@
    f = deco_test(do_something)("1","2","3")

Ausgabe:

before function
1
2
3
after function

Persönliches Verständnis:

Es entspricht dem Platzieren von zwei Ausgaben außerhalb der Funktion do_something: vor der Funktion und nach der Funktion. do_something 函数外面套了两个输出：before function 和 after function。

不带参数的装饰器，用 @

# 不带参数的装饰器def deco_test(func):
    def wrapper(*args, **kwargs):
        print("before function")
        f = func(*args, **kwargs)
        print("after function")
        return f    return wrapper

@deco_testdef do_something(a,b,c):
    print(a)
    time.sleep(1)
    print(b)
    time.sleep(1)
    print(c)
    return aif __name__ == '__main__':
    # 使用@
    f = do_something("1","2","3")

输出：

before function
1
2
3
after function

个人理解：

相当于执行 do_something 函数的时候，因为有 @ 的原因，已经知道有一层装饰器 deco_test，所以不需要再单独写 deco_test(do_something) 了。

带参数的装饰器

# 带参数的装饰器def logging(level):
    def wrapper(func):
        def inner_wrapper(*args, **kwargs):
            print("[{level}]: enter function {func}()".format(level=level, func=func.__name__))
            f = func(*args, **kwargs)
            print("after function: [{level}]: enter function {func}()".format(level=level, func=func.__name__))
            return f        return inner_wrapper    return wrapper

@logging(level="debug")def do_something(a,b,c):
    print(a)
    time.sleep(1)
    print(b)
    time.sleep(1)
    print(c)
    return aif __name__ == '__main__':
    # 使用@
    f = do_something("1","2","3")

输出：

[debug]: enter function do_something()
1
2
3
after function: [debug]: enter function do_something()

个人理解：

装饰器带了一个参数 level = "debug"。

最外层的函数 logging() 接受参数并将它们作用在内部的装饰器函数上面。内层的函数 wrapper() 接受一个函数作为参数，然后在函数上面放置一个装饰器。这里的关键点是装饰器是可以使用传递给 logging() 的参数的。

类装饰器

# 类装饰器class deco_cls(object):
    def __init__(self, func):
        self._func = func    def __call__(self, *args, **kwargs):
        print("class decorator before function")
        f = self._func(*args, **kwargs)
        print("class decorator after function")
        return f

@deco_clsdef do_something(a,b,c):
    print(a)
    time.sleep(1)
    print(b)
    time.sleep(1)
    print(c)
    return aif __name__ == '__main__':
    # 使用@
    f = do_something("1","2","3")

输出：

class decorator before function
1
2
3
class decorator after function

个人理解：

使用一个装饰器去包装函数，返回一个可调用的实例。 因此定义了一个类装饰器。

两层装饰器

# 不带参数的装饰器def deco_test(func):
    def wrapper(*args, **kwargs):
        print("before function")
        f = func(*args, **kwargs)
        print("after function")
        return f    return wrapper# 带参数的装饰器def logging(level):
    def wrapper(func):
        def inner_wrapper(*args, **kwargs):
            print("[{level}]: enter function {func}()".format(level=level, func=func.__name__))
            f = func(*args, **kwargs)
            print("after function: [{level}]: enter function {func}()".format(level=level, func=func.__name__))
            return f        return inner_wrapper    return wrapper

@logging(level="debug")@deco_testdef do_something(a,b,c):
    print(a)
    time.sleep(1)
    print(b)
    time.sleep(1)
    print(c)
    return aif __name__ == '__main__':
    # 使用@
    f = do_something("1","2","3")

输出：

[debug]: enter function wrapper()
before function
1
2
3
after function
after function: [debug]: enter function wrapper()

个人理解：

在函数 do_something() 外面先套一层 deco_test() 装饰器，再在最外面套一层 logging()

Decorator ohne Parameter, verwenden Sie @

rrreee

Ausgabe:
rrreee

Persönliches Verständnis: 🎜🎜🎜 entspricht der Ausführung der Funktion do_something, da es @ wissen wir bereits, dass es eine Dekoratorebene <code>deco_test gibt, sodass es nicht erforderlich ist, deco_test(do_something) separat zu schreiben. 🎜🎜Dekorator mit Parametern🎜rrreee🎜🎜Ausgabe: 🎜🎜rrreee🎜🎜Persönliches Verständnis: 🎜🎜🎜Der Dekorator benötigt einen Parameter level = "debug". 🎜🎜Die äußerste Funktion logging() akzeptiert Parameter und wendet sie auf die innere Dekoratorfunktion an. Die innere Funktion wrapper() akzeptiert eine Funktion als Parameter und platziert dann einen Dekorator auf der Funktion. Der entscheidende Punkt hierbei ist, dass Dekorateure Parameter verwenden können, die an logging() übergeben werden. 🎜🎜Klassendekorator🎜rrreee🎜🎜Ausgabe: 🎜🎜rrreee🎜🎜Persönliches Verständnis: 🎜🎜🎜Verwenden Sie einen Dekorator, um eine Funktion zu verpacken und eine aufrufbare Instanz zurückzugeben. Daher wird ein Klassendekorator definiert. 🎜🎜Zweischichtiger Dekorator🎜rrreee🎜🎜Ausgabe: 🎜🎜rrreee🎜🎜Persönliches Verständnis: 🎜🎜🎜 Platzieren Sie zunächst eine Ebene von deco_test() außerhalb der Funktion do_something() Decorator, und umschließen Sie dann die äußerste Ebene des logging()-Decorators. 🎜🎜🎜Wenn Sie mehr über das Erlernen des Programmierens erfahren möchten, achten Sie bitte auf die Spalte „PHP-Schulung“! 🎜🎜🎜

Das obige ist der detaillierte Inhalt vonLassen Sie uns über Python-Dekoratoren sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!