Comprendre les fermetures en Python

En Python, les fermetures sont un concept important qui permet à une fonction de "se souvenir" de l'environnement dans lequel elle a été créée, même après la fin de son exécution. Les fermetures nous permettent d'implémenter des fonctions avec état sans utiliser de variables globales ou d'instances de classe.

Dans cet article, nous explorerons les fermetures en implémentant un simple compteur utilisant le mot-clé nonlocal. Plongeons-y !

Qu’est-ce qu’une fermeture ?

Une fermeture se produit lorsqu'une fonction imbriquée fait référence à une variable de sa portée englobante, lui permettant de conserver l'accès à ces variables même après la fin de l'exécution de la fonction englobante. Les fermetures sont particulièrement utiles lorsque vous souhaitez encapsuler un état ou un comportement au sein d'une fonction.

Le mot-clé non local

En Python, nous utilisons le mot-clé nonlocal pour modifier une variable dans la portée englobante la plus proche qui n'est pas globale. Sans le mot-clé nonlocal, une fonction interne ne peut pas modifier les variables dans sa portée englobante ; cela créerait plutôt une nouvelle variable locale. Le mot-clé nonlocal résout ce problème en indiquant à Python que nous voulons travailler avec une variable de la portée englobante.

Implémentation d'un compteur avec fermetures

Créons une fonction de compteur simple qui utilise des fermetures pour suivre le décompte sans compter sur des variables globales ou une classe.

Étape 1 : Définir la fonction make_counter

Nous allons créer une fonction appelée make_counter, qui renverra un incrément de fonction interne. La fonction interne augmentera une variable de comptage à chaque fois qu'elle sera appelée.

Étape 2 : utilisez nonlocal pour modifier la variable de comptage

Pour garantir que la fonction d'incrémentation modifie la variable count définie dans la portée de la fonction make_counter, nous utiliserons le mot-clé nonlocal.

Voici la mise en œuvre :

def make_counter():
    count = 0  # Variable in the enclosing scope

    def increment():
        nonlocal count  # Tell Python to modify the `count` from the enclosing scope
        count += 1  # Increment the counter
        return count  # Return the current count

    return increment  # Return the inner function, which forms the closure

Étape 3 : Utiliser le compteur

Maintenant que nous avons la fonction make_counter, nous pouvons créer une instance du compteur et l'appeler plusieurs fois pour voir l'incrément du compteur.

counter = make_counter()

print(counter())  # Output: 1
print(counter())  # Output: 2
print(counter())  # Output: 3
print(counter())  # Output: 4
print(counter())  # Output: 5

Explication

• La variable count est initialisée à 0 dans la fonction make_counter.
• Chaque fois que nous appelons la fonction d'incrémentation (qui est renvoyée par make_counter), elle modifie la variable count dans la portée englobante à l'aide du mot-clé nonlocal. Grâce à la propriété de fermeture, la fonction d'incrémentation conserve l'accès au comptage même après la fin de l'exécution de la fonction make_counter.

Pourquoi utiliser des fermetures ?

Les fermetures offrent un moyen puissant et élégant d’encapsuler l’état dans les fonctions. Ils sont particulièrement utiles dans les scénarios où :

• Vous souhaitez garder une trace d'une valeur sans l'exposer à la portée globale.
• Vous avez besoin d'une fonction pour mémoriser son état précédent lors de plusieurs appels (comme notre contre-exemple).
• Vous ne souhaitez pas utiliser de variables globales ou créer des classes pour une gestion simple de l'état.

Les fermetures peuvent être utilisées pour des cas d'utilisation plus avancés tels que les décorateurs, la mémorisation et les rappels.

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!