Quelles sont les utilisations de base des fermetures en Python ?

Qu'est-ce qu'une fermeture

Une fermeture est une fonction qui est définie à l'intérieur d'une autre fonction et peut accéder aux variables dans la portée de la fonction même si la fonction a terminé son exécution et a été détruite. En d’autres termes, une fermeture est une combinaison d’une fonction et de son environnement.

En termes simples, la fermeture est une forme spéciale de fonction qui peut accéder aux variables à l'intérieur de la fonction depuis l'extérieur de la fonction, mais ces variables ne seront pas détruites une fois la fonction exécutée. Les fermetures peuvent être utilisées en Python pour créer du code modulaire et réutilisable.

Fermetures en Python

Les fonctions en Python sont des objets de première classe, c'est-à-dire qu'elles peuvent être transmises, référencées, renvoyées et affectées comme les autres objets. En Python, les fermetures peuvent être implémentées via l'imbrication de fonctions.

Voici un exemple simple qui montre comment créer une fermeture :

def outer_function(x): 
    def inner_function(y): 
        return x + y 
    return inner_function 
    
closure = outer_function(10)
print(closure(5))

Dans cet exemple, outer_function est une fonction qui accepte un paramètre x, et renvoie une fonction fonction_intérieure. inner_function est également une fonction qui accepte un paramètre y et renvoie la somme de x et y. outer_function是一个函数，它接受一个参数x，并返回一个函数inner_function。inner_function也是一个函数，它接受一个参数y，并返回x和y的和。

在最后一行代码中，我们创建了一个闭包closure，并将outer_function(10)的返回值（也就是inner_function）赋值给它。然后我们调用closure函数，传入参数5，并打印返回值15。这个例子中，x的值是10，因为我们传递给outer_function的参数是10。

闭包的实现方式

Python 中的闭包有两种实现方式：函数嵌套和装饰器。

函数嵌套

在 Python 中，我们可以定义一个函数，在这个函数内部再定义另一个函数，然后返回这个内部函数。这个内部函数就可以访问外部函数的变量，这就是一个闭包。

嵌套方式如上文的简单例子，在此不再详述。

装饰器

装饰器是 Python 中另一种实现闭包的方式。装饰器是一个函数，它可以接受一个函数作为参数，并返回一个新的函数。新的函数可以在原函数的基础上添加一些新的功能，而不需要改变原函数的代码。

下面是一个简单的例子，演示了如何使用装饰器实现闭包：

def my_decorator(func):
    def wrapper():
        print("Before the function is called.") 
        func() 
        print("After the function is called.") 
    return wrapper 
    
@my_decorator 
def say_hello():
    print("Hello!")
    say_hello()

在这个例子中，我们定义了一个装饰器函数my_decorator，并将其应用到函数say_hello上。装饰器函数接受一个函数作为参数，并返回一个新的函数wrapper。wrapper函数在原函数say_hello的基础上添加了一些新的功能。

在最后一行代码中，我们调用say_hello函数，打印出以下内容：

Before the function is called.
Hello!
After the function is called.

通过装饰器，我们成功实现了一个闭包。

闭包的应用

闭包在 Python 中有很多应用场景，下面列举几个常见的场景：

1. 延迟执行

闭包可以用来实现延迟执行，也就是在函数被调用时才进行计算。这可以提高程序的性能，特别是在计算复杂的表达式时。

下面是一个例子，演示了如何使用闭包实现延迟执行：

def delayed_sum(a, b):
    def sum(): 
        return a + b 
    return sum 
    
result = delayed_sum(1, 2) 
print(result()) # 3

在这个例子中，我们定义了一个delayed_sum函数，它接受两个参数a和b，并返回一个函数sum。当我们调用delayed_sum函数时，它不会计算a和b的和，而是返回一个sum函数。当我们调用sum函数时，它才会计算a和b的和并返回结果。

2. 缓存结果

闭包可以用来缓存函数的结果，特别是在计算复杂的函数时，可以大大提高程序的性能。

