El mundo de la programación en Python

Guía de tipos de argumentos en Python con hints

Funciones, clases y estructuras
目次

1. Introducción

Python es un lenguaje de programación que, por su flexibilidad y facilidad de uso, es apoyado por una amplia gama de usuarios, desde principiantes hasta profesionales. Sin embargo, la característica de “tipado dinámico” de Python a veces puede afectar la legibilidad y mantenibilidad del programa. Para abordar esto, a partir de Python 3.5 se introdujeron las “pistas de tipo” (Type Hints).

Al usar estas pistas de tipo, es posible mejorar la legibilidad y calidad del código, y aumentar la eficiencia del desarrollo. En este artículo, explicaremos la “especificación de tipos de argumentos” utilizando las “pistas de tipo” de Python, desde los conceptos básicos hasta su uso práctico.

Características del tipado dinámico de Python

Una de las características de Python es el “tipado dinámico”, que permite que el programa funcione sin especificar explícitamente los tipos de variables o funciones. Por ejemplo, el siguiente código funciona sin problemas en Python.

def add(a, b):
    return a + b

result = add(1, 2)  # funciona correctamente

Esta flexibilidad permite realizar prototipos y desarrollos rápidamente, pero por otro lado pueden surgir los siguientes problemas.

  • Los tipos de los argumentos y valores de retorno de las funciones son poco claros, y un uso incorrecto no genera errores.
  • Cuando el proyecto se vuelve grande, la inferencia de tipos se vuelve difícil, lo que puede aumentar la cantidad de bugs.

Contexto de la introducción de pistas de tipo

Las pistas de tipo, introducidas para resolver estos problemas, son un mecanismo que agrega información de tipos al código. Esto brinda los siguientes beneficios.

  • Mejora de la legibilidad: Al explicitar la información de tipos, el papel de funciones y variables se vuelve más claro
  • Uso de herramientas de análisis estático: Con herramientas como mypy, es posible detectar errores de tipo antes de la ejecución
  • Mejora de la eficiencia del desarrollo: La función de autocompletado del IDE se refuerza, permitiendo escribir código de manera más eficiente

En este artículo, nos centraremos en cómo especificar tipos de argumentos usando pistas de tipo de Python, explicándolo con ejemplos concretos. En la siguiente sección, veremos más a fondo qué son las pistas de tipo.

2. ¿Qué son los type hints?

Los “type hints” de Python son un mecanismo para anotar la información de tipos de y variables en el código. Con ello, se clarifica la intención del código y las herramientas de análisis estático y los IDE pueden ejecutar la verificación de tipos del programa. Fueron introducidos en Python 3.5 mediante PEP 484 y sus funcionalidades se han ampliado en versiones posteriores.

Función de los type hints

El objetivo de los type hints no es detectar errores durante la ejecución del programa, sino prevenirlos en el momento de escribir el código. En particular, los type hints son útiles en los siguientes casos.

  • Mejora de la legibilidad del código: al explicitar los tipos, el propósito de funciones y variables se entiende de un vistazo.
  • Eficiencia en el desarrollo en equipo: reduce malentendidos entre desarrolladores y facilita la revisión de código.
  • Aprovechamiento del análisis estático: permite detectar errores de tipo con herramientas como mypy o PyCharm.

Ejemplos de anotación de type hints

Con los type hints, puedes especificar explícitamente los tipos de los argumentos y valores de retorno como se muestra a continuación.

Type hints en funciones

def greet(name: str) -> str:
    return f"Hello, {name}!"

En este código, name se indica como tipo cadena (str) y el valor de retorno de la función también se declara como cadena. En comparación con la ausencia de type hints, la intención de la función queda más clara.

Type hints en variables

A partir de Python 3.6, también puedes anotar variables con type hints.

age: int = 25
names: list = ["Alice", "Bob", "Charlie"]

Características de los type hints

Los type hints son simplemente “pistas” y no cambian la naturaleza de tipado dinámico de Python. Por ejemplo, aunque los tipos no coincidan, no se producirá un error.

Ejemplo de incompatibilidad de tipos

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

result = add_numbers(10, "20")  # No produce error en tiempo de ejecución

El código anterior producirá un error en tiempo de ejecución, pero al usar una herramienta de análisis estático (por ejemplo, mypy) se puede detectar el error con antelación.

