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

1 . Beispiel für die Verwendung eines Verschlusses

Schauen wir uns zunächst ein Beispiel für einen Verschluss an:

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

Hier wird beim Aufruf von

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

In der Funktion von

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

Beispiel für die Implementierung eines zählenden Verschlusses:

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

sollte wie folgt verwendet werden:

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]

2. Fallstricke bei der Verwendung von Verschlüssen

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

Ist das Ergebnis nicht sehr seltsam? Man kann das als eine Falle bei der Verwendung von Verschlüssen betrachten! Mal sehen, warum?

Im obigen Code gibt die Funktion

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

3. Verschlüsse und Dekoratoren

Der Dekorator ist eine Anwendung des Verschlusses, aber er übergibt eine Funktion:

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))

Übergeben Sie bei der Ausführung zunächst die Funktion

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>

4. Traps in Dekoratoren

Wenn Sie einen Dekorator schreiben, der auf eine Funktion einwirkt, werden die wichtigen Metainformationen dieser Funktion zum Beispiel Namen, Dokumentzeichenfolgen, Anmerkungen und Parametersignaturen gehen verloren.

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__

Sehen Sie sich die Ergebnisse an:

hello world.__name__: wrapper__doc__: None

Der Funktionsname und die Dokumentationszeichenfolge sind zu Abschlussinformationen geworden. Glücklicherweise können Sie den

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

Überzeugen Sie sich selbst von den Ergebnissen!

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!