GuíaIntermedio

Guía de OOP y Modelado de Datos en Python

Un diccionario suelto con las llaves correctas puede parecerse a un objeto, pero no protege sus invariantes, no expone comportamiento y se rompe en silencio cuando alguien le mete un valor inválido. Esta guía enseña a diseñar un modelo de objetos limpio, correcto y "pythónico" partiendo de ese problema real. Trabajas modelando un solo dominio de principio a fin —Reservo, un sistema de reservas de salas de coworking— y lo construyes con clases desde cero: primero el paso de datos sueltos a un objeto que junta datos y comportamiento, después encapsulación con propiedades que validan invariantes, `@dataclass` para modelar datos inmutables sin código repetitivo, composición para armar el grafo de objetos del dominio, herencia y polimorfismo para los distintos tipos de socio, protocolos y clases abstractas para diseñar contra interfaces en vez de contra implementaciones concretas, y los métodos dunder que hacen que un objeto se sienta nativo de Python (comparación, orden, iteración, context managers). Todo el código se ejecuta de verdad con Python 3.14 y se verifica contra números de ancla del dominio (una reserva de 3 horas en la sala Focus cuesta 7500 centavos, con 20% de descuento para el tier pro). El proyecto final modela el dominio Reservo completo con las ocho piezas integradas y una demo ejecutable.

64
lecciones
8
módulos
Inglés · Español
disponible en
Incluido en el Club
acceso
Inicia sesión para empezar
NIEVA

Resultados

Lo que vas a poder hacer

  • Pasar de datos sueltos (diccionarios, tuplas) a una clase propia, entendiendo la diferencia entre clase e instancia, `__init__` y `self`
  • Encapsular estado con `@property` para exponer comportamiento sin romper invariantes, validando reglas del dominio (`capacity > 0`, precios no negativos) en el lugar correcto
  • Modelar datos con `@dataclass`, incluyendo objetos de valor inmutables con `frozen=True` y validación con `__post_init__`
  • Elegir con criterio entre composición y herencia ("tiene un" contra "es un") y modelar el grafo de objetos de un dominio real
  • Aplicar herencia y polimorfismo para que distintos tipos de un mismo concepto (por ejemplo, tiers de membresía) calculen comportamiento distinto tras la misma interfaz
  • Diseñar contra interfaces con `typing.Protocol` (tipado estructural, duck typing) y con clases abstractas (`abc.ABC`) cuando se necesita una interfaz nominal
  • Implementar métodos dunder (`__repr__`, `__eq__`, `__hash__`, `__lt__`, `__len__`, `__iter__`, `__contains__`) para que un objeto se comporte como un tipo nativo de Python
  • Construir context managers propios con `__enter__` y `__exit__`
  • Distinguir cuándo usar una clase normal, una dataclass o un protocolo según lo que el dominio necesita expresar
  • Integrar todo el modelo de un dominio real —entidades, colecciones, servicio orquestador— en un sistema ejecutable y verificable

Antes de empezar

Qué necesitas traer

Es para ti si...

  • Desarrolladores Python de nivel intermedio que escriben código con funciones y diccionarios sueltos y quieren pasar a un diseño orientado a objetos real
  • Devs que usan clases mecánicamente pero nunca tuvieron un criterio claro para elegir entre composición y herencia
  • Personas que quieren entender `@dataclass`, `Protocol` y los métodos dunder más allá de copiar ejemplos sueltos de internet
  • Cualquiera preparando entrevistas técnicas donde se pregunta por diseño orientado a objetos, principios SOLID aplicados o cuándo preferir composición sobre herencia
  • Quien va a seguir con las guías hermanas de empaquetado o testing y necesita primero un modelo de dominio bien diseñado sobre el cual trabajar

Requisitos y materiales

  • Sintaxis básica de Python: variables, funciones, control de flujo, estructuras de datos
  • Nociones mínimas de clases (no es necesario haber diseñado un modelo de objetos serio antes)
  • Python 3.14 instalado; todo el código se ejecuta con la librería estándar, sin dependencias externas
  • No es necesario conocer diseño de bases de datos, testing con pytest ni empaquetado: esos temas viven en sus propias guías

Contenido

El temario, módulo por módulo

Abre cualquiera para ver sus lecciones.

  • 1. Introducción: De datos a objetos
  • 2. Por qué OOP — de un dict suelto a un objeto
  • 3. Qué es una clase vs una instancia
  • 4. `__init__` y `self`
  • 5. Atributos de instancia
  • 6. El primer método — comportamiento sobre el estado
  • 7. Varias instancias y su identidad
  • 8. Mini-proyecto: modela una `Room`

  • 1. Presentación del módulo: el objeto que se cuida solo
  • 2. Atributos vs métodos: el objeto como guardián
  • 3. La convención del guion bajo
  • 4. `@property` como getter computado
  • 5. Setters que validan
  • 6. Invariantes en `__init__` con `ValueError`
  • 7. Por qué encapsular: el objeto siempre válido
  • 8. Mini-proyecto: un `Member` que se autovalida

  • 1. Presentación del módulo: deja de escribir boilerplate
  • 2. El boilerplate y qué genera `@dataclass`
  • 3. Declarar campos con tipos
  • 4. Defaults y la trampa del default mutable
  • 5. `frozen=True` y objetos de valor inmutables
  • 6. Validar con `__post_init__`
  • 7. Dataclass vs clase normal
  • 8. Mini-proyecto: `Booking` como objeto de valor

  • 1. Presentación del módulo: el grafo de objetos
  • 2. "Tiene-un" frente a "es-un": la distinción clave
  • 3. Asociación: un `Booking` referencia una `Room` y un `Member`
  • 4. Composición: un `BookingService` tiene un `Calendar`
  • 5. Agregación frente a composición: el ciclo de vida
  • 6. Delegación: reenviar el trabajo al colaborador
  • 7. Preferir composición sobre herencia, y por qué
  • 8. Mini-proyecto: el servicio de reservas y su calendario

  • 1. Introducción a Herencia y Polimorfismo
  • 2. Herencia — Clase Base y Subclase
  • 3. `super()` y Extender el Constructor
  • 4. Sobrescribir Métodos
  • 5. Polimorfismo — Misma Llamada, Comportamiento Distinto
  • 6. Cuándo la Herencia Ayuda y Cuándo Estorba
  • 7. Una Nota sobre Herencia Múltiple y MRO
  • 8. Mini-Proyecto — Tiers de Member con Polimorfismo

  • 1. Introducción a Protocolos y Duck Typing
  • 2. Duck Typing — Los Métodos Importan, No la Clase
  • 3. `typing.Protocol` — La Interfaz Estructural
  • 4. Una Interfaz de Dominio — `Repository` y `Clock`
  • 5. ABC con `@abstractmethod` — La Interfaz Nominal
  • 6. Protocol vs ABC — Estructural vs Nominal
  • 7. Diseñar Contra la Interfaz Desacopla
  • 8. Mini-proyecto: un `Repository` Protocol para bookings

  • 1. Introducción a Métodos Dunder y Objetos Pythonicos
  • 2. `__repr__` vs `__str__`: Dos Formas de Verse
  • 3. Igualdad por Valor: `__eq__` y `__hash__`
  • 4. Orden: `__lt__` y `functools.total_ordering`
  • 5. El Protocolo de Contenedor: `__len__`, `__contains__`, `__getitem__`
  • 6. Hacer el `Calendar` Iterable con `__iter__`
  • 7. Context Managers: `__enter__` y `__exit__`
  • 8. Mini-proyecto: un `Calendar` Pythonico

  • 1. Introducción: modela el dominio Reservo
  • 2. `Room` con invariantes
  • 3. `Member` con tiers polimórficos
  • 4. `Booking` como dataclass frozen
  • 5. `Calendar` con dunders
  • 6. El `BookingService` que compone y orquesta
  • 7. Protocolos en las fronteras
  • 8. Proyecto: modela el dominio Reservo

Dónde encaja

Esta guía es parte de algo más grande

Se estudia dentro de estos programas, con acompañamiento y fechas.

Python Mini-Bootcamp [June 2026]Gratis

Dudas frecuentes

Lo que suele preguntarse

Empieza cuando quieras

Inicia sesión para empezar
Reseñas

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!