Ejemplo de detección con herramienta de análisis estático

Al usar mypy, se señalará la incompatibilidad de tipos de la siguiente manera.

error: Argument 2 to "add_numbers" has incompatible type "str"; expected "int"

 

Ventajas

  1. Mejora la legibilidad del código.
  2. Se refuerzan las funciones de autocompletado en el IDE.
  3. Permite prevenir errores con herramientas de análisis estático.

Limitaciones

  1. Los tipos no se imponen en tiempo de ejecución (se requiere una herramienta de análisis estático).
  2. Si se requieren anotaciones de tipos complejas, la legibilidad puede verse afectada.

Consideraciones al introducir type hints

  1. Introduce los type hints de forma gradual
    En proyectos grandes existentes, se recomienda comenzar introduciendo type hints en algunas funciones o módulos.
  2. Evita anotaciones de tipos complicadas
    Las anotaciones excesivamente complejas perjudican la legibilidad, por lo que es importante mantener la simplicidad.
  3. Aprovecha las herramientas de análisis estático
    Al introducir type hints, combinar herramientas como mypy o pylint maximiza su efectividad.

3. Métodos básicos de especificación de tipos

Al usar las pistas de tipo de Python, puedes especificar explícitamente los tipos de los argumentos, valores de retorno y variables de una función. En esta sección se explica detalladamente cómo especificar tipos básicos.

Especificación de tipos para argumentos y valores de retorno de funciones

Al agregar pistas de tipo a los argumentos y valores de retorno de una función, puedes indicar qué tipos recibe y qué tipos devuelve la función.

Especificación de tipos simple

A continuación se muestra un ejemplo sencillo de especificación de tipos para argumentos y valores de retorno.

def add(a: int, b: int) -> int:
    return a + b
  • a y b: reciben tipo entero (int).
  • Valor de retorno: devuelve tipo entero (int).

Cuando la función tiene varios argumentos

Las pistas de tipo pueden usarse fácilmente incluso cuando hay varios argumentos.

def greet(name: str, age: int) -> str:
    return f"Hello, {name}! You are {age} years old."
  • En esta función, se recibe una cadena (name) y un entero (age), y devuelve una cadena.

Especificación de tipos para variables

A partir de Python 3.6, también se pueden añadir pistas de tipo a las variables.

Especificación básica de tipos para variables

name: str = "Alice"
age: int = 30
is_student: bool = True
  • name: cadena
  • age: entero
  • is_student: tipo booleano (bool)

Variables sin valor inicial pero con tipo especificado

Si solo se especifica el tipo de la variable sin asignarle un valor inicial, se escribe de la siguiente manera.

height: float  # El tipo está especificado, pero no hay valor inicial

En este caso, más adelante será necesario asignar a height un valor del tipo adecuado.

Omisión e inferencia de pistas de tipo

En Python, el código funciona sin pistas de tipo, pero la ausencia de ellas dificulta la comprensión de la intención.

Cuando no se usan pistas de tipo

def multiply(a, b):
    return a * b

En esta función, los tipos de a y b son desconocidos. Por lo tanto, los desarrolladores o el IDE que lean el código no pueden inferir los tipos con precisión.

Al agregar pistas de tipo

def multiply(a: int, b: int) -> int:
    return a * b

Al añadir pistas de tipo, queda claro que esta función recibe argumentos de tipo entero y devuelve un valor de tipo entero.

Especificación de tipos para colecciones

En Python, también se pueden especificar pistas de tipo para colecciones como listas y diccionarios. Es habitual usar el módulo «typing» para ello.

Especificación de tipos para listas

Para listas, se usa typing y su List.

from typing import List

numbers: List[int] = [1, 2, 3]

Especificación de tipos para diccionarios

Se especifican los tipos de clave y valor del diccionario.

from typing import Dict

student_ages: Dict[str, int] = {"Alice": 20, "Bob": 25}

Ejemplo de función usando especificación de tipos

A continuación se muestra un ejemplo de función que utiliza varios tipos.

from typing import List

def calculate_average(grades: List[float]) -> float:
    return sum(grades) / len(grades)

grades = [85.5, 90.0, 78.5]
average = calculate_average(grades)
print(f"Average grade: {average}")

Resumen

