0Pricing
Python Academy · Lección

Anotaciones de tipos básicas

Anote variables, parámetros de funciones y tipos de retorno.

Anotaciones de tipos básicas es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 1 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.

¿Qué son las anotaciones de tipos?

Las anotaciones de tipos son indicaciones que declaran el tipo esperado de las variables, los parámetros y los valores devueltos. No se aplican durante la ejecución; las leen comprobadores de tipos como mypy.

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

result: str = greet("Alice")
print(result)

Anotaciones de variables

Anote las variables de nivel de módulo, de nivel de clase o locales con dos puntos seguidos del tipo.

count: int = 0
pi: float = 3.14159
name: str = "Python"
flag: bool = True

# Annotation without assignment (declaration only)
future_value: int

Anotaciones de parámetros de funciones

Anote cada parámetro en la firma de la función. Use -> type para anotar el tipo devuelto.

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

def repeat(text: str, times: int = 1) -> str:
    return text * times

def no_return() -> None:
    print("side effect only")

Tipos de colecciones integrados (Python 3.9+)

A partir de Python 3.9, use directamente los tipos integrados en minúsculas como genéricos: list[int], dict[str, int] y tuple[int, ...].

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

def config() -> dict[str, str]:
    return {"host": "localhost", "port": "8080"}

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

Optional y Union

X | None (Python 3.10 o posterior) o Optional[X] significa que un valor puede ser X o None. X | Y significa que puede ser X o Y.

from typing import Optional

def find(items: list[int], target: int) -> int | None:
    return next((x for x in items if x == target), None)

# Older style:
# def find(...) -> Optional[int]:

Tipos Union

int | str (Python 3.10 o posterior) o Union[int, str] anota un valor que puede ser de varios tipos.

from typing import Union

def process(value: int | str) -> str:
    return str(value)

# Older style:
# def process(value: Union[int, str]) -> str:

Alias de tipos

Asigne una expresión de tipo a un nombre para crear un alias reutilizable y mejorar la legibilidad.

from typing import TypeAlias

Vector: TypeAlias = list[float]
Matrix: TypeAlias = list[Vector]

def dot(a: Vector, b: Vector) -> float:
    return sum(x * y for x, y in zip(a, b))

Anotaciones Callable

Use Callable[[arg_types], return_type] para anotar las funciones que se pasan como argumentos.

from typing import Callable

def apply(func: Callable[[int, int], int], x: int, y: int) -> int:
    return func(x, y)

result = apply(lambda a, b: a + b, 3, 4)
print(result)  # 7

Anotación de *args y **kwargs

Anote *args con el tipo de sus elementos, no con una tupla, y **kwargs con el tipo de sus valores.

def log(*messages: str, level: str = "INFO") -> None:
    for msg in messages:
        print(f"[{level}] {msg}")

def configure(**options: int) -> None:
    for key, val in options.items():
        print(f"{key}: {val}")

from __future__ import annotations

Añada esta importación al principio del archivo para habilitar la evaluación pospuesta de las anotaciones, lo que permite usar referencias adelantadas sin comillas.

from __future__ import annotations

class Node:
    def __init__(self, value: int, next: Node | None = None):
        self.value = value
        self.next = next   # forward ref to Node works here

Protección TYPE_CHECKING

Importe los tipos solo durante la comprobación de tipos, no durante la ejecución, para evitar importaciones circulares o importaciones pesadas.

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from mymodule import HeavyClass

def process(obj: HeavyClass) -> None:
    ...   # HeavyClass not imported at runtime

Comprobación rápida

¿Qué sintaxis de anotación indica que una función no devuelve ningún valor?

Repaso

Anote las variables con name: Type, los parámetros con param: Type y los valores devueltos con -> Type. Use list[T], dict[K,V] (Python 3.9 o posterior), X | None (Python 3.10 o posterior) y from __future__ import annotations para las referencias adelantadas.

Preguntas frecuentes

¿La lección «Anotaciones de tipos básicas» es gratis?

Sí — el texto completo de «Anotaciones de tipos básicas» 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 «Anotaciones de tipos básicas»?

Anote variables, parámetros de funciones y tipos de retorno. 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 1 de 4.

¿Cuánto tiempo toma la lección «Anotaciones de tipos básicas»?

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

  1. Anotaciones de tipos básicas
  2. Tipos complejos: List, Dict, Optional y Union
  3. TypeVar, clases genéricas y Protocol
  4. Ejecución de mypy y corrección de errores de tipos
← Volver a Python Academy