Python Fermetures Exemple De Code

Je suis en train d'apprendre Python en utilisant Dive Into Python 3 livre. Je l'aime, mais je ne comprends pas le à titre d'exemple pour introduire des Fermetures dans la Section 6.5.

Je veux dire, je vois comment il fonctionne, et je pense que c'est vraiment cool. Mais je ne vois pas de réel avantage: il me semble que le même résultat pourrait être obtenu par la simple lecture du fichier ligne par ligne dans une boucle, et de faire un rechercher /remplacer pour chaque ligne lue.

Quelqu'un pourrait-il m'aider à:

comprendre pourquoi à l'aide de fermetures dans cet exemple, améliore le code (par exemple, plus facile à maintenir, étendre, de réutiliser ou de debug?)
ou suggérer une source de certaines autres de la vie réelle des exemples de code où les fermetures de briller?

Merci!

OriginalL'auteur max | 2010-05-09

22

Décorateurs sont un exemple de fermetures. Par exemple,
```
def decorate(f):
    def wrapped_function():
        print("Function is being called")
        f()
        print("Function call is finished")
    return wrapped_function

@decorate
def my_function():
    print("Hello world")

my_function()
```
La fonction wrapped_function est une fermeture, parce qu'il conserve l'accès à des variables dans son champ d'application, en particulier, le paramètre f, la fonction d'origine. Les fermetures sont ce à quoi vous permettre d'y accéder.

Fermetures permet de conserver l'état entre les appels de fonction, sans avoir à recourir à une classe:
```
def make_counter():
    next_value = 0
    def return_next_value():
        nonlocal next_value
        val = next_value
        next_value += 1
        return val
    return return_next_value

my_first_counter = make_counter()
my_second_counter = make_counter()
print(my_first_counter())
print(my_second_counter())
print(my_first_counter())
print(my_second_counter())
print(my_first_counter())
print(my_second_counter())
```
Aussi, les méthodes liées sont techniquement fermetures (même si elles sont probablement mis en œuvre différemment). Les méthodes liées sont fonctions de membre de classe avec leur classe, cuit dans:
```
import sys
w = sys.stdout.write
w("Hello\n")
```
w est essentiellement une fermeture avec une référence à la sys.stdout objet.

Enfin, je n'ai pas lu ce livre, mais une lecture rapide de ce chapitre est lié et je suis très impressionné--c'est si horriblement rond-point qu'il est inutile qu'une explication de fermetures.

Merci!!!! J'aimerais utiliser un Python 3 livre qui est similaire dans le style et la profondeur de cette réponse, mais je ne pouvais pas en trouver un...

OriginalL'auteur Glenn Maynard
2

Cela pourrait ne pas sembler particulièrement utile lorsque vous avez accès à l'ensemble de la base de code ou lorsque vous n'avez pas de possibilité de réutilisation dans l'esprit, mais il est incroyablement puissant et utile lorsque vous essayez de séparer la logique dans différents, de modules réutilisables qui peuvent être mises en œuvre en parallèle par différents développeurs. Si vous étiez tout simplement lire les chaînes de modèle à partir du fichier, chaque module devrait être conscient de ce fichier et de faire passer des nuisances dans la liste des chaînes de modèle. Et si vous avez changé de système, de sorte que les chaînes de modèle est venu à partir d'une URL au lieu de partir d'un fichier, il pourrait briser complètement l'ensemble de votre base de code. D'autre part, si vous avez une logique de traitement prend simplement une fonction de rappel ou plusieurs appel des fonctions, et ensuite vous avez un module qui génère les fonctions dynamiquement à l'aide de contenu à partir d'un fichier, puis seulement le composant que des constructions les fonctions des besoins de changement. C'est le pouvoir d'être en mesure de créer des fonctions dynamiquement.

Oui; mais pourquoi ne pas passer juste la liste de chaînes de caractères? Un module de traiter le fichier ou l'URL ou toute autre source d'entrée que nous avons. Et le reste du programme sera de prendre les règles comme une liste de chaînes de modèle.
l'autre module peut simplement vérifier qu'un objet remplit une liste de prédicats. Il n'a même pas besoin de savoir ce que ces prédicats sont. Cela simplifie la tâche de la deuxième module, et permet d'être réutilisés avec des prédicats non liées à la correspondance de chaîne. Même si, j'en conviens, l'exemple est un peu artificiel. Il y a de meilleurs des cas d'utilisation pour que l'exemple.
Merci, cela rend les choses plus clair pour moi!

OriginalL'auteur Michael Aaron Safyan
2

voici une fermeture de l'utilisation, de configure:
```
def confmaker():
   cf=ini_conf()
   def clo(*args):
      return cf.get(*args)
   return clo

cfget=confmaker()

cfget(...)
```
ici ini_conf est appelée qu'une seule fois. Dans ma compréhension, les fermetures d'éviter les variables globales(comme la mucoviscidose), et de faire l'utilisation la plus simple.