Al usar pistas de tipo, la intención del código queda clara y es más fácil prevenir errores. Esta sección explicó los métodos básicos de especificación de tipos. A continuación, en la sección «4. Especificación de tipos para estructuras de datos complejas», se describirán métodos más avanzados.

4. Anotación de tipos para estructuras de datos complejas

En Python, además de los tipos de colecciones básicas como listas y diccionarios, también se pueden especificar tipos para estructuras de datos complejas como tuplas, estructuras anidadas, tipos opcionales, etc. En esta sección, explicaremos los métodos para especificar hints de tipos para estas estructuras de datos.

Anotación de tipos para listas y tuplas

Anotación de tipos para listas

Los hints de tipos para listas se usan con el módulotyping@List. Al especificar explícitamente el tipo de los elementos, se puede definir el contenido de la lista de manera más estricta.

from typing import List

numbers: List[int] = [1, 2, 3, 4]
names: List[str] = ["Alice", "Bob", "Charlie"]
  • numbers: lista de tipo entero (int)
  • names: lista de tipo cadena (str)

Anotación de tipos para tuplas

Las tuplas se especifican usandoTuple. Al describir los tipos de cada elemento en orden, se puede expresar tuplas con elementos de tipos diferentes.

from typing import Tuple

person: Tuple[str, int] = ("Alice", 25)
  • En este ejemplo, person es una pareja de tipo cadena (nombre) y entero (edad).

Anotación de tipos para diccionarios

Para especificar explícitamente los tipos de clave y valor del diccionario, se usaDict.

Anotación de tipos básica para diccionarios

from typing import Dict

student_scores: Dict[str, float] = {"Alice": 95.5, "Bob": 87.0}
  • En este ejemplo, la clave es de tipo cadena (str) y el valor es de tipo punto flotante (float).

Diccionarios anidados

También se puede especificar tipos cuando el valor del diccionario es otro diccionario.

from typing import Dict

class_data: Dict[str, Dict[str, int]] = {
    "Class A": {"Alice": 85, "Bob": 90},
    "Class B": {"Charlie": 88, "Dave": 92},
}
  • En este ejemplo, la clave del diccionario externo es el nombre de la clase (str) y el valor es un diccionario con el nombre del estudiante (str) y la puntuación (int).

Tipos Optional y Union

Tipo Optional

Optional se usa cuando los argumentos o valores de retorno reciben «el tipo especificado oNone».

from typing import Optional

def find_student(name: str) -> Optional[str]:
    students = ["Alice", "Bob", "Charlie"]
    return name if name in students else None
  • En este ejemplo, la función find_student devuelve un valor de tipo str o None.

Tipo Union

UsandoUnion, se pueden especificar múltiples tipos.

from typing import Union

def calculate(value: Union[int, float]) -> float:
    return value * 2.0
  • En este ejemplo, value acepta un entero (int) o un punto flotante (float).

Tipos personalizados y alias de tipos

Alias de tipos

Usando alias de tipos, se pueden expresar especificaciones de tipos complejas de manera concisa.

from typing import List

Vector = List[float]

def add_vectors(v1: Vector, v2: Vector) -> Vector:
    return [x + y for x, y in zip(v1, v2)]
  • Vector se define como una lista de punto flotante (List[float]).

Anotar tipos con clases personalizadas

También se pueden usar clases propias en hints de tipos.

class Student:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

def enroll_student(student: Student) -> str:
    return f"{student.name} has been enrolled."
  • En este ejemplo, se usa la clase Student como pista de tipo.

Anotación de tipos con genéricos

UsandoGeneric, se pueden definir tipos reutilizables.

