Lección 25 de 47 · Herencia, protocolos y genéricos✦ WebMCP implementado
Herencia, super() y @property
10 min de lectura4 retos
En PHP escribes class B extends A y parent::__construct(). En Python es casi igual, pero con tres sorpresas: super(), que una clase puede tener varios padres, y que los getters y setters casi nunca se escriben a mano porque existe @property. En esta lección heredas, ordenas a los padres (el MRO), creas clases abstractas y proteges un atributo sin romper a nadie.
¿De dónde vienen los nombres?
super = inglés super (de arriba, superior)
Te da acceso a la clase de «más arriba», el padre. Es el parent:: de PHP, pero se escribe como una llamada: super().metodo().
MRO = inglés Method Resolution Order (orden de resolución de métodos)
La lista ordenada de clases donde Python busca un método. Con un solo padre es una fila; con varios padres hace falta una regla, y esa regla se llama así.
ABC = inglés Abstract Base Class (clase base abstracta)
Una clase que no se puede instanciar porque deja métodos sin escribir. Es la abstract class de PHP, y vive en el módulo abc.
@property = inglés property (propiedad)
Un decorador que hace que un método se use como si fuera un atributo: tarea.titulo, sin paréntesis.
mixin = inglés mix in (mezclar dentro)
Una clase pequeña que no se usa sola, sino que se «mezcla» en otras para darles una habilidad. Es lo que en PHP resuelve un trait.
__slots__ = inglés slot (hueco, casilla)
Una lista de los únicos atributos que puede tener un objeto: cada uno tiene su casilla reservada y no caben más.
En 4 ideas
1/4
Una clase hereda con paréntesis: class TareaConFecha(Tarea) es el extends de PHP. Para llamar al padre usas super().__init__(...), que es el parent::__construct(...), y si te lo olvidas, nadie lo hace por ti.
Python permite varios padres (class A(B, C)), y el orden en que se busca cada método se llama MRO. Esos padres sueltos se llaman mixins y hacen el trabajo de los trait de PHP.
abc.ABC + @abstractmethod es el abstract class + abstract function de PHP: no puedes crear un objeto de una clase con métodos sin escribir.
@property convierte un método en un atributo con lógica. Empiezas con un atributo normal y, cuando necesitas validar, lo cambias a property sin tocar a quien lo usa: por eso en Python casi no hay getTitulo()/setTitulo() (en PHP 8.4+ tienes set { } y readonly para algo parecido).
1 · Heredar y llamar al padre con super()
Piensa en una receta de familia. Tu abuela tiene la receta base de la tortilla y tú la heredas: haces lo mismo, pero con un toque tuyo. En Python la clase hija escribe el nombre del padre entre paréntesis y hereda todo lo suyo.
Pythonmain.py
classTarea:
def__init__(self, titulo):
self.titulo = titulo
self.hecha = Falsedefresumen(self):
marca = "x"ifself.hecha else" "returnf"[{marca}] {self.titulo}"classTareaConFecha(Tarea):
def__init__(self, titulo, limite):
# En PHP: parent::__construct($titulo);super().__init__(titulo)
self.limite = limite
defresumen(self):
# En PHP: return parent::resumen() . " (hasta ...)";returnf"{super().resumen()} (hasta {self.limite})"
t = TareaConFecha("Pagar la luz", "2026-12-01")
print(t.resumen())
t.hecha = Trueprint(t.resumen())
print(isinstance(t, Tarea), issubclass(TareaConFecha, Tarea))
Mismo ejemplo en PHP. Fíjate en que la hija reescribe (en inglés, override) resumen() y aun así reutiliza el del padre:
PHP 8.5TareaConFecha.php
<?phpdeclare(strict_types=1);
class Tarea
{
public bool $hecha = false;
publicfunction__construct(public string $titulo) {}
publicfunctionresumen(): string
{
$marca = $this->hecha ? "x" : " ";
return"[{$marca}] {$this->titulo}";
}
}
class TareaConFecha extends Tarea
{
publicfunction__construct(string $titulo, public string $limite)
{
parent::__construct($titulo);
}
publicfunctionresumen(): string
{
returnparent::resumen() . " (hasta {$this->limite})";
}
}
$t = newTareaConFecha("Pagar la luz", "2026-12-01");
echo$t->resumen() . PHP_EOL;
Pythonmain.py
classTarea:
def__init__(self, titulo):
self.titulo = titulo
self.hecha = Falsedefresumen(self):
marca = "x"ifself.hecha else" "returnf"[{marca}] {self.titulo}"classTareaConFecha(Tarea):
def__init__(self, titulo, limite):
super().__init__(titulo)
self.limite = limite
defresumen(self):
returnf"{super().resumen()} (hasta {self.limite})"
t = TareaConFecha("Pagar la luz", "2026-12-01")
print(t.resumen())
¿Por qué? · En PHP no existe
¿Por qué hay que llamar a super().__init__() a mano?
En PHP pasa lo mismo con parent::__construct(): si la hija define su propio constructor y no llama al del padre, el del padre no se ejecuta. Pero PHP te lo deja pasar con una diferencia: las propiedades tipadas sin valor te avisan con un Typed property must not be accessed before initialization.
En Python no hay ni siquiera eso: los atributos nacen cuando alguien escribe self.x = .... Si el __init__ del padre no corre, esos atributos no existen y el fallo aparece más tarde, cuando alguien los lee. Mira lo que pasa:
Pythonmain.py
classTareaMala(Tarea):
def__init__(self, titulo, limite):
# Falta super().__init__(titulo): self.hecha no existeself.titulo = titulo
self.limite = limite
mala = TareaMala("Pagar la luz", "2026-12-01")
# AttributeError: 'TareaMala' object has no attribute 'hecha'
mala.resumen()
2 · Varios padres: el MRO y los mixins
PHP solo deja heredar de una clase (extends admite un solo nombre) y, para compartir código suelto, te da los trait. Python deja heredar de varias clases a la vez. Las clases pequeñas que solo aportan una habilidad se llaman mixins.
Pythonmain.py
classTarea:
def__init__(self, titulo):
self.titulo = titulo
classConLog:
deflog(self, mensaje):
print(f"[{type(self).__name__}] {mensaje}")
classArchivable:
archivada = Falsedefarchivar(self):
self.archivada = TrueclassTareaCompleta(Archivable, ConLog, Tarea):
pass
t = TareaCompleta("Renovar el DNI")
t.log("creada")
t.archivar()
print(t.archivada)
Si dos padres tienen un método con el mismo nombre, ¿cuál gana? Python lo decide con una lista ordenada: el MRO. Se lee de izquierda a derecha y la primera clase que tenga el método gana. Puedes verla con __mro__:
Mira el resultado: super() no significa «mi padre», sino «la siguiente clase del MRO». Por eso Rapida acaba llamando a Segura aunque no sea su padre directo, y las dos se ejecutan una sola vez.
classTarea:
def__init__(self, titulo):
self.titulo = titulo
classConLog:
deflog(self, mensaje):
print(f"[{type(self).__name__}] {mensaje}")
classArchivable:
archivada = Falsedefarchivar(self):
self.archivada = TrueclassTareaCompleta(Archivable, ConLog, Tarea):
pass
t = TareaCompleta("Renovar el DNI")
t.log("creada")
3 · Clases abstractas: ABC y @abstractmethod
Una clase abstracta es un molde incompleto: dice «todos los notificadores deben saber enviar», pero no dice cómo. Quien herede está obligado a escribirlo. En PHP es abstract class con abstract function. En Python se hace con la clase ABC y el decorador @abstractmethod.
¿Por qué hace falta heredar de ABC? En PHP basta con la palabra abstract
En PHP abstract es una palabra del lenguaje. En Python una clase normal puede tener un método que lance NotImplementedError, pero eso solo falla cuando alguien lo llama, a lo mejor semanas después y en producción.
ABC + @abstractmethod mueve el aviso al momento de crear el objeto: el fallo sale el primer día, no el día que ese camino del código se usa. Es el mismo servicio que te hace PHP al negarse a instanciar una clase abstract.
4 · @property: getters y setters sin getters ni setters
En PHP clásico, para validar un título escribías getTitulo() y setTitulo() desde el primer día, por si acaso. En Python se hace al revés: empiezas con un atributo normal (tarea.titulo) y, el día que necesitas validar, lo conviertes en @property. Quien usaba tarea.titulo = "x" no cambia ni una línea.
Pythonmain.py
classTarea:
def__init__(self, titulo):
self.titulo = titulo
@propertydeftitulo(self):
returnself._titulo
@titulo.setterdeftitulo(self, valor):
valor = valor.strip()
ifnot valor:
raiseValueError("el título no puede estar vacío")
self._titulo = valor
t = Tarea(" Comprar pan ")
print(repr(t.titulo))
t.titulo = "Llamar al banco"print(t.titulo)
try:
t.titulo = " "exceptValueErroras error:
print("ValueError:", error)
Mira que __init__ hace self.titulo = titulo y, aun así, pasa por el setter: la validación corre desde el constructor. El valor guardado vive en _titulo (con un guion bajo) porque titulo ya es el nombre de la property.
PHP 8.5Tarea.php
<?phpdeclare(strict_types=1);
class Tarea
{
public string $titulo {
set {
$limpio = trim($value);
if ($limpio === "") {
thrownewInvalidArgumentException("el título no puede estar vacío");
}
$this->titulo = $limpio;
}
}
publicfunction__construct(string $titulo)
{
$this->titulo = $titulo;
}
}
$t = newTarea(" Comprar pan ");
echo$t->titulo . PHP_EOL;
Pythonmain.py
classTarea:
def__init__(self, titulo):
self.titulo = titulo
@propertydeftitulo(self):
returnself._titulo
@titulo.setterdeftitulo(self, valor):
valor = valor.strip()
ifnot valor:
raiseValueError("el título no puede estar vacío")
self._titulo = valor
t = Tarea(" Comprar pan ")
print(t.titulo)
En PHP 8.4+ los property hooks (set { ... }) hacen justo esto. Antes tenías que escribir los métodos. Y si lo que quieres es que nadie cambie el valor, PHP tiene readonly. En Python eso es una property sin setter:
¿Por qué los getters y setters de Python empiezan siendo atributos normales?
En PHP, cambiar $t->titulo por $t->getTitulo() obliga a tocar todo el código que lo usaba, y por eso se escriben los métodos desde el principio «por si acaso». Eso llena las clases de código que no hace nada.
En Python, @property hace que el cambio sea invisible desde fuera: sigue siendo t.titulo. Así que empiezas simple y añades la lógica cuando de verdad la necesitas. Un getter que solo devuelve el atributo es ruido que Python te ahorra.
5 · Privado, final y __slots__
Python no tiene private de verdad. Tiene dos convenciones con guiones bajos que avisan a los demás:
Escribes
Significa
En PHP sería
self.titulo
Público: úsalo con libertad
public
self._titulo
«Uso interno, no lo toques». Nada lo impide
protected / private (solo como aviso)
self.__titulo
Python lo renombra a _Tarea__titulo para que no choque con una clase hija
Parecido a private, pero se puede saltar
Pythonmain.py
classTarea:
def__init__(self, titulo):
self._titulo = titulo
self.__secreto = "nota privada"
t = Tarea("Comprar pan")
print(t._titulo)
print(t._Tarea__secreto)
print([nombre for nombre invars(t)])
El doble guion bajo no es seguridad: es un renombrado para que dos clases de una misma familia no se pisen un atributo. Si alguien quiere leerlo, escribe _Tarea__secreto y lo lee.
Para el resto de final y readonly de PHP, Python tiene dos herramientas pequeñas. @final es un aviso para los comprobadores de tipos, no una prohibición real. __slots__ reserva las casillas exactas de los atributos: ahorra memoria y evita que un fallo de escritura invente un atributo nuevo.
Pythonmain.py
from typing import final
@finalclassEtiqueta:
__slots__ = ("nombre",)
def__init__(self, nombre):
self.nombre = nombre
e = Etiqueta("urgente")
print(e.nombre)
try:
e.color = "rojo"exceptAttributeErroras error:
print("AttributeError:", error)
Equivalencia POO · PHP → Python
La POO de PHP traducida a lo que has visto en esta lección:
PHP
Python
Quién lo ve
class B extends A
class B(A):
Todo el que importe B
parent::__construct($x)
super().__init__(x)
Solo dentro de la clase hija; no se llama solo
parent::metodo()
super().metodo()
Busca en el siguiente del MRO, no solo en el padre
una sola herencia + trait
varios padres: class C(A, B) y mixins
El MRO decide quién gana
abstract class / abstract function
class A(ABC) / @abstractmethod
Falla al instanciar, no al llamar
getX() / setX()
@property y @x.setter
Se usa como un atributo: t.x
readonly / private(set)
@property sin setter
Falla con AttributeError al asignar
private / protected
_x (aviso) y __x (renombrado)
Nadie lo impide: es una convención
final class
@final (typing)
Solo lo vigila mypy o pyright, no Python
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
Una tarea urgente
Haz que Urgente herede de Tarea y reescriba resumen() para devolver URGENTE: seguido del resumen del padre. El programa debe imprimir URGENTE: Pagar la luz. Es el parent::resumen() de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Dentro de Urgente define resumen(self) y usa super().resumen() para pedir el texto del padre.
Reto 2 de 4 · ✓ Resuelto
El constructor de la hija
TareaConFecha.__init__(titulo, limite) debe llamar al constructor del padre (para que existan titulo y hecha) y guardar limite. Es el parent::__construct($titulo) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Antes de guardar limite, escribe super().__init__(titulo).
Reto 3 de 4 · ✓ Resuelto
Un título que se limpia y se valida
Convierte titulo en una @property con setter: quita los espacios de los lados (strip()) y, si queda vacío, lanza ValueError. Tiene que valer también desde el constructor. Es el set { } de PHP 8.4 o un setTitulo() con validación.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Hacen falta dos métodos con el mismo nombre: uno con @property que devuelve self._titulo y otro con @titulo.setter que valida y guarda en self._titulo.
Reto 4 de 4 · ✓ Resuelto
Un exportador abstracto
Convierte Exportador en una clase abstracta (ABC) con el método abstracto exportar(self, titulos), y haz que ExportadorCsv.exportar devuelva los títulos unidos por comas ("pan,leche", y "" si no hay ninguno). Es el abstract class de PHP más un implode(",", $titulos).
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.class Exportador(ABC), decora exportar con @abstractmethod y en ExportadorCsv usa ",".join(titulos).
Resumen
Lo que te llevas de esta lección
class B(A) hereda y super().__init__(...) llama al padre; si la hija escribe su __init__, tiene que llamarlo (en PHP, extends y parent::__construct()).
Puedes heredar de varios padres; el MRO (Clase.__mro__) decide quién gana, y los mixins hacen de trait.
ABC + @abstractmethod: no se puede crear un objeto con métodos sin escribir (en PHP, abstract).
@property y @x.setter dejan validar sin cambiar cómo se usa t.x; sin setter es de solo lectura (en PHP, getters/setters, set { } y readonly).
Nada es privado de verdad: _x y __x son avisos (en PHP, private/protected sí se imponen).
Para recordarlo: «Super, Mezcla, Abstrae, Propiedad»
SSuper super().__init__(), siempre en la hija
MMRO el orden de búsqueda con varios padres
AABC @abstractmethod impide crear el objeto
PProperty @property y su setter
Para heredar bien en Python: Super en el constructor, MRO para el orden, ABC para lo obligatorio y Property para validar. «Si la hija escribe su __init__, el super() también».