Python Academy · Lección

Tipos complejos: List, Dict, Optional y Union

Utilice correctamente los genéricos del módulo typing y Optional/Union.

Tipos complejos: List, Dict, Optional y Union es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

Descripción general del módulo typing

Antes de Python 3.9, los tipos genéricos como List, Dict y Tuple procedían de typing. Desde la versión 3.9, puede usar directamente los tipos integrados.

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

# Python 3.9+: use list[int], dict[str,int] directly
# Python 3.8-: use typing.List[int], typing.Dict[str,int]

List y Sequence

Use list[T] para secuencias mutables y Sequence[T] cuando acepte cualquier secuencia ordenada, como una lista, una tupla o una cadena.

from typing import Sequence

def total(nums: list[int]) -> int:
    return sum(nums)

def first(items: Sequence[str]) -> str:
    return items[0]   # works with list, tuple, str

Dict y Mapping

Use dict[K,V] para diccionarios mutables y Mapping[K,V] para objetos de solo lectura similares a diccionarios.

from typing import Mapping

def lookup(data: Mapping[str, int], key: str) -> int | None:
    return data.get(key)

result = lookup({"a": 1, "b": 2}, "a")
print(result)   # 1

Anotaciones de tuplas

Longitud fija: tuple[int, str, float]. Longitud variable: tuple[int, ...].

def point() -> tuple[float, float]:
    return (1.0, 2.0)

def first_n(n: int) -> tuple[int, ...]:
    return tuple(range(n))

# Named tuple with types:
from typing import NamedTuple
class Point(NamedTuple):
    x: float
    y: float

Optional[T]

Optional[T] es una forma abreviada de T | None. Es siempre la opción adecuada cuando un parámetro puede estar ausente.

from typing import Optional

def find_user(user_id: int) -> Optional[dict[str, str]]:
    db: dict[int, dict[str, str]] = {
        1: {"name": "Alice"}
    }
    return db.get(user_id)

Tipos Union

Union[X, Y] o X | Y (Python 3.10 o posterior) para valores que pueden ser de varios tipos.

from typing import Union

def stringify(value: Union[int, float, str]) -> str:
    return str(value)

# Python 3.10+:
def stringify2(value: int | float | str) -> str:
    return str(value)

Tipos Literal

Literal["a","b","c"] restringe un valor a un conjunto específico de literales.

from typing import Literal

Mode = Literal["read", "write", "append"]

def open_file(path: str, mode: Mode) -> None:
    with open(path, mode):
        pass

open_file("data.txt", "read")    # ok
# open_file("data.txt", "exec")  # mypy error

TypedDict

TypedDict anota la estructura de diccionarios en la que cada clave se asigna a un tipo específico.

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int
    email: str | None

def greet(user: User) -> str:
    return f"Hello, {user['name']}"

alice: User = {"name": "Alice", "age": 30, "email": None}

Set y FrozenSet

Anote los conjuntos con set[T] y los conjuntos inmutables con frozenset[T].

def unique(items: list[int]) -> set[int]:
    return set(items)

def allowed_methods() -> frozenset[str]:
    return frozenset({"GET", "POST", "DELETE"})

Iterable e Iterator

Use Iterable[T] para cualquier objeto que pueda recorrer con un bucle; use Iterator[T] para objetos que tengan __next__.

from typing import Iterable, Iterator

def evens(numbers: Iterable[int]) -> Iterator[int]:
    return (n for n in numbers if n % 2 == 0)

for n in evens([1, 2, 3, 4, 5]):
    print(n)   # 2 4

Any y NoReturn

Any omite la comprobación de tipos para un valor. NoReturn marca las funciones que nunca devuelven un valor, porque siempre generan una excepción o ejecutan un bucle infinito.

from typing import Any, NoReturn

def accept_all(x: Any) -> None:
    print(x)

def crash(msg: str) -> NoReturn:
    raise RuntimeError(msg)   # never returns normally

Comprobación rápida

¿Qué significa Optional[str]?

Repaso

Use list[T], dict[K,V] y tuple[T,...] para las colecciones. Optional[T] = T | None. Use Union[X,Y] o X|Y para varios tipos. Use Literal para valores específicos, TypedDict para estructuras de diccionarios con tipos y Any para omitir la comprobación de tipos.

Preguntas frecuentes

¿La lección «Tipos complejos: List, Dict, Optional y Union» es gratis?

Sí — el texto completo de «Tipos complejos: List, Dict, Optional y Union» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tipos complejos: List, Dict, Optional y Union»?

Utilice correctamente los genéricos del módulo typing y Optional/Union. Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Tipos complejos: List, Dict, Optional y Union»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Anotaciones de tipos básicas
Tipos complejos: List, Dict, Optional y Union
TypeVar, clases genéricas y Protocol
Ejecución de mypy y corrección de errores de tipos

← Volver a Python Academy