Python Academy · Lección

Sobrescritura de métodos y super()

Sobrescriba métodos de la clase padre y llámelos con super().

Sobrescritura de métodos y super() es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 2 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.

Introducción

La sobrescritura de métodos permite que las clases hijas personalicen el comportamiento heredado. super() permite llamar a la implementación original.

Conceptos básicos de la sobrescritura

Defina en la clase hija un método con el mismo nombre para reemplazar la versión del padre en todas las instancias de la hija.

class Greeter:
    def greet(self): return 'Hello'
class FormalGreeter(Greeter):
    def greet(self): return 'Good day'
print(FormalGreeter().greet())

super() en sobrescrituras

super().greet() dentro de la clase hija llama a la versión del padre. Resulta útil para ampliar el comportamiento, no para reemplazarlo por completo.

class Logger:
    def log(self, msg): print(f'[LOG] {msg}')
class TimedLogger(Logger):
    def log(self, msg):
        import time
        super().log(f'{time.time():.0f}: {msg}')
TimedLogger().log('test')

super() en init

Llame siempre a super().__init__() en el __init__ de una clase hija para asegurarse de que se ejecute la inicialización del padre.

class Animal:
    def __init__(self, name): self.name = name
class Cat(Animal):
    def __init__(self, name, indoor):
        super().__init__(name)
        self.indoor = indoor
cat = Cat('Whiskers', True)
print(cat.name, cat.indoor)

super() con argumentos

super(ChildClass, self) es la forma explícita (al estilo de Python 2). Python 3 permite usar super() sin argumentos en la mayoría de los casos.

class A:
    def greet(self): return 'A'
class B(A):
    def greet(self): return super().greet() + 'B'
class C(B):
    def greet(self): return super().greet() + 'C'
print(C().greet())

Herencia cooperativa

En la herencia múltiple, super() sigue el MRO. Cada clase que llama a super() garantiza que se inicialicen todas las clases de la cadena.

class A:
    def __init__(self): print('A init')
class B(A):
    def __init__(self): super().__init__(); print('B init')
class C(A):
    def __init__(self): super().__init__(); print('C init')
class D(B, C):
    def __init__(self): super().__init__(); print('D init')
D()

Sobrescritura de str

Sobrescriba __str__ en la clase hija para personalizar cómo se imprimen las instancias.

class Animal:
    def __init__(self, name): self.name = name
    def __str__(self): return f'Animal: {self.name}'
class Dog(Animal):
    def __str__(self): return f'Dog: {self.name}'
print(Dog('Rex'))

Patrón de método plantilla

El padre define la estructura del algoritmo; la clase hija completa los pasos sobrescribiendo métodos específicos.

class DataProcessor:
    def process(self):
        data = self.load()
        return self.transform(data)
    def load(self): return [1,2,3]
    def transform(self, d): return d
class Doubler(DataProcessor):
    def transform(self, d): return [x*2 for x in d]
print(Doubler().process())

Llamada al método de una clase hermana

Con super() y un MRO adecuado, puede llamar al método de una clase hermana en la herencia múltiple; esto se denomina super() cooperativo.

class A:
    def hello(self): print('A')
class B(A):
    def hello(self): super().hello(); print('B')
class C(A):
    def hello(self): super().hello(); print('C')
class D(B,C):
    def hello(self): super().hello(); print('D')
D().hello()

__init_subclass__

__init_subclass__ se llama cada vez que se crea una subclase de la clase. Resulta útil para patrones de registro de plugins.

class Plugin:
    registry = []
    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin.registry.append(cls)
class A(Plugin): pass
class B(Plugin): pass
print([c.__name__ for c in Plugin.registry])

Cuándo NO sobrescribir

No sobrescriba un método si no necesita cambiar su comportamiento. Las sobrescrituras innecesarias aumentan la carga de mantenimiento. Prefiera la composición para comportamientos no relacionados.

# Good: only override what's needed
class Dog(Animal):
    def speak(self): return 'Woof'
    # No need to override __init__ if parent's is fine
print('override guidance')

Comprobación rápida

En Python 3, ¿a qué hace referencia super() (sin argumentos) dentro de un método?

Repaso

Sobrescriba redefiniendo el método en la clase hija. super().method() llama a la versión del padre. super().__init__() inicializa el padre. El super() cooperativo sigue el orden del MRO.

Continúe

¡Excelente progreso! Continúe para dominar el siguiente concepto.

Preguntas frecuentes

¿La lección «Sobrescritura de métodos y super()» es gratis?

Sí — el texto completo de «Sobrescritura de métodos y super()» 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 «Sobrescritura de métodos y super()»?

Sobrescriba métodos de la clase padre y llámelos con super(). 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 2 de 4.

¿Cuánto tiempo toma la lección «Sobrescritura de métodos y super()»?

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

← Volver a Python Academy