Ausführliche Erklärung von Abschlüssen und Dekoratoren in Python

Closure ist eine wichtige grammatikalische Struktur in der funktionalen Programmierung. Der Abschluss ist auch eine Struktur zum Organisieren von Code, wodurch auch die Wiederverwendbarkeit des Codes verbessert wird.

Wenn innerhalb einer Inline-Funktion auf eine Variable innerhalb der äußeren Funktion (aber nicht im globalen Bereich) verwiesen wird, gilt die Inline-Funktion als Abschluss.

Variablen, die innerhalb einer externen Funktion definiert sind, aber von einer internen Funktion referenziert oder verwendet werden, werden als freie Variablen bezeichnet.

Zusammenfassend muss das Erstellen eines Abschlusses die folgenden Punkte erfüllen:

• 1 Es muss eine eingebettete Funktion vorhanden sein

• 2. Die eingebettete Funktion muss auf die Variable in der externen Funktion verweisen

• 3. Der Rückgabewert der externen Funktion muss die eingebettete Funktion

In [10]: def func(name):
    ...:     def in_func(age):
    ...:         print 'name:',name,'age:',age
    ...:     return in_func
    ...: 

In [11]: demo = func('feiyu')In [12]: demo(19)
name: feiyu age: 19

ein Verschluss generiert - func, und Der Abschluss enthält die freie Variable - in_func. Dies bedeutet also auch, dass die Variable name am Ende des Lebenszyklus der Funktion func noch vorhanden ist, da sie vom Abschluss referenziert wird, sodass sie nicht recycelt wird . name

können Sie externe Variablen direkt referenzieren, aber Sie können externe Variablen nicht überschreiben. Wenn Sie daher die Variablen der übergeordneten Funktion im Abschluss direkt überschreiben, tritt ein Fehler auf. Schauen Sie sich das folgende Beispiel an: python

def counter(start=0):count = [start] def incr():count[0] += 1return countreturn incr

a = counter()
print 'a:',aIn [32]: def counter(start=0):
    ...:     count = start
    ...:     def incr():
    ...:         count += 1
    ...:         return count
    ...:     return incr
    ...: 

In [33]: a = counter()In [35]: a()  #此处会报错

UnboundLocalError: local variable 'count' referenced before assignment

In [36]: def counter(start=0):
    ...:     count = [start]
    ...:     def incr():
    ...:         count[0] += 1
    ...:         return count
    ...:     return incr
    ...: 

In [37]: count = counter(5)

In [38]: for i in range(10):
    ...:     print count(),
    ...:     
[6] [7] [8] [9] [10] [11] [12] [13] [14] [15]

In [1]: def create():
   ...:     return [lambda x:i*x for i in range(5)]  #推导式生成一个匿名函数的列表
   ...: 

In [2]: create()Out[2]: 
[<function __main__.<lambda>>,
 <function __main__.<lambda>>,
 <function __main__.<lambda>>,
 <function __main__.<lambda>>,
 <function __main__.<lambda>>]In [4]: for mul in create():
   ...:     print mul(2)
   ...:     
88888

ein create zurück, das 4 Funktionsvariablen enthält. Diese vier Funktionen beziehen sich alle auf die Schleifenvariable list, was bedeutet, dass sie dieselben Variablen i verwenden und i ändern sich. Wenn die Funktion aufgerufen wird, ist die Schleifenvariable i bereits gleich 4, sodass alle vier Funktionen 8 zurückgeben. Wenn Sie den Wert einer Schleifenvariablen in einem Abschluss verwenden müssen, verwenden Sie die Schleifenvariable als Standardparameter des Abschlusses oder implementieren Sie sie über eine Teilfunktion. Auch das Implementierungsprinzip ist sehr einfach, das heißt, wenn die Schleifenvariable als Parameter an die Funktion übergeben wird, wird neuer Speicher beansprucht. Der Beispielcode lautet wie folgt: i

In [5]: def create():
   ...:         return [lambda x,i=i:i*x for i in range(5)] 
   ...: 
In [7]: for mul in create():
   ...:     print mul(2)
   ...:     
02468

def addb(func):def wrapper():return &#39;<b>&#39; + func() + &#39;</b>&#39;return wrapperdef addli(func):def wrapper():return &#39;<li>&#39; + func() + &#39;</li>&#39;return wrapper 

@addb         # 等同于 demo = addb(addli(demo)) 
@addli        # 等同于 demo = addli(demo)def demo():return &#39;hello world&#39;

print demo()    # 执行的是 addb(addku(demo))

zur Dekoration an demo und dann die dekorierte Funktion zur Dekoration an addli. Das zurückgegebene Endergebnis lautet also: addb

<b><li>hello world</li></b>

def out_func(func):def wrapper():
        func()return wrapper@out_funcdef demo():"""
        this is  a demo.
    """print 'hello world.'if __name__ == '__main__':
    demo()print "__name__:",demo.__name__print "__doc__:",demo.__doc__

hello world.__name__: wrapper__doc__: None

-Dekorator in der Bibliothek verwenden, um die zugrunde liegende Wrapper-Funktion mit Anmerkungen zu versehen. functools@wraps

from functools import wrapsdef out_func(func):    @wraps(func)def wrapper():
        func()return wrapper

Das obige ist der detaillierte Inhalt vonAusführliche Erklärung von Abschlüssen und Dekoratoren in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!