Fermetures de python

Les fonctions écrites en python sont considérées comme des objets de première classe. Le statut équivalent des autres objets est donné aux fonctions dans Python. Les fonctions peuvent être créées et détruites dynamiquement, attribuées à des variables, enregistrées dans les collections, fournies comme arguments, et plus. Le terme «fonctions imbriquées», parfois appelées «fonctions intérieures», fait référence aux fonctions définies à l'intérieur des autres fonctions.

C'est une fonction imbriquée appelée message de construction. Sa fonction principale extérieure est l'endroit où il est défini et appelé.

Dans sa forme la plus élémentaire, la clôture n'est qu'une fonction imbriquée qui a accès à une variable libre laissée après l'exécution d'une fonction d'enclu. Une fermeture python a ces trois propriétés:

• • Il est imbriqué dans la fonction.
  • Il peut accéder à une variable libre en dehors de sa portée.
  • La fonction environnante le renvoie.

Toute variable non liée dans la portée locale est censée être libre. Le mot-clé non local est requis pour que les fermetures fonctionnent avec des variables immuables comme les chaînes et les entiers. Les fermetures de python offrent une sorte de masquage des données et aident à éviter l'utilisation de variables globales.

Portée des variables

Nous devons également en savoir plus sur la portée de la variable Python pour comprendre les fermetures plus pleinement. La portée est une telle région où la variable est observable. Seule la plage spécifiée d'une variable peut être utilisée. Selon les trois lunettes différentes, les variables peuvent souvent être allouées dans trois emplacements distincts:

• • Portée mondiale: Définition d'une variable lorsqu'elle est en dehors de toutes les fonctions. Toute fonction dans le code peut facilement utiliser une variable globale.
  • Portée locale: Une variable est locale à une fonction lorsqu'elle est déclarée à l'intérieur. Une variable locale ne peut être accessible que de l'intérieur des limites d'une telle fonction où il est déclaré.
  • Portée non locale: Une variable allouée est non locale à ses fonctions imbriquées lorsqu'elle est utilisée dans la fonction environnante. La fonction dans laquelle une variable non locale a été définie ainsi que toutes ses fonctions intérieures peuvent accéder à cette variable.

Pourquoi utiliser les fermetures?

Les principales raisons pour lesquelles nous embauchons les décorateurs sont décrites dans la liste suivante:

• • Le fait que les fermetures de Python offrent une certaine forme de masquage des données comme fonctions de rappel sont l'un des principaux avantages de leur utilisation. Par conséquent, l'utilisation des variables globales est diminuée
  • La taille du code peut être diminuée dans certaines circonstances en utilisant les fermetures plutôt que dans les classes.
  • Lors du remplacement des constantes à code dur, les fermetures sont un excellent choix.
  • La fonction décorative des fermetures est très bénéfique.

Quand Python crée-t-il la fermeture?

Python crée une nouvelle portée chaque fois qu'une fonction est invoquée. Python produit en outre une nouvelle fermeture si cette fonction en produit une.

Créer une fonction nommée Multiplicateur qui produit d'abord une fermeture. La multiplication de deux entrées est ce que la fonction multiplicateur renvoie. Mais il utilise une fermeture à la place de cela. Ajoutez trois appels à la fonction multiplicateur ensuite. Trois fermetures sont produites en appelant ces fonctions. Un nombre est multiplié par 2, 4 et 5 par chaque fonction. Ensuite, exécutez les fonctions des fermetures.

Exemple 1:

Pour invoquer une fonction intérieure de l'extérieur de la fonction extérieure, nous devons d'abord comprendre comment. Ces méthodes peuvent renvoyer une valeur. Ici, «t» et «u» sont des variables locales de la fonction f ().

Étant donné que les variables «t» et «u» ne peuvent plus être accessibles après avoir exécuté h = f (), toutes les variables de F (local) ont disparu. Cependant, nous conservons toujours la valeur «T» qui a été retournée et enregistrée en h. Nous pourrions donc pouvoir faire remettre la fonction extérieure à la fonction intérieure. Les fonctions de première classe de Python le rendent possible pour cela. Cela implique que parce que Python interprète les fonctions comme des valeurs, vous pouvez les attribuer aux variables, les fournir en arguments de fonction ou faire remettre en place une autre fonction.

