Pourquoi ma fonction imbriquée en Python accède-t-elle uniquement à la dernière valeur d'une variable de boucle ?

Variables locales dans les fonctions imbriquées

Les fonctions imbriquées offrent un moyen pratique d'organiser le code et d'encapsuler les fonctionnalités dans un contexte plus large. Cependant, comprendre comment les variables sont gérées dans des portées imbriquées peut souvent laisser les développeurs perplexes.

Considérez l'extrait de code suivant :

class Cage(object):
    def __init__(self, animal):
        self.animal = animal

def get_petters():
    for animal in ['cow', 'dog', 'cat']:
        cage = Cage(animal)

        def pet_function():
            print("Mary pets the " + cage.animal + ".")

        yield (animal, cage.animal)

Dans cet exemple, une fonction génératrice get_petters() parcourt un liste d'animaux, créant un objet Cage pour chacun et produisant un tuple contenant le nom de l'animal et une fonction imbriquée qui tente d'accéder à la cage locale variable.

Lors de l'exécution de ce code, vous pouvez vous attendre à voir trois animaux différents imprimés, correspondant aux trois instances différentes de la variable cage. Cependant, le résultat ne donne que « Mary caresse le chat » à plusieurs reprises.

Comprendre le comportement de fermeture

Le nœud du problème réside dans la nature de la fermeture en Python. Lorsque les fonctions imbriquées sont définies, elles capturent les références aux variables dans leur portée englobante. Dans le code fourni, la fonction pet_function est imbriquée au sein de la fonction get_petters() et a ainsi accès à la variable cage.

Cependant, cette référence n'est pas établie au moment de la définition de la fonction. Au lieu de cela, cela se produit au moment de l’exécution de la fonction. Au moment où les fonctions imbriquées sont exécutées, la variable cage s'est déjà vu attribuer la valeur « chat » lorsqu'elle parcourt la liste des animaux.

Remèdes

Pour résoudre ce problème, on peut adopter plusieurs approches :

1. Fonctions partielles :

Une fonction partielle est un appelable qui encapsule une fonction existante et initialise certains de ses arguments avec des valeurs prédéfinies. Dans ce cas, vous pouvez utiliser functools.partial() pour créer une fonction pet partielle qui lie la variable cage au contexte approprié :

def pet_function(cage=None):
    print("Mary pets the " + cage.animal + ".")

yield (animal, partial(pet_function, cage=cage))

2. Création de nouvelles étendues :

Une autre option consiste à définir la fonction animal dans une étendue imbriquée qui garantit que la variable cage est toujours liée localement à la valeur correcte :

def scoped_cage(cage=None):
    def pet_function():
        print("Mary pets the " + cage.animal + ".")
    return pet_function

yield (animal, partial(pet_function, cage))

3. Paramètres de mot-clé par défaut :

Vous pouvez également transmettre la variable cage comme argument de mot-clé par défaut à la fonction pet :

def pet_function(cage=cage):
    print("Mary pets the " + cage.animal + ".")

yield (animal, partial(pet_function))

En adhérant à ces techniques, vous pouvez vous assurer que les imbriqués les fonctions fonctionnent avec les variables locales attendues, éliminant les effets secondaires inattendus et préservant la clarté du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!