Fermeture python

Dans cet article, nous allons discuter de la fermeture de Python.Avant de comprendre la fermeture de Python, nous devons comprendre les fonctions imbriquées et les variables non locales.

Fonction imbriquée:

Une fonction imbriquée est définie dans une autre fonction. Ces fonctions peuvent accéder à une variable de la fonction extérieure. La variable non locale dont nous pouvons accéder dans leur portée.

Ex:

Defouter_fun (s):
MSG = S #NON Variable locale
Definner_fun ():
imprimer (msg)
inner_fun ()
OUTER_FUN ('Good Morning')

Sortir:

Dans l'exemple ci-dessus, l'inner_fun est une fonction imbriquée, et MSG est une variable non locale. Nous pouvons y accéder à l'intérieur du corps extérieur_fun.

Définition de fermeture:

La fermeture Python est une fonction imbriquée. Nous pouvons accéder à la variable en dehors de la portée. Ce concept est essentiel pour comprendre les décorateurs de python.

Toutes les fonctions imbriquées ne sont pas des fermetures. Les trois critères suivants devraient répondre pour définir une fermeture:

1. Nous devrions avoir une fonction imbriquée (fonction à l'intérieur d'une autre fonction)
2. La fonction imbriquée doit se référer à une variable non locale
3. La fonction de portée extérieure doit renvoyer la fonction intérieure.

Ex:

#Defining Fonctions imbriquées
DEFGREET_MSG (S):
msg = s # msg a une portée dans la fonction extérieure
defprint_msg ():
imprimer (msg) #Using non locale variable
returnprint_msg # Return objet au lieu d'appeler une fonction intérieure
call_fun = accordé_msg ('bonjour')
call_fun ()
call_fun ()

Sortir:

Dans l'exemple ci-dessus, le salut_msg est la fonction extérieure. Cela crée une fonction intérieure (saluer_msg est la fermeture ici), et il est retourné.

La fonction extérieure accueille_msg renvoie une fonction print_msg, et il est affecté à la variable call_fun. Ici, nous voyons la fonction extérieure terminée son exécution, mais nous pouvons toujours accéder à la variable MSG.

Comment modifier la variable à l'intérieur de la fermeture:

En utilisant un mot-clé non local, nous pouvons modifier la variable à l'intérieur de la fonction intérieure.

Ex: Sans utiliser de mot-clé non local. Ici, nous essayons de modifier la variable NUM à l'intérieur de la fermeture et nous a obtenus non liés à l'embouteille parce que Python considère Num comme une variable locale et Num n'est pas défini à l'intérieur de Fun ().

DefGereate_num ():
num = 0
deffun ():
num + = 1
imprimer (num)
retourner
g = generate_num ()
g()
g()
g()

Sortir:

Ex: Avec une utilisation non local mot-clé. Dans l'exemple ci-dessous en utilisant un mot-clé non local, nous pourrons modifier la variable NUM.

DefGereate_num ():
num = 0
deffun ():
Num non local
num + = 1
imprimer (num)
retourner
g = generate_num ()
g()
g()
g()

Sortir:

Nous écrire plus d'exemples en utilisant une fermeture:

Ex: Cela imprimera les arguments passés et le nom de la fonction

Defouter (Func):
Défclosure (* Args):
print ('Running "" avec des arguments '.format (func.__name__, args))
imprimer (func (* args))
fermeture de retour
Defadd (A, B):
retoura + b
Defsub (A, B):
Retour A-B
Defmul (A, B):
retourner un * b
Defdiv (A, B):
retourner a / b
add_closure = exter (add)
sub_closure = exter (sub)
Mul_closure = exter (MUL)
div_closure = exter (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)

Sortir:

Ex: Dans l'exemple ci-dessous, chaque fois que la fermeture est appelée, les valeurs seront ajoutées à une liste et il ajoutera toutes les valeurs de liste puis renvoie une valeur.

Defaddition ():
res = []
deffunc_sum (Val):
res.Ajouter (VAL)
sum_res = sum (res)
returnsum_res
returnfunc_sum
S = addition ()
t = s (2)
imprimer (t)
t = s (5)
imprimer (t)
t = s (10)
imprimer (t)
t = s (100)
imprimer (t)

Sortir:

Ex: Dans cet exemple, multipliez le numéro de paramètre de fonction interne par paramètre de fonction externe
def multiply_by_number (m):

# fonction intérieure
Défopération (n):
# m est multiplié par n
retour n * m
# retourner la fonction intérieure
opération de retour
multiply_by_10 = multiply_by_number (10)
# devrait imprimer 20
imprimer (multiply_by_10 (2))
# devrait imprimer 100
imprimer (multiply_by_10 (10))
# devrait imprimer 120
imprimer (multiply_by_10 (12))

Sortir:

Conclusion:

La fermeture Python est une fonction imbriquée. Avec cela, nous pouvons éviter d'utiliser des variables globales à l'aide de variables non locales. Cela fournit des données de cachette et de compréhension de ce concept utile pour construire un décorateur de python.