Tutorial de Mypy para Principiantes

Mypy es una herramienta de verificación de tipos estáticos para Python. A diferencia de lenguajes como Java o C++, Python es un lenguaje con tipado dinámico, lo que significa que las variables pueden cambiar de tipo en tiempo de ejecución sin ninguna restricción. Sin embargo, esta práctica puede llevar a errores en tiempo de ejecución difíciles de detectar y solucionar. Mypy permite agregar anotaciones de tipo para detectar estos errores en el código antes de ejecutar este.

¿Por qué puede ser útil usar tipado estático en Python?

El tipado estático con mypy ayuda a mejorar la calidad del código al verificar de forma automática el tipo de dato que se espera. Lo que ofrece múltiples beneficios. Entre los beneficios de verificar los tipos de datos mediante una herramienta como mypy ofrece múltiples ventajas a la hora de desarrollar código.

• Detección temprana de errores: Mypy permite identificar errores de tipo antes de ejecutar el programa, reduciendo el número de fallos en producción.
• Código más claro y mantenible: Las anotaciones de tipo sirven como documentación implícita, ayudando a los desarrolladores a entender mejor el código sin necesidad de revisar todas las implementaciones.
• Mejora en herramientas de autocompletado y documentación: Los editores de código como VS Code y PyCharm pueden usar mypy para ofrecer mejores sugerencias de autocompletado y detección de errores.
• Integración con entornos de desarrollo: Mypy se puede integrar en flujos de trabajo con herramientas de CI/CD para automatizar la verificación de tipos antes de cada despliegue.

Instalación y uso básico de Mypy

Para instalar mypy, simplemente usa el siguiente comando:

En Analytics Lane

Problemas con listas mutables en Python: Cómo evitar efectos inesperados

pip install mypy

Puedes verificar que mypy se ha instalado correctamente ejecutando:

mypy --version

Uno básico de Mypy en un proyecto

Para comenzar a usar mypy en un proyecto, simplemente agrega anotaciones de tipo a tu código. Por ejemplo:

def suma(a: int, b: int) -> str:
    return a + b

Luego, puedes ejecutar el comando mypy segundo del archivo con para verificar el código:

mypy script.py

script.py:2: error: Incompatible return value type (got "int", expected "str")  [return-value]
Found 1 error in 1 file (checked 1 source file)

Al ejecutar el comando se muestra un error ya que el código tiene un error en el tipado de la función. En la definición, se indica que el tipo que devuelve suma() es una cadena de texto, cuando la suma de dos valores enteros es en realidad otro número entero. Si se soluciona el error, como se muestra en el siguiente código, y se vuelve a ejecutar el comando el error desaparecerá.

def suma(a: int, b: int) -> int:
    return a + b

Una vez corregida la función, dado que ya no hay errores de tipado, mypy mostrará un mensaje de éxito indicando que no hay problemas.

Success: no issues found in 1 source file

Conceptos clave de tipado estático en Python

Antes de continuar, dado que Python es un lenguaje con tipado dinámico, es importante conocer qué es y las ventajas de usar tipado estático.

¿Qué es el tipado estático y cómo se compara con el tipado dinámico de Python?

El tipado estático requiere que los tipos de datos sean declarados explícitamente y validados en tiempo de compilación, mientras que el tipado dinámico permite cambiar los tipos de las variables en tiempo de ejecución. Python, por defecto, usa tipado dinámico, pero se puede agregar tipado estático opcional para mayor seguridad y claridad.

Introducción a los Type Hints

Los anotaciones de tipo (Type Hints) permiten especificar el tipo de datos que se espera en una variable, los parámetros de una función o su valor de retorno. Por ejemplo:

numero: int = 10
texto: str = "Hola, mundo"
flotante: float = 3.14

Tipos básicos

Algunos de los tipos básicos en Python son:

• int: enteros (10, -5)
• float: números de punto flotante (3.14, -2.71)
• str: cadenas de texto ("Hola", 'Python')
• bool: valores booleanos (True, False)
• list: listas ([1, 2, 3])
• dict: diccionarios ({"clave": "valor"})

Tipos genéricos con List, Dict, Tuple, Optional, Any

En Python, se pueden usar tipos genéricos con los tipos básicos para obtener una mayor precisión. Por ejemplo, se puede usar List[int] para indicar que la lista solo puede tener números enteros y no de otro tipo. Algunos ejemplos que se pueden hacer con los tipos genéricos son:

