Cómo comprobar si una función en Python acepta ciertos argumentos

Introducción

En este laboratorio (lab), aprenderás cómo verificar si una función de Python acepta ciertos argumentos explorando las firmas de las funciones. El laboratorio utiliza el módulo inspect para acceder e inspeccionar las firmas de las funciones, proporcionando información valiosa sobre los argumentos esperados y los valores de retorno de una función.

El laboratorio te guía a través de la creación de un script de Python con una función de muestra, luego utiliza inspect.signature() para obtener e imprimir la firma de la función. También aprenderás cómo interpretar la salida para entender los parámetros y el tipo de retorno de la función. Finalmente, el laboratorio demostrará cómo probar el paso de argumentos utilizando bloques try-except.

Aprende sobre las firmas de funciones

En este paso, aprenderás sobre las firmas de funciones en Python. Las firmas de funciones proporcionan información valiosa sobre los argumentos esperados y los valores de retorno de una función. Comprender las firmas de funciones es crucial para escribir código limpio, mantenible y libre de errores.

Una firma de función incluye la siguiente información:

• Nombre de la función: El nombre de la función.
• Parámetros: Los nombres y tipos de los argumentos que la función acepta.
• Tipo de retorno: El tipo de valor que la función devuelve (si lo hay).

Python ofrece varias formas de acceder e inspeccionar las firmas de funciones. Uno de los métodos más comunes y potentes es utilizar el módulo inspect. Exploremos cómo usar el módulo inspect para aprender sobre las firmas de funciones.

Primero, creemos un simple script de Python llamado my_function.py en tu directorio ~/project utilizando el editor VS Code. Este script definirá una función y luego utilizará el módulo inspect para examinar su firma.

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

sig = inspect.signature(add_numbers)

print(sig)

En este script:

• Importamos el módulo inspect.
• Definimos una función llamada add_numbers que toma dos argumentos enteros (x y y) y devuelve su suma como un entero.
• Utilizamos sugerencias de tipo (x: int, y: int, -> int) para especificar los tipos esperados de los argumentos y el valor de retorno.
• Utilizamos inspect.signature() para obtener la firma de la función add_numbers y la almacenamos en la variable sig.
• Imprimimos la firma en la consola.

Ahora, ejecutemos el script utilizando el comando python:

python ~/project/my_function.py

Deberías ver la siguiente salida:

(x: int, y: int) -> int

Esta salida representa la firma de la función add_numbers. Muestra que la función acepta dos parámetros, x e y, ambos se espera que sean enteros, y que la función devuelve un entero.

Comprender las firmas de funciones te ayuda a usar las funciones correctamente y evitar errores comunes. En los siguientes pasos, aprenderás más sobre cómo usar el módulo inspect para extraer información detallada de las firmas de funciones.

Utiliza inspect.signature()

En el paso anterior, aprendiste cómo obtener la firma de una función utilizando inspect.signature(). En este paso, profundizarás en cómo utilizar el objeto de firma para extraer información más detallada sobre los parámetros de la función.

La función inspect.signature() devuelve un objeto Signature, que tiene varios atributos y métodos útiles para inspeccionar los parámetros de la función. Modifiquemos el script my_function.py para explorar estas características.

Abre el archivo my_function.py en tu directorio ~/project utilizando el editor VS Code y modifícalo de la siguiente manera:

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int = 10) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

sig = inspect.signature(add_numbers)

for param in sig.parameters.values():
    print(f"Parameter Name: {param.name}")
    print(f"Parameter Default: {param.default}")
    print(f"Parameter Annotation: {param.annotation}")
    print(f"Parameter Kind: {param.kind}")
    print("-" * 20)

En este script modificado:

• Agregamos un valor predeterminado de 10 al parámetro y (y: int = 10).
• Iteramos sobre el atributo parameters del objeto Signature, que es un diccionario ordenado de objetos Parameter.
• Para cada objeto Parameter, imprimimos sus atributos name, default, annotation y kind.

Ahora, ejecuta el script utilizando el comando python:

python ~/project/my_function.py

Deberías ver la siguiente salida:

Parameter Name: x
Parameter Default: <class 'inspect._empty'>
Parameter Annotation: <class 'int'>
Parameter Kind: POSITIONAL_OR_KEYWORD
--------------------
Parameter Name: y
Parameter Default: 10
Parameter Annotation: <class 'int'>
Parameter Kind: POSITIONAL_OR_KEYWORD
--------------------

Desglosemos la salida:

• Nombre del parámetro: El nombre del parámetro (x e y).
• Valor predeterminado del parámetro: El valor predeterminado del parámetro. Si un parámetro no tiene valor predeterminado, esto será inspect._empty.
• Anotación del parámetro: La anotación de tipo del parámetro (por ejemplo, <class 'int'>).
• Tipo de parámetro: El tipo de parámetro, que puede ser POSITIONAL_OR_KEYWORD, VAR_POSITIONAL, VAR_KEYWORD, KEYWORD_ONLY o POSITIONAL_ONLY. En este caso, tanto x como y son POSITIONAL_OR_KEYWORD, lo que significa que se pueden pasar como argumentos posicionales o de palabra clave.

Al utilizar inspect.signature(), puedes obtener una comprensión más profunda de los parámetros de una función y sus propiedades. Esta información es valiosa para escribir código que interactúe correctamente con las funciones y para documentar tu código de manera efectiva.

Prueba el paso de argumentos con try-except

En este paso, aprenderás cómo utilizar bloques try-except para manejar posibles errores al pasar argumentos a una función. Esto es especialmente importante cuando se trabaja con entrada del usuario o datos externos, donde el tipo de dato o el formato pueden no ser los que la función espera.

Modifiquemos el script my_function.py para incluir el manejo de errores utilizando try-except. Intentaremos llamar a la función add_numbers con argumentos inválidos y capturar el TypeError resultante.

Abre el archivo my_function.py en tu directorio ~/project utilizando el editor VS Code y modifícalo de la siguiente manera:

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int = 10) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

try:
    result = add_numbers("hello", 5)
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

try:
    result = add_numbers(5, "world")
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

try:
    result = add_numbers(5, 5)
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

En este script modificado:

• Encerramos las llamadas a add_numbers en bloques try-except.
• Intentamos llamar a add_numbers con una cadena como primer argumento y un entero como segundo argumento.
• Intentamos llamar a add_numbers con un entero como primer argumento y una cadena como segundo argumento.
• Intentamos llamar a add_numbers con dos enteros como argumentos.
• Si se produce un TypeError (lo que sucederá cuando pasemos una cadena en lugar de un entero), capturamos la excepción y mostramos un mensaje de error.
• Si no se produce ningún TypeError, mostramos el resultado de la llamada a la función.

Ahora, ejecuta el script utilizando el comando python:

python ~/project/my_function.py

Deberías ver la siguiente salida:

Error: unsupported operand type(s) for +: 'str' and 'int'
Error: unsupported operand type(s) for +: 'int' and 'str'
Result: 10

Esta salida demuestra cómo se pueden utilizar los bloques try-except para manejar de forma elegante los errores que se producen al pasar argumentos inválidos a una función. Las dos primeras llamadas a add_numbers dan lugar a excepciones TypeError, que son capturadas y manejadas por los bloques except. La tercera llamada a add_numbers con dos enteros se ejecuta correctamente y se muestra el resultado.

Utilizar bloques try-except es una buena práctica para escribir código robusto y confiable. Te permite anticipar posibles errores y manejarlos de una manera que evite que tu programa se bloquee.

Resumen

En este laboratorio, has aprendido sobre las firmas de funciones en Python y cómo proporcionan información sobre los argumentos esperados y los valores de retorno de una función. Comprender las firmas de funciones es fundamental para escribir código limpio y mantenible.

El laboratorio demuestra cómo utilizar el módulo inspect, específicamente la función inspect.signature(), para recuperar y examinar la firma de una función de Python. Has creado una función simple con sugerencias de tipo y luego has utilizado inspect.signature() para imprimir la firma de la función en la consola, mostrando los tipos de argumentos esperados y el tipo de retorno.