Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 25 de 47 · Herencia, protocolos y genéricos ✦ WebMCP implementado

Herencia, super() y @property

10 min de lectura 4 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.

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
class Tarea:
    def __init__(self, titulo):
        self.titulo = titulo
        self.hecha = False

    def resumen(self):
        marca = "x" if self.hecha else " "
        return f"[{marca}] {self.titulo}"


class TareaConFecha(Tarea):
    def __init__(self, titulo, limite):
        # En PHP: parent::__construct($titulo);
        super().__init__(titulo)
        self.limite = limite

    def resumen(self):
        # En PHP: return parent::resumen() . " (hasta ...)";
        return f"{super().resumen()} (hasta {self.limite})"


t = TareaConFecha("Pagar la luz", "2026-12-01")
print(t.resumen())
t.hecha = True
print(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
<?php
declare(strict_types=1);

class Tarea
{
    public bool $hecha = false;

    public function __construct(public string $titulo) {}

    public function resumen(): string
    {
        $marca = $this->hecha ? "x" : " ";
        return "[{$marca}] {$this->titulo}";
    }
}

class TareaConFecha extends Tarea
{
    public function __construct(string $titulo, public string $limite)
    {
        parent::__construct($titulo);
    }

    public function resumen(): string
    {
        return parent::resumen() . " (hasta {$this->limite})";
    }
}

$t = new TareaConFecha("Pagar la luz", "2026-12-01");
echo $t->resumen() . PHP_EOL;
Pythonmain.py
class Tarea:
    def __init__(self, titulo):
        self.titulo = titulo
        self.hecha = False

    def resumen(self):
        marca = "x" if self.hecha else " "
        return f"[{marca}] {self.titulo}"


class TareaConFecha(Tarea):
    def __init__(self, titulo, limite):
        super().__init__(titulo)
        self.limite = limite

    def resumen(self):
        return f"{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
class TareaMala(Tarea):
    def __init__(self, titulo, limite):
        # Falta super().__init__(titulo): self.hecha no existe
        self.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
class Tarea:
    def __init__(self, titulo):
        self.titulo = titulo


class ConLog:
    def log(self, mensaje):
        print(f"[{type(self).__name__}] {mensaje}")


class Archivable:
    archivada = False

    def archivar(self):
        self.archivada = True


class TareaCompleta(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__:

Pythonmain.py
class Base:
    def saluda(self):
        return "base"


class Rapida(Base):
    def saluda(self):
        return "rapida > " + super().saluda()


class Segura(Base):
    def saluda(self):
        return "segura > " + super().saluda()


class TareaUrgente(Rapida, Segura):
    pass


print(TareaUrgente().saluda())
print([clase.__name__ for clase in TareaUrgente.__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.

PHP 8.5TareaCompleta.php
<?php
declare(strict_types=1);

trait ConLog
{
    public function log(string $mensaje): void
    {
        echo "[" . static::class . "] $mensaje" . PHP_EOL;
    }
}

trait Archivable
{
    public bool $archivada = false;

    public function archivar(): void
    {
        $this->archivada = true;
    }
}

class Tarea
{
    public function __construct(public string $titulo) {}
}

class TareaCompleta extends Tarea
{
    use Archivable, ConLog;
}

$t = new TareaCompleta("Renovar el DNI");
$t->log("creada");
Pythonmain.py
class Tarea:
    def __init__(self, titulo):
        self.titulo = titulo


class ConLog:
    def log(self, mensaje):
        print(f"[{type(self).__name__}] {mensaje}")


class Archivable:
    archivada = False

    def archivar(self):
        self.archivada = True


class TareaCompleta(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.

Pythonmain.py
from abc import ABC, abstractmethod


class Notificador(ABC):
    @abstractmethod
    def enviar(self, texto):
        ...

    def avisar_dos_veces(self, texto):
        self.enviar(texto)
        self.enviar(texto)


class Consola(Notificador):
    def enviar(self, texto):
        print(f"consola: {texto}")


class Callado(Notificador):
    pass


Consola().avisar_dos_veces("Te quedan 3 tareas")

try:
    Callado()
except TypeError as error:
    print("TypeError:", error)

Cuando una clase tiene métodos abstractos sin escribir, crear el objeto falla al instante, en la línea de Callado(), antes de que nadie llame a nada.

PHP 8.5Notificador.php
<?php
declare(strict_types=1);

abstract class Notificador
{
    abstract public function enviar(string $texto): void;

    public function avisarDosVeces(string $texto): void
    {
        $this->enviar($texto);
        $this->enviar($texto);
    }
}

class Consola extends Notificador
{
    public function enviar(string $texto): void
    {
        echo "consola: $texto" . PHP_EOL;
    }
}

(new Consola())->avisarDosVeces("Te quedan 3 tareas");
Pythonmain.py
from abc import ABC, abstractmethod


class Notificador(ABC):
    @abstractmethod
    def enviar(self, texto):
        ...

    def avisar_dos_veces(self, texto):
        self.enviar(texto)
        self.enviar(texto)


class Consola(Notificador):
    def enviar(self, texto):
        print(f"consola: {texto}")


Consola().avisar_dos_veces("Te quedan 3 tareas")

¿Por qué? · En PHP no existe

¿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
class Tarea:
    def __init__(self, titulo):
        self.titulo = titulo

    @property
    def titulo(self):
        return self._titulo

    @titulo.setter
    def titulo(self, valor):
        valor = valor.strip()
        if not valor:
            raise ValueError("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 = "   "
except ValueError as 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
<?php
declare(strict_types=1);

class Tarea
{
    public string $titulo {
        set {
            $limpio = trim($value);
            if ($limpio === "") {
                throw new InvalidArgumentException("el título no puede estar vacío");
            }
            $this->titulo = $limpio;
        }
    }

    public function __construct(string $titulo)
    {
        $this->titulo = $titulo;
    }
}

$t = new Tarea("  Comprar pan  ");
echo $t->titulo . PHP_EOL;
Pythonmain.py
class Tarea:
    def __init__(self, titulo):
        self.titulo = titulo

    @property
    def titulo(self):
        return self._titulo

    @titulo.setter
    def titulo(self, valor):
        valor = valor.strip()
        if not valor:
            raise ValueError("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:

Pythonmain.py
class Tarea:
    def __init__(self, titulo, hecha=False):
        self.titulo = titulo
        self.hecha = hecha

    @property
    def pendiente(self):
        return not self.hecha


t = Tarea("Comprar pan")
print(t.pendiente)
t.hecha = True
print(t.pendiente)

try:
    t.pendiente = True
except AttributeError as error:
    print("AttributeError:", error)

¿Por qué? · En PHP no existe

¿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:

EscribesSignificaEn PHP sería
self.tituloPúblico: úsalo con libertadpublic
self._titulo«Uso interno, no lo toques». Nada lo impideprotected / private (solo como aviso)
self.__tituloPython lo renombra a _Tarea__titulo para que no choque con una clase hijaParecido a private, pero se puede saltar
Pythonmain.py
class Tarea:
    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 in vars(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


@final
class Etiqueta:
    __slots__ = ("nombre",)

    def __init__(self, nombre):
        self.nombre = nombre


e = Etiqueta("urgente")
print(e.nombre)

try:
    e.color = "rojo"
except AttributeError as error:
    print("AttributeError:", error)

Equivalencia POO · PHP → Python

La POO de PHP traducida a lo que has visto en esta lección:

PHPPythonQuién lo ve
class B extends Aclass 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 + traitvarios padres: class C(A, B) y mixinsEl MRO decide quién gana
abstract class / abstract functionclass A(ABC) / @abstractmethodFalla al instanciar, no al llamar
getX() / setX()@property y @x.setterSe usa como un atributo: t.x
readonly / private(set)@property sin setterFalla 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

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

Resumen

Lo que te llevas de esta lección

  1. 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()).
  2. Puedes heredar de varios padres; el MRO (Clase.__mro__) decide quién gana, y los mixins hacen de trait.
  3. ABC + @abstractmethod: no se puede crear un objeto con métodos sin escribir (en PHP, abstract).
  4. @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).
  5. 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».