El mundo de la programación en Python

Guía completa de anotaciones de tipo en Python

Funciones, clases y estructuras
目次

1. Necesidad y ventajas de las anotaciones de tipo

Python es un lenguaje de tipado dinámico y funciona sin que se especifiquen explícitamente los tipos de variables y funciones. Esta característica permite una codificación flexible, pero, a medida que el código crece o en contextos de trabajo en equipo, puede convertirse en una desventaja para facilitar la lectura del código por parte de otros desarrolladores. Ahí es donde las anotaciones de tipo resultan útiles.

Desafíos del tipado dinámico y ventajas de las anotaciones de tipo

En Python, a veces puede ser ambiguo qué tipo debe tener una variable. Este problema puede pasar desapercibido en scripts pequeños, pero cuanto más crece el código, más difícil se vuelve entenderlo y se convierte en un caldo de cultivo para errores. Al utilizar anotaciones de tipo se obtienen ventajas como las siguientes.
  • Mejora de la legibilidad: Gracias a las anotaciones de tipo, los tipos de las variables y funciones quedan explícitos, lo que facilita a otros desarrolladores comprender el código.
  • Detección temprana de errores: Con herramientas como mypy es posible detectar incompatibilidades de tipos antes de ejecutar el código.
  • Mayor eficiencia en el desarrollo: En combinación con las funciones de autocompletado del editor, permite que la codificación sea más fluida.

2. Escritura básica de anotaciones de tipo

Las anotaciones de tipo son una función introducida oficialmente desde Python 3.5, que permite especificar explícitamente los tipos en el código. Con ello, los desarrolladores pueden comprender el comportamiento del código con mayor claridad.

Cómo añadir anotaciones de tipo a las variables

Es sencillo añadir anotaciones de tipo a las variables. Escribe el tipo después del nombre de la variable como se muestra a continuación.
x: int = 10
y: float = 3.14
name: str = "John"

Anotaciones de tipo en los argumentos y valores de retorno de las funciones

En las funciones también puedes añadir anotaciones de tipo a los argumentos y al valor de retorno. Por ejemplo, en la siguiente función se especifica explícitamente que el argumentoa es de tipoint y que el valor de retorno es de tipostr.
def greet(age: int) -> str:
    return f"Your age is {age}"
Las anotaciones de tipo no afectan en tiempo de ejecución, pero mejoran la legibilidad del código y, al integrarse con las funciones de autocompletado del editor, aumentan la eficiencia del desarrollo.
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

3. Uso del módulo typing

El módulo typing de Python se utiliza para representar tipos más complejos. Aquí presentamos algunos tipos de uso común.

Ejemplos de uso del tipo List

Para especificar el tipo de una lista, se utiliza List. En el siguiente ejemplo se muestra una lista de int.
from typing import List

numbers: List[int] = [1, 2, 3, 4, 5]
A partir de Python 3.9, se puede usar list en lugar de List.
numbers: list[int] = [1, 2, 3, 4, 5]

Uso del tipo Dict

También se pueden añadir anotaciones de tipo a los diccionarios. El siguiente ejemplo es un diccionario cuyas claves son de tipo str y cuyos valores son de tipo int.
from typing import Dict

inventory: Dict[str, int] = {"apple": 10, "banana": 5}

Uso de Union

Cuando un valor puede tener varios tipos, se utiliza Union. El siguiente ejemplo muestra que el argumento puede ser de tipo str o int.
from typing import Union

def process(value: Union[int, str]) -> None:
    if isinstance(value, int):
        print(f"Integer: {value}")
    else:
        print(f"String: {value}")
De este modo, al usar el módulo typing, se pueden añadir anotaciones de tipo más flexibles e intuitivas.

4. Ejemplos de uso de anotaciones de tipo avanzadas

Las anotaciones de tipo también admiten estructuras de datos y funciones más complejas. Aquí veremos funciones que devuelven múltiples valores y cómo crear tipos propios.

Especificación de tipos para múltiples valores de retorno

Cuando una función devuelve múltiples valores, se usa tuple para especificar el tipo del valor de retorno.
def get_coordinates() -> tuple[float, float]:
    return 35.6895, 139.6917
De este modo, se explicita el tipo de retorno y se mejora la legibilidad del código.

Definir tipos propios

NewType permite crear tipos propios. Por ejemplo, en el siguiente ejemplo se define un nuevo tipo llamado UserId.
from typing import NewType

UserId = NewType('UserId', int)

def get_user(user_id: UserId) -> str:
    return f"User ID is {user_id}"
Al definir tipos propios, el significado del código se vuelve más claro y la intención se comunica con mayor facilidad.