OriginalL'auteur whi
1

Niels-Nomenclature des écritures (avec modifications):

Le même résultat pourrait être obtenu par la simple lecture du fichier ligne par ligne dans une boucle, et de faire un rechercher /remplacer pour chaque ligne lue.

Et, en fait, c'est ce qui est essentiellement accompli dans la section 6.5, où les règles sont placés dans le fichier plural4-rules.txt. Avec des règles comme des chaînes elles peuvent être conservées dans un fichier, et de notre code sépare les données de contrôle. Cela rend le projet plus facile à gérer et à maintenir.

Niels' question m'a motivé à en esquisser le développement du chapitre 6 dans un effort pour comprendre exactement ce que l'auteur a essayé de démontrer. Il y a beaucoup de leçons à apprendre dans le développement et il n'est pas juste au sujet de fermetures, mais sur les meilleures pratiques de codage.

L'exercice m'a permis de comprendre comment les générateurs peuvent être utilisés pour remplacer alternative, moins abstraite et plus empêtré implémentations. Le développement du matériel de 6,2 à travers 6.6 est éducatives assez d'esquisser ici.

Je vais commencer avec Niels' second point relatif à la rupture des règles en la séparation des fonctions de 6,3 comme un segue dans l'esquisse:

Pourquoi, en utilisant les fermetures dans cet exemple, améliorer le code?

L'auteur déclare à ce sujet:

A été l'ajout de ce niveau d'abstraction de la peine? Eh bien, pas encore.

Il y a encore des articles 6.4-6.6. L'histoire des fermetures, et dans ce cas, la construction d'une pluralisation générateur est de réaliser étape par étape, en commençant par le codage en dur des règles dans un module appelé au pluriel(un nom). Donc, en commençant par la première section pertinente et résumant notre chemin à travers à la fin de ce chapitre, nous avons la suite.

6.2 nous allons Utiliser des Expressions Régulières: Ici, l'auteur profite de l'occasion pour renforcer et d'étendre notre compréhension des expressions régulières avec la pluralisation des règles codé en dur dans le délai initial de pluriel fonction.

6.3. Une Liste de Fonctions: les Résumés des règles codé en dur dans le pluriel fonction à plusieurs autonome fonctions. C'est un "tremplin" à la section suivante. Mais il démontre également qu'il existe une différence importante entre l'utilisation de match_sxz() et match_sxz.

6.4 Une Liste De Modèles: Le fait que nous avons créé individu nommé fonctions, couplées par match et s'appliquent, à l'article 6.3 sont redondantes. Ces fonctions sont toutes basées sur le même modèle et ne sont jamais appelé directement. Ici, il modifie ce code afin de le rendre plus simple pour changer les règles. Cela devient un autre niveau d'abstraction, avec les règles spécifiées comme des chaînes de caractères dans la variable appelle le motif. La pluralisation des règles ne sont plus les fonctions.

6.5 Un Fichier De Modèles: Avec pas plus de code en double et la pluralisation des règles définies dans une liste de chaînes de caractères, la prochaine étape en vue de la construction du générateur est de mettre ces chaînes dans un fichier séparé. Ici, ils deviennent plus maintenable, séparé du code qui les utilise.

6.6 Générateurs: Le générateur est un pluriel générique() fonction qui parse le fichier de règles, de contrôles, pour un match, s'applique la règle, le cas échéant, et passe à la règle suivante. Ceci est un exemple d'une fermeture.

C'est tout le pluriel() la fonction a à faire, et c'est tout le pluriel() fonction doit faire.

Relativement simple et belle de développement, assez sophistiquée pour être utile, et extensible à d'autres types de problèmes que l'on peut trouver, en particulier dans le texte de reconnaissance de formes.

L'auteur aborde la problématique de la performance de cette solution particulière à la fin de ce tutoriel. L'ouverture et la lecture des lignes à partir d'un fichier va dégrader les performances, surtout avec un nombre croissant d'appels open (). Il affirme qu'une meilleure performance peut être atteint à l'aide d'un itérateur, qui est considéré comme plus tard dans le livre.

OriginalL'auteur Aaron
0

de lecture dans le fichier ligne par ligne dans une boucle

ligne par ligne dans une boucle

boucle

Ce seront les performances du disque à travers le plancher. Lu une fois, s'appliquent à de nombreuses reprises.

Désolé, je n'ai pas été très précis. Bien sûr, je voudrais stocker les chaînes de modèle, j'ai lu à partir du fichier dans une liste, et puis toujours parcourir cette liste. Mais comment est le passage d'une liste de fonctions de mieux que de passer d'une liste de chaînes de modèle?

OriginalL'auteur Ignacio Vazquez-Abrams

Vous devez vous connecter pour publier un commentaire.