Python -Schließung

In diesem Artikel werden wir die Python -Schließung diskutieren.Vor dem Verständnis der Python-Schließung müssen wir verschachtelte Funktionen und nicht lokale Variablen verstehen.

Verschachtelte Funktion:

Eine verschachtelte Funktion ist in einer anderen Funktion definiert. Diese Funktionen können auf eine Variable der äußeren Funktion zugreifen. Die nicht lokale Variable, auf die wir in ihrem Bereich zugreifen können.

Ex:

Defuter_Fun (s):
MSG = S #non Lokale Variable
definner_fun ():
Druck (MSG)
Inner_fun ()
OUTER_FUN ('Guten Morgen')

Ausgang:

Im obigen Beispiel ist das Inner_fun eine verschachtelte Funktion, und MSG ist eine nicht lokale Variable. Wir können auf diese im Outer_Fun -Körper zugreifen.

Abschlussdefinition:

Die Python -Schließung ist eine verschachtelte Funktion. Wir können auf die Variable außerhalb des Geltungsbereichs zugreifen. Dieses Konzept ist wichtig, um Python -Dekorateure zu verstehen.

Alle verschachtelten Funktionen sind keine Schließungen. Die folgenden drei Kriterien sollten erfüllen, um eine Schließung zu definieren:

1. Wir sollten eine verschachtelte Funktion haben (Funktion in einer anderen Funktion)
2. Die verschachtelte Funktion sollte sich auf eine variable, die nicht lokal ist
3. Die Außenbereichsfunktion muss die innere Funktion zurückgeben.

Ex:

#Definierende verschachtelte Funktionen
Defgreet_msg (s):
MSG = S# MSG hat den Umfang der äußeren Funktion
Defprint_msg ():
Print (MSG)#Useuse -Nicht -Lokal -Variable
returnPrint_msg#Rückgabeobjekt zurück, anstatt eine innere Funktion aufzurufen
call_fun = greet_msg ('Guten Morgen')
call_fun ()
call_fun ()

Ausgang:

Im obigen Beispiel ist das GREET_MSG die äußere Funktion. Dies schafft eine innere Funktion (GREET_MSG ist hier schließt) und wird zurückgegeben.

Die äußere Funktion Greet_MSG gibt eine print_msg -Funktion zurück und wird der Variablen call_fun zugewiesen. Hier sehen wir, dass die äußere Funktion ihre Ausführung beendet hat, aber wir können trotzdem auf die MSG -Variable zugreifen.

So ändern Sie die Variable im Verschluss:

Mithilfe von nichtlokalem Schlüsselwort können wir die Variable in der inneren Funktion ändern.

Ex: Ohne nichtlokale Schlüsselwort zu verwenden. Hier versuchen wir, die Num -Variable im Verschluss zu modifizieren und haben ungebundene ERROR erhalten, weil Python NUM als lokale Variable betrachtet und Num nicht in Fun definiert ist ().

DefGenerate_num ():
Num = 0
Deffun ():
num += 1
drucken (num)
Spaß zurückgeben
g = generate_num ()
G()
G()
G()

Ausgang:

Ex: Mit Verwendung nicht lokal Stichwort. Im folgenden Beispiel können wir die NUM -Variable ändern können.

DefGenerate_num ():
Num = 0
Deffun ():
Nichtlokale Num
num += 1
drucken (num)
Spaß zurückgeben
g = generate_num ()
G()
G()
G()

Ausgang:

Wir werden mehr Beispiel mit einem Verschluss schreiben:

Ex: Dies wird bestandene Argumente und Funktionsname drucken

Trouuter (Func):
DefcLosure (*args):
print ('running "" mit Argumenten '.Format (Func.__NAME__, Argumentationen)))
print (func (*args))
Rückschließung
Defadd (a, b):
returna+b
Defsub (a, b):
Return a-b
Defmul (a, b):
Return a*b
Defdiv (a, b):
Return a/b
add_cLosure = äußere (add)
sub_cLosure = äußere (sub)
mul_clous = äußere (mul)
div_clous = äußere (div)
add_closierung (3, 3)
add_cLosed (4, 5)
sub_closier (10, 5)
sub_cleure (20, 10)
mul_cLosure (10, 5)
mul_closier (20, 10)
Div_closier (10, 5)
Div_closier (20, 10)

Ausgang:

Ex: Im folgenden Beispiel werden jedes Mal, wenn der Verschluss aufgerufen wird.

Defaddition ():
res = []
deffunc_sum (val):
res.anhängen (val)
sum_res = sum (res)
returnsum_res
returnfunc_sum
S = Addition ()
t = s (2)
Druck (t)
t = s (5)
Druck (t)
t = s (10)
Druck (t)
t = s (100)
Druck (t)

Ausgang:

Ex: In diesem Beispiel multiplizieren Sie die Parameterzahl der inneren Funktion mit dem Parameter der äußeren Funktion
Def multiply_by_number (m):

# innere Funktion
Defoperation (n):
# m wird mit n multipliziert
return n * m
# Die innere Funktion zurückgeben
Rückgabevorgang
multiply_by_10 = multiply_by_number (10)
# sollte 20 drucken
print (multiply_by_10 (2))
# sollte 100 drucken
print (multiply_by_10 (10))
# sollte 120 drucken
print (multiply_by_10 (12))

Ausgang:

Abschluss:

Die Python -Schließung ist eine verschachtelte Funktion. Damit können wir es vermeiden, globale Variablen mit nicht lokalen Variablen zu verwenden. Dies liefert einige Daten, die dieses Konzept verstecken und verstehen, das beim Aufbau eines Python -Dekorators hilfreich ist.