5. Cómo aprovechar las herramientas de comprobación de tipos

Además de usar anotaciones de tipo, aprovechar herramientas de comprobación estática de tipos permite escribir código más robusto. Entre las herramientas representativas se encuentran mypy y Pylance.

Instalación y uso de mypy

mypy es una de las herramientas de comprobación de tipos y realiza comprobaciones de errores basándose en las anotaciones de tipo incluidas en el código de Python. Primero, instálalo.
pip install mypy
A continuación, ejecuta la comprobación de tipos.
mypy script.py
De este modo, se te notificará cualquier discrepancia de tipos o problema.

Comprobación de tipos en tiempo real con Pylance

La extensión de VSCode Pylance admite la comprobación de tipos en tiempo real. Por ejemplo, en función de las anotaciones de tipo, se muestran mensajes de error en el editor y puedes corregir los problemas de inmediato.
def add_numbers(a: int, b: int) -> str:
    return a + b  # Aquí se mostrará un error y se te indicará corregirlo
Como es posible la comprobación de errores en tiempo real, la velocidad de desarrollo aumenta y se previenen los errores antes de que ocurran.

6. Aprovechamiento de las anotaciones de tipo en proyectos reales

Las anotaciones de tipo también son de gran utilidad en proyectos reales. Aquí presentamos ejemplos prácticos de su uso en proyectos.

Importancia de las anotaciones de tipo en el desarrollo en equipo

Las anotaciones de tipo son especialmente potentes en el desarrollo en equipo y en proyectos de código abierto. El siguiente ejemplo de código es una función que obtiene datos de una API y los procesa.
from typing import Dict, Any

def fetch_data() -> Dict[str, Any]:
    return {"status": 200, "data": {"user": "Alice", "age": 30}}
De este modo, al aclarar la estructura de los datos mediante anotaciones de tipo, otros desarrolladores pueden comprender el código más fácilmente。

Validación mediante anotaciones de tipo

Las anotaciones de tipo también ayudan en la validación de datos. La siguiente función verifica que todos los elementos de una lista sean cadenas.
from typing import List

def validate_strings(values: List[str]) -> bool:
    return all(isinstance(v, str) for v in values)
Al usar anotaciones de tipo, se mejora la exactitud del código y se pueden prevenir errores antes de que ocurran。

Ventajas de la refactorización usando anotaciones de tipo

El uso de anotaciones de tipo también es de gran ayuda durante la refactorización del código. La refactorización consiste en mejorar el código sin cambiar su funcionalidad; en especial cuando se trata de funciones con muchos argumentos o valores de retorno, o de estructuras de datos complejas, las anotaciones de tipo sirven como guía para evitar errores。 Por ejemplo, veamos el siguiente código。
def process_data(data: dict) -> None:
    # Lógica de procesamiento
    pass
Esta función solo recibe un diccionario sencillo, pero si la estructura de los datos se vuelve más compleja o existe la posibilidad de que los datos recibidos sean de tipos distintos, hay riesgo de introducir cambios erróneos durante la refactorización. Al especificar tipos claros como se muestra a continuación mediante anotaciones de tipo, es posible llevar a cabo la refactorización con seguridad incluso cuando haya cambios en el código。
from typing import Dict, Union

def process_data(data: Dict[str, Union[str, int]]) -> None:
    # Lógica de procesamiento
    pass
En este caso, al haberse especificado el tipo Dict[str, Union[str, int]], incluso si se realiza refactorización, un verificador de tipos (p. ej., mypy) detectará errores de antemano y ayudará a prevenir fallos inesperados。

7. Conclusión

Las anotaciones de tipo en Python son una herramienta muy potente para mejorar la legibilidad y la mantenibilidad, especialmente en proyectos de gran escala y en el desarrollo en equipo. Al aprovechar las anotaciones de tipo, se pueden prevenir errores antes de que ocurran y elevar la calidad del código. Además, al utilizar herramientas de comprobación estática de tipos como mypy y Pylance, es posible detectar con antelación los errores de tipo durante el proceso de desarrollo y corregirlos de manera eficiente. En particular, las anotaciones de tipo resultan útiles en los siguientes aspectos。
  • Mejora la legibilidad del código y permite que otros desarrolladores lo entiendan rápidamente.
  • Permite realizar refactorizaciones de forma segura, por lo que, a medida que avanza el proyecto, se puede mantener la calidad del código.
  • Al aprovechar las herramientas de comprobación estática de tipos, es posible la detección temprana y la corrección de errores.
En el futuro, al introducir de forma activa las anotaciones de tipo en los proyectos de Python, será posible crear un código más robusto y fácil de comprender.
侍エンジニア塾