下面是一个例子，演示了如何使用闭包实现缓存结果：

def memoize(func):
    cache = {} 
    
    def wrapper(*args):
        if args in cache: 
            return cache[args] 
        result = func(*args) 
        cache[args] = result 
        return result 
    return wrapper 
                                        
@memoize 
def fibonacci(n): 
    if n in (0, 1):
        return n 
    return fibonacci(n - 1) + fibonacci(n - 2) 
    
print(fibonacci(10)) # 55

在这个例子中，我们定义了一个memoize装饰器函数，它可以缓存被装饰函数的结果。在fibonacci函数中，我们使用了memoize装饰器，以避免重复计算斐波那契数列中的值。当我们第一次调用fibonacci函数时，它会计算出fibonacci(0)和fibonacci(1)的值，并将它们存储在缓存中。当我们下一次调用fibonacci

Dans la dernière ligne de code, nous créons une fermeture closure et transmettons la valeur de retour de outer_function(10) (c'est-à-dire inner_function ) lui est attribué. Ensuite, nous appelons la fonction closure, passons le paramètre 5 et imprimons la valeur de retour 15. Dans cet exemple, la valeur de x est 10 car le paramètre que nous avons passé à outer_function est 10.

Comment implémenter des fermetures

Il existe deux façons d'implémenter des fermetures en Python : l'imbrication de fonctions et les décorateurs. 🎜🎜Imbrication de fonctions🎜🎜En Python, nous pouvons définir une fonction, définir une autre fonction à l'intérieur de cette fonction, puis renvoyer cette fonction interne. Cette fonction interne peut accéder aux variables de la fonction externe, qui est une fermeture. 🎜🎜La méthode d'imbrication est comme dans l'exemple simple ci-dessus et ne sera pas décrite en détail ici. 🎜🎜Décorateurs🎜🎜Les décorateurs sont une autre façon d'implémenter des fermetures en Python. Un décorateur est une fonction qui accepte une fonction comme argument et renvoie une nouvelle fonction. La nouvelle fonction peut ajouter de nouvelles fonctions basées sur la fonction d'origine sans modifier le code de la fonction d'origine. 🎜🎜Voici un exemple simple qui montre comment utiliser des décorateurs pour implémenter des fermetures : 🎜

def counter():
    count = 0 
    def inner():
        nonlocal count 
        count += 1 
        return count 
    return inner 
   
c1 = counter() 
c2 = counter() 
print(c1()) # 1 
print(c1()) # 2 
print(c2()) # 1 
print(c2()) # 2

🎜Dans cet exemple, nous définissons une fonction de décorateur my_decorator et l'appliquons à la fonction say_hello on</ code>. La fonction décorateur accepte une fonction en paramètre et renvoie une nouvelle fonction <code>wrapper. La fonction wrapper ajoute de nouvelles fonctions basées sur la fonction originale say_hello. 🎜🎜Dans la dernière ligne de code, nous appelons la fonction say_hello et imprimons ce qui suit : 🎜

🎜Avant que la fonction ne soit appelée
Bonjour ! la fonction est appelée.🎜

🎜Grâce au décorateur, nous avons réussi à implémenter une fermeture. 🎜🎜Applications des fermetures🎜🎜Les fermetures ont de nombreux scénarios d'application en Python. Voici quelques scénarios courants : 🎜🎜1 Exécution retardée 🎜🎜Les fermetures peuvent être utilisées pour implémenter une exécution retardée, c'est-à-dire lorsqu'une fonction est appelée. calcul. Cela peut améliorer les performances du programme, en particulier lors de l'évaluation d'expressions complexes. 🎜🎜Voici un exemple qui montre comment utiliser les fermetures pour implémenter une exécution retardée : 🎜rrreee🎜Dans cet exemple, nous définissons une fonction delayed_sum qui accepte deux paramètres a</ code> et < code>b, et renvoie une fonction sum. Lorsque nous appelons la fonction delayed_sum, elle ne calcule pas la somme de a et b, mais renvoie une somme fonction. Lorsque nous appelons la fonction sum, elle calculera la somme de a et b et renverra le résultat. 🎜🎜2. Mise en cache des résultats 🎜🎜 Les fermetures peuvent être utilisées pour mettre en cache les résultats des fonctions, en particulier lors du calcul de fonctions complexes, ce qui peut grandement améliorer les performances du programme. 🎜🎜Voici un exemple qui montre comment utiliser les fermetures pour mettre en cache les résultats : 🎜rrreee🎜Dans cet exemple, nous définissons une fonction de décorateur memoize qui peut mettre en cache les résultats de la fonction décorée. Dans la fonction fibonacci, nous utilisons le décorateur memoize pour éviter de calculer à plusieurs reprises les valeurs de la séquence de Fibonacci. Lorsque nous appellerons pour la première fois la fonction fibonacci, elle calculera les valeurs de fibonacci(0) et fibonacci(1) et les stockera dans cache. Lorsque nous appellerons la fonction fibonacci la prochaine fois, elle vérifiera d'abord si la valeur requise a été calculée dans le cache. Si c'est le cas, elle renverra directement le résultat dans le cache, sinon elle sera recalculée. . 🎜🎜3. Implémenter des fonctions similaires aux variables privées🎜🎜En Python, nous ne pouvons pas définir directement des variables privées comme Java et C++. Cependant, nous pouvons utiliser des fermetures pour obtenir des fonctionnalités similaires aux variables privées. 🎜

下面是一个例子，演示了如何使用闭包实现私有变量：

def counter():
    count = 0 
    def inner():
        nonlocal count 
        count += 1 
        return count 
    return inner 
   
c1 = counter() 
c2 = counter() 
print(c1()) # 1 
print(c1()) # 2 
print(c2()) # 1 
print(c2()) # 2

在这个例子中，我们定义了一个counter函数，它返回一个inner函数。inner函数可以访问count变量，而count变量是在counter函数中定义的。由于 Python 中没有直接定义私有变量的语法，我们使用了一个内部函数来访问外部函数中的变量。这样，我们就可以实现类似于私有变量的功能。

在调用c1和c2时，它们返回的inner函数中的count变量是不同的。这是因为每次调用counter函数时，它都会返回一个新的inner函数，每个inner函数都有自己的count变量。

闭包的优缺点

闭包有很多优点，例如：

• 可以避免使用全局变量，提高程序的可维护性；

• 可以实现类似于私有变量的功能，提高程序的安全性；

• 可以实现延迟执行和缓存结果，提高程序的性能。

但是，闭包也有一些缺点，例如：

• 可能会占用较多的内存空间，因为闭包会保留外部函数的状态；

• 可能会导致循环引用的问题，如果闭包中引用了外部函数的变量，而这些变量又引用了闭包中的变量，就会出现循环引用的问题。

小结

Python中的闭包是一种非常强大的编程技术，它可以帮助我们提高程序的可维护性、安全性和性能。通过闭包，我们可以避免使用全局变量、实现类似于私有变量的功能、实现延迟执行和缓存结果等。

要使用闭包，我们需要了解闭包的原理和使用方法。在Python中，可以使用嵌

套函数来实现闭包。在定义闭包时，需要注意外部函数和内部函数的作用域、变量的生命周期等问题，以避免出现意外的错误。

在实际编程中，可以使用闭包来实现许多有用的功能，例如缓存结果、实现状态机、实现装饰器等。对于有经验的Python程序员来说，闭包已经成为不可或缺的一部分。

在使用闭包时，需要注意以下几点：

• 尽量避免在闭包中修改外部函数的变量。如果需要修改变量，应该使用nonlocal关键字。

• 闭包中的变量是在函数定义时绑定的，而不是在函数调用时绑定的。因此，如果在闭包中引用了外部函数的变量，应该确保这些变量在闭包定义时是可用的。

• 闭包中引用的外部函数的变量会一直存在，直到闭包被销毁。因此，如果闭包中引用了外部函数的大量变量，可能会占用大量的内存空间。

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!