from typing import List, Dict, Tuple, Optional, Any

numeros: List[int] = [1, 2, 3]
datos: Dict[str, int] = {"edad": 30, "fecha": 2023}
tupla: Tuple[int, str, float] = (1, "Hola", 3.14)
valor_opcional: Optional[str] = None  # Puede ser str o None
cualquier_tipo: Any = "Texto o número"

Uso de Union y Literal

También se puede especificar que una variable acepte múltiples tipos con Union. Algo útil, cuando una variable puede ser por ejemplo de tipo entero o real. Por otro lado, Literal permite indicar los valores que puede admitir un tipo de datos.

from typing import Union, Literal

valor: Union[int, float] = 5.5
estado: Literal["activo", "inactivo"] = "activo"

Casos de uso de Mypy

Una vez que sabemos cómo indicar los tipos de los datos, se pueden ver algunos casos de uso de Mypy para validar el código.

Validación de argumentos en funciones

Mypy ayuda a asegurarse de que los argumentos pasados a una función coincidan con los tipos esperados:

def dividir(a: int, b: int) -> float:
    return a / b

resultado = dividir(10, 2)  # Correcto
resultado_erroneo = dividir("10", 2)  # Error detectado por mypy

Al ejecutar mypy sobre este código se obtiene un mensaje como el que se muestra a continuación:

script.py:5: error: Argument 1 to "dividir" has incompatible type "str"; expected "int"  [arg-type]
Found 1 error in 1 file (checked 1 source file)

Validación de los tipos de retornos en las funciones

Se puede definir el tipo de retorno de una función para evitar errores:

def obtener_longitud(texto: str) -> int:
    return len(texto)

Tipado en clases y atributos

Mypy también es útil para definir tipos en clases:

class Persona:
    def __init__(self, nombre: str, edad: int):
        self.nombre: str = nombre
        self.edad: int = edad

Uso de Optional para Valores Nulos

Si una variable puede ser None, se debe usar Optional:

from typing import Optional

def obtener_usuario(id: int) -> Optional[str]:
    if id == 1:
        return "Juan"
    return None

Integración con Herramientas de CI/CD

Mypy se puede integrar en herramientas de integración continua como GitHub Actions o pre-commit para verificar el código automáticamente. Por ejemplo, se puede configurar con pre-commit:

-   repo: https://github.com/pre-commit/mirrors-mypy
    rev: v1.0
    hooks:
    -   id: mypy

Con esta configuración, cada vez que se haga un commit, mypy verificará automáticamente los tipos en el código.

Configuración avanzada y opciones de Mypy

En los proyectos, se puede configurar el comportamiento de Mypy con los archivos de configuración.

Configuración con mypy.ini o pyproject.toml

Para proyectos más grandes, mypy permite configuraciones avanzadas mediante un archivo mypy.ini o pyproject.toml:

Ejemplo de mypy.ini:

[mypy]
disallow_untyped_defs = True
ignore_missing_imports = True
strict = True

Estas opciones permiten reforzar el tipado y evitar errores en el código.

Opciones avanzadas

Algunas opciones útiles de mypy:

• --strict: Activa todas las comprobaciones estrictas.
• --ignore-missing-imports: Ignora errores de importación de paquetes sin anotaciones de tipo.
• --disallow-untyped-defs: Obliga a anotar todas las funciones con tipos.

Conclusiones

Mypy es una herramienta que permite mejorar la calidad del código en Python mediante la verificación de tipos estáticos. A lo largo de este tutorial, hemos explorado cómo instalarlo, configurarlo y aplicarlo en distintos escenarios, desde funciones y clases hasta integraciones con CI/CD. Siendo una herramienta que ofrece importantes beneficios entre los que se puede destacar:

• Prevención de errores: Detecta problemas de tipado antes de ejecutar el código.
• Código más claro y mantenible: Facilita la comprensión y documentación del código.
• Mejoras en autocompletado y depuración: Herramientas como VS Code y PyCharm aprovechan mypy para ofrecer sugerencias más precisas.
• Facilidad de integración: Compatible con proyectos grandes, CI/CD y configuraciones avanzadas.

Nota: La imágen de este artículo fueron generadas utilizando un modelo de inteligencia artificial.