Introducción a los decoradores de Python

    Introducción

    En Python, un decorador es un patrón de diseño que podemos usar para agregar nueva funcionalidad a un objeto ya existente sin necesidad de modificar su estructura. Se debe llamar a un decorador directamente antes de la función que se va a extender. Con los decoradores, puede modificar la funcionalidad de un método, una función o una clase de forma dinámica sin utilizar directamente subclases. Esta es una buena idea cuando desea ampliar la funcionalidad de una función que no desea modificar directamente. Los patrones de decorador se pueden implementar en todas partes, pero Python proporciona una sintaxis y características más expresivas para eso.

    En este artículo, discutiremos los decoradores de Python en detalle.

    Cómo crear decoradores

    Veamos cómo se pueden crear decoradores en Python. Como ejemplo, crearemos un decorador que podemos usar para convertir la cadena de salida de una función en minúsculas. Para hacerlo, necesitamos crear una función decoradora y debemos definir una envoltura dentro de ella. Mira el siguiente guión:

    def lowercase(func):
        def wrapper():
            func_ret = func()
            change_to_lowercase = func_ret.lower()
            return change_to_lowercase
    
        return wrapper
    

    En el script anterior, simplemente hemos creado un decorador llamado lowercase que toma una función como argumento. Para probar nuestro lowercase función necesitamos crear una nueva función y luego pasarla a este decorador. Tenga en cuenta que, dado que las funciones son de primera clase en Python, puede asignar la función a una variable o tratarla como una. Emplearemos este truco para llamar a la función decoradora:

    def hello_function():
        return 'HELLO WORLD'
    
    decorate = lowercase(hello_function)
    print(decorate())
    

    Salida

    hello world
    

    Tenga en cuenta que puede fusionar los dos fragmentos de código anteriores en uno. Creamos la función hello_function() que devuelve la frase “HOLA MUNDO”. Luego llamamos al decorador y pasamos el nombre de esta función como argumento mientras lo asignamos a la variable “decorar”. Cuando se ejecuta, puede ver que la oración resultante se convirtió en minúsculas.

    Sin embargo, existe una forma más sencilla de aplicar decoradores en Python. Simplemente podemos agregar el @ símbolo antes del nombre de la función decoradora justo encima de la función que se va a decorar. Por ejemplo:

    @lowercase
    def hello_function():
        return 'HELLO WORLD'
    
    print(hello_function())
    

    Salida

    hello world
    

    Cómo aplicar varios decoradores a una función

    Python nos permite aplicar más de un decorador a una sola función. Para hacer esto correctamente, asegúrese de aplicar los decoradores en el mismo orden en que los ejecutaría como código normal. Por ejemplo, considere el siguiente decorador:

    def split_sentence(func):
        def wrapper():
            func_ret = func()
            output = func_ret.split()
            return output
    
        return wrapper
    

    Aquí hemos creado un decorador que toma una oración de entrada y la divide en varias partes. Al decorador se le ha dado el nombre split_sentence. Apliquemos ahora lowercase y split_sentence decoradores a una función.

    Para ejecutar estas operaciones en el orden correcto, aplíquelas de la siguiente manera:

    @split_sentence
    @lowercase
    def hello_function():
        return 'HELLO WORLD'
    print(hello_function())
    

    Salida

    ['hello', 'world']
    

    Nuestra oración se ha dividido en dos y se ha convertido en minúsculas desde que aplicamos ambos lowercase y split_sentence decoradores para hello_function.

    Pasar argumentos a las funciones del decorador

    Los decoradores de Python también pueden interceptar los argumentos que se pasan a las funciones decoradas. Los argumentos, a su vez, se pasarán a la función decorada en tiempo de ejecución. Considere el siguiente ejemplo:

    def my_decorator(func):
        def my_wrapper(argument1, argument2):
            print("The arguments are: {0}, {1}".format(argument1, argument2))
            func(argument1, argument2)
        return my_wrapper
    
    
    @my_decorator
    def names(firstName, secondName):
        print("Your first and second names are {0} and {1} respectively".format(firstName, secondName))
    
    print(names("Nicholas", "Samuel"))
    

    Salida

    The arguments are: Nicholas, Samuel
    Your first and second names are Nicholas and Samuel respectively
    

    En el script anterior, el decorador acepta dos argumentos :, argument1 y argument1.

    Creación de decoradores de uso general

    Los decoradores de uso general se pueden aplicar a cualquier función. Este tipo de decoradores son muy útiles para depurar, por ejemplo.

    Podemos definirlos usando el args y **kwargs argumentos. Todos los argumentos posicionales y de palabras clave se almacenan en estas dos variables, respectivamente. Con args y kwargs, podemos pasar cualquier número de argumentos durante la llamada a una función. Por ejemplo:

    def my_decorator(func):
        def my_wrapper(*args, **kwargs):
            print('Positional arguments:', args)
            print('Keyword arguments:', kwargs)
            func(*args)
        return my_wrapper
    
    @my_decorator
    def function_without_arguments():
        print("No arguments")
    
    function_without_arguments()
    

    Salida

    Positional arguments: ()
    Keyword arguments: {}
    No arguments
    

    Como puede ver, no se pasaron argumentos al decorador.

    Ahora veamos cómo podemos pasar valores a los argumentos posicionales:

    @my_decorator
    def function_with_arguments(x, y, z):
        print(x, y, z)
    
    function_with_arguments(5, 15, 25)
    

    Salida

    Positional arguments: (5, 15, 25)
    Keyword arguments: {}
    5 15 25
    

    Hemos pasado tres argumentos posicionales al decorador. Para pasar argumentos de palabras clave, tenemos que usar palabras clave en la llamada a la función. Aquí hay un ejemplo:

    @my_decorator
    def passing_keyword_arguments():
        print("Passing keyword arguments")
    
    passing_keyword_arguments(firstName="Nicholas", secondName="Samuel")
    

    Salida

    Positional arguments: ()
    Keyword arguments: {'secondName': 'Samuel', 'firstName': 'Nicholas'}
    Passing keyword arguments
    

    Se pasaron dos argumentos de palabras clave al decorador.

    En la siguiente sección, discutiremos cómo depurar decoradores.

    Cómo depurar decoradores

    En este punto, debe haber visto que usamos decoradores para ajustar funciones. El cierre del contenedor oculta el nombre de la función original, su lista de parámetros y la cadena de documentos.

    Por ejemplo: si intentamos obtener los metadatos para el decorador function_with_arguments, obtendremos los metadatos del cierre del contenedor. Demostremos esto:

    function_with_arguments.__name__
    

    Salida

    'my_wrapper'
    

    Esto presenta un gran desafío durante la depuración. Sin embargo, Python proporciona functools.wraps decorador que puede ayudar a resolver este desafío. Funciona copiando los metadatos perdidos a su cierre decorado.

    Ahora demostremos cómo funciona esto:

    import functools
    
    def lowercase(func):
        @functools.wraps(func)
        def my_wrapper():
            return func().lower()
        return my_wrapper
    
    @lowercase
    def hello_function():
        "Saying hello"
        return 'HELLO WORLD'
    
    print(hello_function())
    

    Salida

    hello world
    

    Desde que usamos functools.wraps en la función contenedora, podemos inspeccionar los metadatos de la función para “hello_function”:

    hello_function.__name__
    

    Salida

    'hello_function'
    
    hello_function.__doc__
    

    Salida

    'Saying hello'
    

    El script anterior muestra claramente que los metadatos ahora se refieren a la función en lugar de al contenedor. Te recomiendo que siempre uses functools.wraps siempre que esté definiendo un decorador. Esto le facilitará la depuración.

    Conclusión

    El propósito de los decoradores es cambiar la funcionalidad de una clase, método o función dinámicamente sin usar subclases directamente o cambiar el código fuente de la clase, método o función que necesitamos decorar. En este artículo, vimos cómo crear decoradores simples y de propósito general y cómo pasar argumentos a los decoradores. También vimos cómo depurar los decoradores durante el desarrollo usando el functools módulo.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *