GuíaBásico
Guía de Tipado y Pydantic
Una anotación de tipo en Python es una etiqueta, no un candado: el intérprete la lee, la guarda y sigue ejecutando sin comprobar nada. Esta guía corrige ese malentendido de raíz y construye, sobre él, un sistema completo de tipado estático y validación en runtime con Pydantic v2. Trabajas sobre un solo caso de estudio realista —Cosecha, una plataforma que conecta productores agrícolas con restaurantes, donde todos los datos vienen de afuera (un CSV desordenado por productor, un webhook de pagos, una API de clima, un formulario web) y ninguno es confiable— y lo llevas de cuarenta funciones sin anotar a un sistema donde lo inválido no puede existir. Aprendes a instalar y leer un verificador de tipos (mypy) sin frustrarte con los primeros 300 errores, a describir la forma real de tus datos con el vocabulario completo de `typing`, a convertir esas descripciones en validación de verdad con Pydantic, a expresar reglas de negocio como código en vez de `if` dispersos, y a diseñar fronteras donde el dato se valida una sola vez para que el resto del sistema deje de programar a la defensiva. La guía cierra con los casos difíciles del mundo real —librerías sin tipos, JSON de forma variable, configuración por variables de entorno, migración de Pydantic v1 a v2— y con el criterio explícito para saber cuándo el tipado estorba y cuándo ceder con una razón escrita.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Distinguir con precisión qué revisa un verificador de tipos (el código, antes de ejecutar) de qué revisa Pydantic (el dato real, mientras el programa corre), y por qué ninguno reemplaza al otro
- Instalar y ejecutar un verificador de tipos (mypy), leer sus errores sin frustrarte, elegir el nivel de estrictez y adoptar tipos de forma incremental en un proyecto grande
- Anotar código real con el vocabulario completo de `typing`: colecciones tipadas, uniones, literales y enumeraciones, alias de tipo, genéricos y protocolos
- Escribir tu primer modelo de Pydantic v2, entender la coerción de datos y leer un `ValidationError` completo, con todos los campos que fallaron
- Expresar reglas de negocio como validadores de campo y de modelo, distinguiendo las que van en el modelo de las que dependen de estado externo (base de datos, usuario, configuración)
- Diseñar la arquitectura de fronteras: modelos de entrada, de dominio y de salida, con inmutabilidad y sin programación defensiva río abajo
- Tipar librerías de terceros sin anotaciones propias con archivos `.pyi`, y acotar `Any` cuando el dato realmente no se puede describir
- Usar `TypedDict` para diccionarios con forma conocida y tipar configuración leída de variables de entorno
- Migrar código heredado de Pydantic v1 a v2 reconociendo los cambios de comportamiento, no solo los de nombre de método
- Justificar por escrito, con criterio de ingeniería, qué partes de un sistema conviene dejar sin tipar y por qué
Antes de empezar
Qué necesitas traer
Es para ti si...
- Desarrolladores Python de nivel intermedio que ya escriben funciones y clases propias pero nunca usaron un verificador de tipos en serio
- Devs que conocen Pydantic solo por FastAPI y quieren entenderlo como lo que es: una librería independiente de modelado y validación de datos
- Equipos que reciben datos externos poco confiables (CSVs de terceros, webhooks, formularios) y necesitan una estrategia de validación, no `if` repartidos por el código
- Personas migrando un proyecto de Pydantic v1 a v2 que quieren entender los cambios de comportamiento, no solo hacer un buscar-y-reemplazar
- Cualquiera preparando entrevistas técnicas donde se pregunta por tipado gradual, validación en runtime o diseño de fronteras de datos
Requisitos y materiales
- Saber Python: funciones, clases, diccionarios, listas, comprensiones, y haber escrito algo más grande que un script
- No se requiere experiencia previa con tipado ni con ningún verificador de tipos
- Si vienes de un lenguaje tipado (Java, C#, TypeScript), conviene tener presente que el tipado de Python funciona distinto: es opcional y no se verifica al ejecutar
- No es necesario conocer FastAPI, SQLAlchemy ni empaquetado de paquetes: esos temas viven en sus propias guías
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Presentación del módulo: el malentendido de origen
- 2. Python no verifica tus tipos
- 3. La anotación como documentación ejecutable
- 4. Los tipos básicos y cómo se leen
- 5. Anotar funciones: parámetros y retorno
- 6. `None`, `Optional` y el error del millón
- 7. Tipar código que ya existe, sin romperlo
- 8. Proyecto: anota un módulo sin tipos
- 1. Presentación del módulo: quién revisa los tipos
- 2. Poner a correr un verificador de tipos
- 3. Leer un error de tipos sin frustrarte
- 4. Estricto o permisivo: elegir el nivel
- 5. Adoptar tipos en un proyecto grande, por partes
- 6. `Any`: la puerta de escape y su precio
- 7. Silenciar al verificador (y cuándo se justifica)
- 8. Proyecto: pon el verificador en verde
- 1. Presentación del módulo: cuando los tipos básicos no alcanzan
- 2. Colecciones: listas, diccionarios y tuplas tipadas
- 3. Uniones: cuando algo puede ser dos cosas
- 4. Literales y enumeraciones: valores cerrados
- 5. Alias de tipo y tipos con nombre
- 6. Genéricos en cristiano
- 7. Protocolos: tipar por comportamiento
- 8. Proyecto: modela el dominio con tipos
- 1. Presentación del módulo: la frontera con el mundo exterior
- 2. Por qué las anotaciones no bastan en la frontera
- 3. Tu primer modelo de Pydantic
- 4. Qué hace Pydantic cuando el dato no encaja
- 5. Coerción: la conversión que ayuda y la que engaña
- 6. Campos: valores por defecto, alias y restricciones
- 7. Modelos anidados y listas de modelos
- 8. Proyecto: modela la entrada de un CSV real
- 1. Presentación del módulo: más allá de "es un número"
- 2. Validadores de campo
- 3. Validadores de modelo: reglas entre campos
- 4. Antes o después: el orden de la validación
- 5. Errores útiles para quien mandó el dato
- 6. Serializar: del modelo al mundo otra vez
- 7. Cuándo NO validar con Pydantic
- 8. Proyecto: las reglas de negocio como código
- 1. Presentación del módulo: validar una vez, confiar después
- 2. La frontera: dónde entra el dato sucio
- 3. Modelos de entrada, de dominio y de salida
- 4. Tipos que hacen imposible el estado inválido
- 5. Inmutabilidad y modelos congelados
- 6. Dejar de programar a la defensiva
- 7. El costo de validar y cuándo importa
- 8. Proyecto: pon la validación en la frontera
- 1. Presentación del módulo: donde el tipado se pone incómodo
- 2. Librerías sin tipos y archivos `.pyi`
- 3. Datos dinámicos que no se dejan tipar
- 4. `TypedDict` para diccionarios con forma
- 5. Configuración y variables de entorno tipadas
- 6. Migrar de Pydantic v1 a v2
- 7. Cuándo el tipado estorba
- 8. Proyecto: dómalo sin ensuciar el código
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!