Cierres Python

Antes de ver qué es un cierre, primero debemos entender qué son las funciones anidadas y las variables no locales. 
 

Funciones anidadas en Python

Una función que se define dentro de otra función se conoce como función anidada. Las funciones anidadas pueden acceder a las variables del ámbito adjunto. 
En Python, solo se puede acceder a estas variables no locales dentro de su alcance y no fuera de su alcance. Esto se puede ilustrar con el siguiente ejemplo: 

# Python program to illustrate
# nested functions
def outerFunction(text):
    text = text
 
    def innerFunction():
        print(text)
 
    innerFunction()
 
if __name__ == '__main__':
    outerFunction('Hey!')

Como podemos ver, se puede acceder fácilmente a innerFunction() dentro del cuerpo de la función exterior pero no fuera de su cuerpo. Por lo tanto, aquí, innerFunction() se trata como una función anidada que usa texto como variable no local.
 

Cierres Python

Un Closure es un objeto de función que recuerda valores en ámbitos adjuntos incluso si no están presentes en la memoria. 
 

• Es un registro que almacena una función junto con un entorno: un mapeo que asocia cada variable libre de la función (variables que se usan localmente pero definidas en un ámbito envolvente) con el valor o la referencia a la que estaba vinculado el nombre cuando se realizó el cierre. creado.
• Una clausura, a diferencia de una función simple, permite que la función acceda a esas variables capturadas a través de las copias de la clausura de sus valores o referencias, incluso cuando la función se invoca fuera de su alcance.

# Python program to illustrate
# closures
def outerFunction(text):
    text = text
 
    def innerFunction():
        print(text)
 
    # Note we are returning function
    # WITHOUT parenthesis
    return innerFunction 
 
if __name__ == '__main__':
    myFunction = outerFunction('Hey!')
    myFunction()

Output:
omkarpathak@omkarpathak-Inspiron-3542:
~/Documents/Python-Programs/$ python Closures.py 
Hey!

1. Como se observa en el código anterior, los cierres ayudan a invocar funciones fuera de su alcance.
2. La función funcióninterna tiene su alcance solo dentro de la funciónexterior. Pero con el uso de cierres, podemos extender fácilmente su alcance para invocar una función fuera de su alcance.

# Python program to illustrate
# closures
import logging
logging.basicConfig(filename='example.log',
                    level=logging.INFO)
 
 
def logger(func):
    def log_func(*args):
        logging.info(
            'Running "{}" with arguments {}'.format(func.__name__,
                                                    args))
        print(func(*args))
         
    # Necessary for closure to
    # work (returning WITHOUT parenthesis)
    return log_func            
 
def add(x, y):
    return x+y
 
def sub(x, y):
    return x-y
 
add_logger = logger(add)
sub_logger = logger(sub)
 
add_logger(3, 3)
add_logger(4, 5)
 
sub_logger(10, 5)
sub_logger(20, 10)

OUTPUT:
omkarpathak@omkarpathak-Inspiron-3542:
~/Documents/Python-Programs/$ python MoreOnClosures.py 
6
9
5
10

Cuándo y por qué usar Closures:

1. Dado que los cierres se utilizan como funciones de devolución de llamada, proporcionan algún tipo de ocultación de datos. Esto nos ayuda a reducir el uso de variables globales.

2. Cuando tenemos pocas funciones en nuestro código, los cierres demuestran ser una forma eficiente. Pero si necesitamos tener muchas funciones, vaya a la clase (OOP).

Este artículo es una contribución de Omkar Pathak . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.