Exemple 2:

Cet exemple montre que la fonction interne «g» est renvoyée par la fonction extérieure f (t).

La fonction g () est maintenant renvoyée par l'expression f (t). En attribuant la valeur de «g» à «h» lorsque nous écrivons h = f (i), «h» peut maintenant être considéré comme «g» et prendre l'argument de G. H (j) équivaut à appeler «g» en conséquence (j).

Exemple 3:

La fonction g (), pas une valeur particulière de cela, est ce que F (t) renvoie. Prenez cette instance en considération pour cela et écrivez ce qui suit:

Ce code renvoie une erreur. Cela signifie que nous avons rencontré une erreur. Nous ne pouvons pas utiliser «H» pour invoquer une fonction car nous retournons le résultat de g (u) de f (t), ce qui est une raison de l'erreur.

Exemple 4:

Nous n'avons pas à garder F (a) dans «H». L'alternative est d'appeler F (a) directement (b). Considérez l'illustration suivante:

La nécessité de faire une différence entre F (A, B) et F (A) doit toujours être gardée à l'esprit (b). Il faut deux paramètres pour appeler la fonction F (a, b). La fonction f (a) (b), en revanche, est une série de fonctions imbriquées, dont chacune n'accepte qu'une seule entrée. Connu comme une fonction unaire, ce type de fonction accepte une seule entrée. Par conséquent, F (a) (b) est une série de deux fonctions unares imbriquées. Ainsi, f (a) est d'abord évalué. Pour enchaîner ces fonctions ensemble, f (a) devrait renvoyer une fonction. Ici, il renvoie la fonction interne «g». Par conséquent, f (a) (b) = g (b).

Exemple 5:

L'utilisation d'une série plus longue de fonctions unaires est tout simplement possible en étendant l'approche actuelle. Les trois fonctions unares imbriquées peuvent également être vues dans cette affaire. La première fonction, f (t), a une fonction à l'intérieur appelée g (u), et g (u) a une fonction à l'intérieur appelé h (v). Chaque fonction intérieure est retournée par sa fonction extérieure.

Ici, nous définissons les fonctions. Ces fonctions renvoient les valeurs. Ensuite, nous initialisons trois variables et leur assignons trois entiers différents. Ensuite, nous appelons ces variables les attributs de la fonction.

Exemple 6:

Supposons qu'il existe des variables non locales dans la fonction extérieure. voyons ce qui se passe.

L'exécution montre qu'il fonctionne sans accroc et que G (u) a accès à la fois à «T» et à «V». Cependant, comment est-ce même imaginable? Maintenant que nous sommes en dehors de la portée de F (T), donc «t» et «V» ne devraient pas être accessibles après la réalisation de F (t). Pourquoi G (u) est-il toujours capable d'y accéder? C'est pour la raison que G (u), la fonction intérieure, est maintenant une fermeture.

Exemple 7:

Modifions la fonction interne utilisée dans ce cas.

Si cela se produit, il ne peut plus être dit être une fermeture. L'explication est que G (u) n'accède pas aux variables non locales «T» et «V». Par conséquent, G (u) n'est pas tenu de les enregistrer.

Exemple 8:

Dans ce cas, nous verrons si nous définissons les valeurs de deux paramètres des fonctions égales, alors cette fonction est définie comme une fermeture ou non.

Une fois de plus, «t» est juste nécessaire pour initialiser «u» dans ce cas. Par conséquent, G (u) n'est pas une fermeture car «g» n'a pas besoin de déclarer «t».

Conclusion

Dans ce guide, nous avons parlé de la fermeture Python. Nous avons également exécuté les différents codes liés à ce sujet. Nous avons besoin d'une fonction dans la fermeture pour définir ce qui suit:

• • La fonction extérieure doit le fournir.
  • Certaines variables non locales de la fonction externe doivent être capturées par elle. Ces variables sont accessibles directement, déclarées comme variables non locales, soit être capturées par une fermeture imbriquée.

En d'autres termes, une fonction et une portée élargie avec des variables libres sont toutes deux considérées comme des fermetures. Appeler la fonction extérieure pour retourner la fermeture est nécessaire après avoir déclaré la fermeture pour l'initialiser.