Chiusura di Python

In questo articolo, discuteremo di chiusura di Python.Prima di capire la chiusura di Python, dobbiamo comprendere le funzioni nidificate e le variabili non locali.

Funzione nidificata:

Una funzione nidificata è definita all'interno di un'altra funzione. Queste funzioni possono accedere a una variabile della funzione esterna. La variabile non locale che possiamo accedere nel loro ambito.

Ex:

defouter_fun (s):
msg = s #non variabile locale
deforner_fun ():
Stampa (MSG)
Inner_fun ()
Outer_fun ("buongiorno")

Produzione:

Nell'esempio sopra, Inner_fun è una funzione nidificata e MSG è una variabile non locale. Possiamo accedervi all'interno del corpo esterno_fun.

Definizione di chiusura:

La chiusura di Python è una funzione nidificata. Possiamo accedere alla variabile al di fuori dell'ambito. Questo concetto è essenziale per comprendere i decoratori di pitone.

Tutte le funzioni nidificate non sono chiusure. I seguenti tre criteri dovrebbero soddisfare per definire una chiusura:

1. Dovremmo avere una funzione nidificata (funzione all'interno di un'altra funzione)
2. La funzione nidificata dovrebbe riferirsi a una variabile non locale
3. La funzione dell'ambito esterno deve restituire la funzione interna.

Ex:

#Defining funzioni nidificate
defgreet_msg (s):
msg = s# msg ha portata nella funzione esterna
defprint_msg ():
Stampa (MSG)#Utilizzo della variabile non locale
returnprint_msg#oggetto return invece di chiamare una funzione interiore
call_fun = sagure_msg ('buongiorno')
call_fun ()
call_fun ()

Produzione:

Nell'esempio sopra, il sagry_msg è la funzione esterna. Questo crea una funzione interiore (Glead_MSG è la chiusura qui) e viene restituita.

La funzione esterna GLEE_MSG restituisce una funzione print_msg ed è assegnata alla variabile Call_Fun. Qui vediamo che la funzione esterna ha terminato la sua esecuzione, ma possiamo ancora accedere alla variabile MSG.

Come modificare la variabile all'interno della chiusura:

Utilizzando la parola chiave non locale possiamo modificare la variabile all'interno della funzione interna.

Ex: Senza usare la parola chiave non locale. Qui stiamo cercando di modificare la variabile NUM all'interno della chiusura e ottenuto illegalerror perché Python pensa che Num come una variabile locale e NUM non sia definito all'interno di Fun ().

defGenerate_num ():
Num = 0
deffun ():
num += 1
Stampa (num)
restituire divertimento
g = generate_num ()
G()
G()
G()

Produzione:

Ex: Con l'uso non locale parola chiave. Nell'esempio seguente usando la parola chiave non locale saremo in grado di modificare la variabile NUM.

defGenerate_num ():
Num = 0
deffun ():
Num non locale
num += 1
Stampa (num)
restituire divertimento
g = generate_num ()
G()
G()
G()

Produzione:

Scriveremo più esempio usando una chiusura:

Ex: Questo stamperà gli argomenti passati e il nome della funzione

Defouter (Func):
deflosure (*args):
print ('running "" con argomenti '.Formato (func.__Name__, args))
stampa (func (*args))
Restituzione della chiusura
Defadd (a, b):
Return+b
defsub (a, b):
restituire A-B
defmul (a, b):
restituire un*b
defdiv (a, b):
restituire a/b
add_closure = esterno (aggiungi)
sub_closure = esterno (sub)
Mul_Closure = esterno (Mul)
Div_Closure = Outer (Div)
add_closure (3, 3)
add_closure (4, 5)
Sub_Closure (10, 5)
Sub_Closure (20, 10)
Mul_Closure (10, 5)
Mul_Closure (20, 10)
Div_Closure (10, 5)
Div_Closure (20, 10)

Produzione:

Ex: Nell'esempio seguente, ogni volta che viene chiamata la chiusura, i valori verranno aggiunti a un elenco e aggiungeranno tutti i valori nell'elenco, quindi restituire un valore.

defadddition ():
res = []
deffunc_sum (val):
res.append (val)
sum_res = sum (res)
returnsum_res
returnfunc_sum
s = aggiunta ()
t = s (2)
stampa (t)
t = s (5)
stampa (t)
t = s (10)
stampa (t)
t = s (100)
stampa (t)

Produzione:

Ex: In questo esempio moltiplica il parametro del parametro della funzione interna per parametro della funzione esterna
def multiply_by_number (m):

# funzione interiore
Deternica (N):
# m viene moltiplicato per n
restituire n * m
# Restituisci la funzione interiore
operazione di ritorno
multiply_by_10 = multiply_by_number (10)
# dovrebbe stampare 20
print (multiply_by_10 (2))
# dovrebbe stampare 100
stampa (multiply_by_10 (10))
# dovrebbe stampare 120
Stampa (Multiply_By_10 (12))

Produzione:

Conclusione:

La chiusura di Python è una funzione nidificata. Con questo, possiamo evitare di usare variabili globali usando variabili non locali. Ciò fornisce alcuni dati che nascondono e comprendono questo concetto utili nella costruzione di un decoratore Python.