from typing import TypeVar, Generic, List

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self):
        self.items: List[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()
  • En este ejemplo, la pila puede manejar cualquier tipo (T).

Resumen

En esta sección, hemos explicado los métodos para especificar tipos en estructuras de datos complejas, desde tipos de colecciones básicas como listas, tuplas y diccionarios, hasta tipos Optional, Union y alias de tipos personalizados. Al usar hints de tipos, la legibilidad y seguridad del código mejoran significativamente.
En la siguiente sección «5. Ventajas y limitaciones de los hints de tipos», explicaremos en detalle los beneficios y desafíos de introducir hints de tipos. ¡Por favor, continúen con nosotros!

RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

5. Ventajas y limitaciones de las anotaciones de tipo

Las anotaciones de tipo de Python aportan muchos beneficios para mejorar la calidad del código. Sin embargo, también existen limitaciones y desafíos que deben tenerse en cuenta. En esta sección se explican en detalle las ventajas y limitaciones de las anotaciones de tipo.

Vent de las anotaciones de tipo

1. Mejora la legibilidad del código

Al usar anotaciones de tipo, el propósito de funciones y variables queda claro, lo que mejora significativamente la legibilidad del código. En el desarrollo en equipo, facilita que otros desarrolladores comprendan el código.
Ejemplo:

def calculate_area(length: float, width: float) -> float:
    return length * width
  • Cuando no hay anotaciones de tipo, no está claro qué tipo se espera para length o width, pero al usar anotaciones de tipo se vuelve claro.

2. Detectar errores con herramientas de análisis estático

Al aprovechar las anotaciones de tipo, herramientas de análisis estático como mypy pueden revisar el código y detectar previamente incompatibilidades y errores de tipo.
Ejemplo: Detectar incompatibilidades de tipo

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

# Resultado de la comprobación por mypy:
# error: Argument 2 to "add" has incompatible type "str"; expected "int"
result = add(10, "20")  # Error de tipo

3. Mejora la función de autocompletado en el IDE

Al escribir anotaciones de tipo, el IDE (p. ej., PyCharm o VSCode) ofrece funciones de autocompletado adecuadas. Esto mejora la eficiencia del desarrollo y reduce la aparición de errores.
Ejemplo:

def greet(name: str) -> str:
    return f"Hello, {name}!"

greet("Alice")  # El IDE completa automáticamente los tipos de los argumentos y el valor de retorno

4. Sirve como documentación

Las anotaciones de tipo funcionan como una documentación ligera dentro del código. Los desarrolladores pueden comprender el comportamiento de una función a partir de la información de tipo sin consultar documentación externa.

Limitaciones de las anotaciones de tipo

1. Los tipos no se imponen en tiempo de ejecución

Las anotaciones de tipo no afectan la ejecución de Python, por lo que la coincidencia de tipos solo se verifica mediante análisis estático. En tiempo de ejecución se ignoran, por lo que no se pueden prevenir errores por incompatibilidad de tipos.
Ejemplo:

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

result = divide("10", 2)  # Error en tiempo de ejecución

2. La especificación de tipos puede volverse compleja

Al trabajar con estructuras de datos complejas o genéricos, la escritura de anotaciones de tipo puede volverse engorrosa, lo que afecta la legibilidad del código.
Ejemplo: Anotaciones de tipo complejas

from typing import Dict, List

data: Dict[str, List[Dict[str, int]]] = {
    "group1": [{"name": 5}, {"name": 10}],
    "group2": [{"name": 15}],
}
  • Si el tipo es demasiado detallado, puede reducir la legibilidad.

3. Genera una carga de aprendizaje

Para principiantes que no están familiarizados con las anotaciones de tipo, representa una carga de aprendizaje como una nueva sintaxis. Además, es necesario comprender el uso de los diversos tipos del módulo typing.

4. No afecta el rendimiento de ejecución

Las anotaciones de tipo se ignoran en tiempo de ejecución, por lo que especificar tipos de forma estricta no mejora la velocidad de ejecución. Si se requiere verificación de tipos, es necesario usar herramientas de análisis estático por separado.

Puntos a considerar al introducir anotaciones de tipo

  1. Introduce las anotaciones de tipo de forma gradual
    En proyectos grandes existentes, se recomienda introducir anotaciones de tipo en algunas funciones o módulos.
  2. Evita especificaciones de tipo engorrosas
    Las especificaciones de tipo excesivamente complejas pueden perjudicar la legibilidad, por lo que es importante mantener la concisión.
  3. Utiliza herramientas de análisis estático
    Al introducir anotaciones de tipo, combinar herramientas como mypy o pylint maximiza su efectividad.

6. Verificación de tipos con herramientas de análisis estático

Las anotaciones de tipo de Python no afectan el comportamiento en tiempo de ejecución, pero utilizando herramientas de análisis estático se pueden detectar inconsistencias de tipos o posibles errores. En esta sección, nos centraremos en «mypy», un ejemplo representativo de herramientas de análisis estático compatibles con anotaciones de tipo, y explicaremos cómo utilizarlo.

¿Qué son las herramientas de análisis estático?

Las herramientas de análisis estático son herramientas que verifican tipos y sintaxis sin ejecutar el código. Al realizar análisis estático con anotaciones de tipo, se pueden descubrir de antemano errores y problemas como los siguientes.

  • Incompatibilidad de tipos en argumentos o valores de retorno
  • Llamada a variables o funciones no definidas
  • Señalamiento de partes ambiguas del tipo

Instalación y uso básico de mypy

1. Instalación de mypy

Primero, instale mypy utilizando pip.

pip install mypy

2. Verificación de tipos con mypy

Analice estáticamente un script de Python que contenga anotaciones de tipo. Ejecute el comando de la siguiente manera.

mypy your_script.py

Ejemplo: al analizar un script que contiene el códigoexample.py

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

result = add(10, "20")  # error de tipo

Al ejecutar el comando, se mostrará un error como el siguiente.

error: Argument 2 to "add" has incompatible type "str"; expected "int"

3. Opciones básicas de mypy

mypy tiene varias opciones disponibles, lo que permite personalizar flexiblemente la verificación de tipos.

  • --strict: Habilita la verificación estricta de tipos.
  • --ignore-missing-imports: Ignora errores de importación.
  • --disallow-untyped-defs: No permite funciones sin anotaciones de tipo.

Ejemplo: habilitar la verificación estricta

mypy --strict example.py

Uso de la verificación de tipos en IDEs

1. Verificación de tipos en PyCharm

PyCharm es un IDE que permite utilizar de manera integrada anotaciones de tipo y mypy. Al usar PyCharm, se obtienen las siguientes ventajas.

  • Detecta errores de tipo en tiempo real mientras escribe el código.
  • Proporciona autocompletado basado en anotaciones de tipo.

Pasos de configuración:

  1. En PyCharm, active las anotaciones de tipo en “Settings” → “Languages & Frameworks” → “Python” → “Type Hinting”.
  2. Configure mypy según sea necesario.
JetBrains
PyCharm: The only Python IDE you need

Built for web, data, and AI/ML professionals. Supercharged w…

2. Verificación de tipos en Visual Studio Code (VSCode)

VSCode también soporta anotaciones de tipo. Al instalar la extensión «Python», se puede realizar verificación de tipos y autocompletado.

  • Instalar la extensión “pylance” permite la verificación en tiempo real basada en anotaciones de tipo.

Ejemplos prácticos con herramientas de verificación de tipos

Ejemplo 1: Verificación de tipos de argumentos obligatorios

def greet(name: str) -> str:
    return f"Hello, {name}!"

print(greet(123))  # error de tipo

mypy señala cuando el tipo de un argumento no coincide.

Ejemplo 2: Verificación del tipo Optional

from typing import Optional

def find_student(student_id: int) -> Optional[str]:
    students = {1: "Alice", 2: "Bob"}
    return students.get(student_id)

student_name = find_student(3)
print(student_name.upper())  # Error de tipo (upper no existe en NoneType)

mypy considera la posibilidad del tipo Optional y señala errores en casos donde no se verifica None.

Cómo gestionar la verificación de tipos

1. Automatizar la verificación de tipos

Al integrar mypy en la pipeline de CI/CD, se puede automatizar la verificación de tipos del código. De esta manera, se pueden detectar errores de tipo durante las solicitudes de pull y prevenir el despliegue de código problemático.

2. Integrar en el flujo de desarrollo

Al establecer reglas como las siguientes, se puede operar efectivamente con anotaciones de tipo.

  • Agregar siempre anotaciones de tipo al código nuevo.
  • Analizar periódicamente todo el proyecto con mypy.
  • Si las anotaciones de tipo son ambiguas, añadir explicaciones complementarias en comentarios o documentación.

Conclusión

Al utilizar herramientas de análisis estático, se puede operar efectivamente con anotaciones de tipo, mejorando la calidad del código y permitiendo la detección temprana de errores. Especialmente, al introducir mypy, se puede construir un entorno de desarrollo que maximice el uso de anotaciones de tipo. En la siguiente sección «7. Ejemplos prácticos de uso de anotaciones de tipo» se explicarán específicamente ejemplos de diseño de funciones y clases utilizando anotaciones de tipo.

7. Ejemplos prácticos de uso de anotaciones de tipo

Aquí se explica cómo se pueden aplicar las anotaciones de tipo de Python en el trabajo, a través de ejemplos concretos. Las anotaciones de tipo van más allá de ser simples documentos; son una herramienta poderosa que mejora la legibilidad y la seguridad del código. En esta sección se muestra cómo usar las anotaciones de tipo en diversos casos, como funciones, clases y argumentos de longitud variable.

Uso de anotaciones de tipo en funciones

1. Especificación de tipos en funciones básicas

Al usar anotaciones de tipo, se pueden describir claramente los parámetros y el valor de retorno de una función. Ejemplo:

def calculate_area(length: float, width: float) -> float:
    return length * width

area = calculate_area(5.0, 3.0)
print(f"Area: {area}")
  • Los argumentoslength ywidth son de tipo punto flotante (float).
  • El valor de retorno también es de tipo punto flotante (float).

2. Especificación de tipos para argumentos con valor por defecto

También se pueden especificar anotaciones de tipo cuando hay argumentos con valor por defecto. Ejemplo:

def greet(name: str = "Guest") -> str:
    return f"Hello, {name}!"

print(greet())  # "Hello, Guest!"
print(greet("Alice"))  # "Hello, Alice!"
  • name es de tipo cadena y tiene como valor por defecto "Guest".

Anotaciones de tipo para argumentos de longitud variable

1. Especificación de tipos para argumentos variables (*args)

Cuando se reciben varios argumentos, se puede usar *args y especificar su tipo. Ejemplo:

from typing import List

def sum_numbers(*numbers: int) -> int:
    return sum(numbers)

print(sum_numbers(1, 2, 3))  # 6
  • *numbers es una tupla de tipo entero (int).

2. Especificación de tipos para argumentos de palabras clave (**kwargs)

También es posible especificar anotaciones de tipo al usar argumentos de palabras clave. Ejemplo:

from typing import Dict

def display_info(**info: str) -> None:
    for key, value in info.items():
        print(f"{key}: {value}")

display_info(name="Alice", age="25", city="New York")
  • **info es un diccionario con claves de tipo cadena y valores también de tipo cadena (Dict[str, str]).

Anotaciones de tipo en el diseño de clases

1. Anotaciones de tipo dentro de la clase

Agregar anotaciones de tipo a los atributos y métodos de una clase clarifica el diseño. Ejemplo:

class Student:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def introduce(self) -> str:
        return f"My name is {self.name}, and I am {self.age} years old."

student = Student("Alice", 20)
print(student.introduce())
  • name yage son, respectivamente, de tipo cadena (str) y entero (int).
  • El método introduce devuelve una cadena (str).

2. Especificar anotaciones de tipo en atributos de clase

También se pueden escribir anotaciones de tipo en atributos a nivel de clase. Ejemplo:

class School:
    name: str = "Default School"
    students: int = 0
  • name es de tipo cadena (str) y students es de tipo entero (int).

Uso práctico de alias de tipo

Los alias de tipo permiten reutilizar tipos complejos de forma concisa.

1. Definición de alias de tipo

from typing import List

Vector = List[float]

def calculate_magnitude(vector: Vector) -> float:
    return sum(x**2 for x in vector) ** 0.5

vector = [1.0, 2.0, 3.0]
print(calculate_magnitude(vector))  # 3.7416573867739413
  • Vector se define como una lista de punto flotante (List[float]).

2. Uso de tipos personalizados

Se pueden usar alias de tipo para estructuras de datos complejas.
Ejemplo:

from typing import Dict, List

StudentScores = Dict[str, List[int]]

scores: StudentScores = {
    "Alice": [90, 85, 88],
    "Bob": [72, 75, 78]
}
  • StudentScores es un diccionario con claves de tipo cadena y valores que son listas de enteros.

Diseño de código seguro usando verificación de tipos

Al combinarse con herramientas de verificación de tipos (como mypy), se puede aumentar la seguridad del código en entornos productivos.

1. Verificación de tipos que incluyen None

Se utiliza Optional para indicar que un argumento puede aceptar None.
Ejemplo:

from typing import Optional

def find_student(name: str) -> Optional[str]:
    students = ["Alice", "Bob", "Charlie"]
    return name if name in students else None
  • El valor de retorno de find_student es una cadena (str) o None.

Resumen

En esta sección se mostraron ejemplos prácticos de uso de anotaciones de tipo en funciones, clases y argumentos de longitud variable. Al usar correctamente las anotaciones de tipo, se mejora la legibilidad y mantenibilidad del código, y se pueden prevenir errores de forma anticipada. En la siguiente sección, «8. Preguntas frecuentes (FAQ)», se abordarán dudas y malentendidos sobre las anotaciones de tipo.

8. Preguntas frecuentes (FAQ)

Los type hints de Python son una herramienta útil, pero al usarlos por primera vez pueden surgir dudas o malentendidos. En esta sección se abordan las preguntas frecuentes sobre los type hints y se proporcionan respuestas claras.

¿Qué problemas surgen al no usar type hints?

Aunque el código Python funciona sin type hints, es más propenso a los siguientes problemas.

  1. Disminución de la legibilidad
    Si los tipos de funciones y variables no están explícitos, otros desarrolladores tardan más en comprender el código.
def add(a, b):
       return a + b

En esta función, los tipos de a y b son desconocidos, por lo que no se sabe si se espera un tipo numérico o una cadena.

  1. Aumento de errores
    Al no estar claros los tipos, pasar un tipo incorrecto no genera un error detectado y aumenta la probabilidad de bugs en tiempo de ejecución.

¿Los type hints mejoran la velocidad de ejecución?

No, los type hints no afectan la velocidad de ejecución.Los type hints son solo “pistas” y no influyen en el comportamiento de Python. La verificación de tipos se realiza con herramientas de análisis estático (p. ej., mypy), no en tiempo de ejecución.

¿Existe una forma de hacer los type hints obligatorios?

Python no tiene un mecanismo para forzar los type hints, pero se pueden aplicar reglas que no permitan código sin type hints mediante los siguientes métodos.

  1. Uso de herramientas de análisis estático
    Al usar la opción --strict de mypy, se pueden detectar como errores las funciones que carecen de type hints.
mypy --strict your_script.py
  1. Reglas de revisión de código y CI/CD
    Configurando reglas en pull requests o pipelines de CI/CD para comprobar la presencia de type hints, se garantiza su uso consistente.

¿Cómo abordar la lentitud del chequeo de tipos con mypy?

En proyectos a gran escala, el chequeo de tipos de mypy puede volverse lento. Se pueden mejorar el rendimiento con los siguientes métodos.

  1. Uso del modo incremental
    Al usar la opción --incremental, solo se revisan las partes modificadas.
mypy --incremental your_script.py
  1. Ignorar algunos módulos
    Se pueden omitir módulos externos que no requieren chequeo de tipos mediante --ignore-missing-imports.
mypy --ignore-missing-imports your_script.py

¿Qué recursos recomiendan para principiantes que quieren aprender type hints?

Utilizando los siguientes recursos, se puede aprender de forma eficiente desde los conceptos básicos hasta aplicaciones avanzadas de los type hints.

  1. Documentación oficial de Python (PEP 484)
    Se explica la especificación básica de los type hints.
    PEP 484 – Type Hints
  2. Tutorial oficial de type hints de Python
    Ejemplos de uso detallados.
    Typing Module
  3. Plataformas de aprendizaje en línea
    Buscar cursos sobre “Python type hints” en Udemy o Coursera permite un aprendizaje estructurado.

¿Cuándo usar y cuándo no usar type hints?

Situaciones en las que se deben usar type hints:

  1. Desarrollo en equipo
    Los type hints facilitan que otros desarrolladores comprendan el código más fácilmente.
  2. Proyectos a gran escala
    A medida que el proyecto crece, los type hints contribuyen a prevenir bugs.
  3. Publicación de APIs externas o bibliotecas
    Con type hints, los usuarios pueden entender más fácilmente cómo usar funciones y clases.

Situaciones en las que no es necesario usar type hints:

  1. Scripts pequeños y de corta duración
    Ej.: análisis de datos sencillo o scripts de automatización.
  2. Código en fase de prototipo
    Durante la creación de prototipos, a veces se omiten los type hints para acelerar el desarrollo.

¿Qué beneficios prácticos aporta el uso de type hints?

El uso de type hints brinda los siguientes beneficios prácticos.

  1. Detección temprana de bugs
    El análisis estático basado en type hints permite prevenir errores antes de la ejecución.
  2. Mejora de la eficiencia de desarrollo
    Las funciones de autocompletado de los IDE se fortalecen, acelerando la escritura de código.
  3. Mejora de la mantenibilidad
    Los tipos claros facilitan la comprensión del código por parte de futuros lectores.

Conclusión

En esta sección se respondieron las preguntas frecuentes sobre los type hints. Los type hints son fáciles de aprender y son una herramienta que mejora significativamente la eficiencia del desarrollador y la calidad del código. Especialmente cuando se combinan con herramientas de análisis estático, su efecto se maximiza.

9. Resumen

En este artículo, se explicó en detalle la especificación de tipos de argumentos utilizando los type hints de Python, desde lo básico hasta lo avanzado, así como el uso de herramientas de verificación de tipos y ejemplos de aplicación en la práctica. Finalmente, se resume el contenido y se presentan los puntos clave para usar los type hints de manera eficaz。

Importancia de los type hints

Los type hints aportan numerosos beneficios mientras mantienen la flexibilidad del tipado dinámico de Python。

  1. Mejora de la legibilidad
    Al declarar la información de tipos en el código, el propósito de funciones y variables se vuelve evidente a simple vista。
  2. Prevención de errores mediante análisis estático
    Detecta incompatibilidades de tipos antes de la ejecución, reduciendo errores potenciales。
  3. Mejora de la eficiencia de desarrollo
    Al aprovechar la función de autocompletado del IDE, la escritura de código se vuelve fluida y se reducen los errores。
  4. Mejora de la mantenibilidad
    Si los tipos son claros, quien lea el código posteriormente lo entenderá más fácilmente。

Pasos para la introducción de los type hints

Se resumen los pasos para introducir los type hints de forma eficaz。

1. Implementar gradualmente

Al añadir type hints a un proyecto existente, es eficaz introducirlos gradualmente siguiendo los pasos a continuación。

  • Agregar type hints a las funciones y clases principales。
  • Utilizar herramientas de análisis estático (p. ej., mypy) para automatizar la verificación de tipos。
  • Compartir las reglas de uso de los type hints dentro del equipo。

2. Evitar especificaciones de tipos excesivamente complejas

Si los tipos se vuelven demasiado complejos, la legibilidad puede disminuir. Utiliza abstracciones y alias de tipos apropiados para mantener la descripción concisa。

3. Aprovechar las herramientas de análisis estático

Introduce herramientas de análisis estático como mypy o PyCharm para gestionar la calidad mediante los type hints。

Puntos clave para el uso de los type hints

Al tener en cuenta los siguientes puntos, podrás aprovechar los type hints de manera más eficaz。

  1. No es necesario agregar type hints a todo
    En scripts pequeños o código en fase de prototipo, se pueden omitir los type hints. Lo importante es mantener el equilibrio。
  2. Aprovechar los recursos oficiales de Python
    Consultando la documentación oficial de Python (PEP 484 y el módulo typing) se pueden aprender las especificaciones más recientes de los type hints。
  3. Seleccionar la herramienta de verificación de tipos adecuada para el entorno de desarrollo
    Según el tamaño del equipo y la naturaleza del proyecto, elige la herramienta adecuada (p. ej., mypy, pylance)。

El futuro de los type hints

Los type hints de Python pueden seguir evolucionando. Se espera que nuevas propuestas de PEP (Python Enhancement Proposal) permitan especificaciones de tipos más flexibles y expresivas. Aprender y comprender su uso temprano permitirá tener una ventaja en futuros proyectos de Python。

Próximos pasos

Después de aprender los fundamentos y aplicaciones de los type hints, pongamos en práctica los siguientes pasos。

  1. Agregar type hints a tu propio proyecto。
  2. Implementar una herramienta de análisis estático y realizar la verificación de tipos。
  3. Consultar la documentación oficial y recursos relacionados con los type hints para profundizar tu conocimiento。

Conclusión

Los type hints de Python son una herramienta muy poderosa para los desarrolladores. Aprovecha lo aprendido en este artículo para mejorar la eficiencia y calidad del código en el trabajo. Al dominar el uso correcto de los type hints, podrás crear código robusto y mantenible, aprovechando la flexibilidad de Python。