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 www.womenshealthlondon.org. 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.

Te puede interesar:Introducción al módulo del sistema operativo Python

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

Te puede interesar:Validación cruzada y búsqueda de cuadrícula para la selección de modelos en Python

['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:

Te puede interesar:Introducción a Python FTP

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

Te puede interesar:Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy

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.

Te puede interesar:Python para PNL: coincidencia de vocabulario y frases con SpaCy

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.

Te puede interesar:Python para PNL: partes del etiquetado de voz y reconocimiento de entidades nombradas

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.