Python Academy · Lección

Herencia múltiple y MRO

Comprenda la herencia múltiple y el MRO de Python (linealización C3).

Herencia múltiple y MRO es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 3 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

Python admite la herencia múltiple. El orden de resolución de métodos (MRO) determina qué método se llama cuando hay nombres en conflicto.

Sintaxis de la herencia múltiple

class C(A, B): hereda tanto de A como de B. C obtiene todos los métodos de ambas.

class A:
    def hello(self): return 'A'
class B:
    def world(self): return 'B'
class C(A, B): pass
c = C()
print(c.hello(), c.world())

Orden de resolución de métodos (MRO)

El MRO define el orden de búsqueda. C.__mro__ muestra el orden: C, A, B, object. Gana la primera clase que tiene un método coincidente.

class A:
    def greet(self): return 'A'
class B:
    def greet(self): return 'B'
class C(A, B): pass
print(C().greet())  # A wins
print(C.__mro__)

Linealización C3

Python usa la linealización C3 para calcular el MRO. Garantiza que la clase hija aparezca antes que el padre y que las clases base múltiples se recorran de izquierda a derecha.

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
print([c.__name__ for c in D.__mro__])

Herencia en diamante

D(B,C), donde B y C heredan ambas de A, es el problema del diamante. C3 garantiza que el __init__ de A se llame una sola vez.

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

Mixins

Un mixin es una clase diseñada para la herencia múltiple. Añade métodos sin funcionar como una clase completa independiente.

class JSONMixin:
    def to_json(self):
        import json
        return json.dumps(vars(self))
class User(JSONMixin):
    def __init__(self, name, age): self.name,self.age=name,age
print(User('Alice', 30).to_json())

Reglas de diseño de los mixins

Los mixins deben: no tener __init__, no heredar de clases que no sean mixins y hacer una sola cosa. Nómbrelos con el sufijo Mixin.

class LoggingMixin:
    def log(self, msg): print(f'[{self.__class__.__name__}] {msg}')
class Service(LoggingMixin):
    def run(self): self.log('running')
Service().run()

super() en la herencia múltiple

super() llama a la siguiente clase del MRO, que no necesariamente es el padre directo. Cada clase debe llamar a super() para lograr un comportamiento cooperativo.

class Base:
    def action(self): return 'Base'
class A(Base):
    def action(self): return 'A->' + super().action()
class B(Base):
    def action(self): return 'B->' + super().action()
class C(A, B):
    def action(self): return 'C->' + super().action()
print(C().action())

type() para la creación dinámica de clases

type('NewClass', (Base,), {'method': fn}) crea una clase de forma dinámica. Resulta útil para la metaprogramación.

def hello(self): return 'hello'
MyClass = type('MyClass', (object,), {'hello': hello})
print(MyClass().hello())

Comprobación del MRO

ClassName.__mro__ o inspect.getmro(ClassName) muestra el orden de resolución como una tupla de clases.

class A: pass
class B(A): pass
class C(B): pass
import inspect
print([c.__name__ for c in inspect.getmro(C)])

Cuándo evitar la herencia múltiple

Las jerarquías complejas de herencia múltiple son difíciles de razonar. Prefiera la composición o los mixins simples a las jerarquías profundas.

# Prefer:
class User:
    def __init__(self, name, logger):
        self.name = name
        self.logger = logger  # composition
print('composition preferred')

Comprobación rápida

¿Qué algoritmo utiliza Python para calcular el orden de resolución de métodos?

Resumen

Herencia múltiple: class C(A, B). El MRO se obtiene mediante la linealización C3 y determina la búsqueda de métodos. Utilice mixins para una herencia múltiple clara. super() sigue el MRO.

Siga avanzando

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

Preguntas frecuentes

¿La lección «Herencia múltiple y MRO» es gratis?

Sí — el texto completo de «Herencia múltiple y MRO» 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 «Herencia múltiple y MRO»?

Comprenda la herencia múltiple y el MRO de Python (linealización C3). 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 3 de 4.

¿Cuánto tiempo toma la lección «Herencia múltiple y MRO»?

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