Python Academy · Leçon

Héritage multiple et MRO

Comprenez l’héritage multiple et le MRO de Python (linéarisation de C3).

Héritage multiple et MRO est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Introduction

Python prend en charge l’héritage multiple. L’ordre de résolution des méthodes (MRO) détermine quelle méthode est appelée lorsque des noms entrent en conflit.

Syntaxe de l’héritage multiple

class C(A, B): hérite à la fois de A et de B. C obtient toutes les méthodes des deux classes.

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())

Ordre de résolution des méthodes (MRO)

Le MRO définit l’ordre de recherche. C.__mro__ affiche l’ordre : C, A, B, object. La première classe contenant une méthode correspondante est retenue.

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__)

Linéarisation C3

Python utilise la linéarisation C3 pour calculer le MRO. Elle garantit que l’enfant précède le parent et que les classes de base multiples sont parcourues de gauche à droite.

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

Héritage en diamant

D(B,C), où B et C héritent tous deux de A, constitue le problème du diamant. C3 garantit que le __init__ de A n’est appelé qu’une seule fois.

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()

Classes de composition

Une classe de composition est conçue pour l’héritage multiple. Elle ajoute des méthodes sans constituer à elle seule une classe complète.

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())

Règles de conception des classes de composition

Les classes de composition doivent : ne pas avoir de __init__, ne pas hériter de classes qui ne sont pas des classes de composition et ne faire qu’une seule chose. Nommez-les avec le suffixe 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() dans l’héritage multiple

super() appelle la classe suivante dans le MRO, pas nécessairement le parent direct. Chaque classe doit appeler super() pour assurer un comportement coopératif.

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() pour créer des classes dynamiquement

type('NewClass', (Base,), {'method': fn}) crée une classe dynamiquement. Cette technique est utile pour la métaprogrammation.

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

Vérifier le MRO

ClassName.__mro__ ou inspect.getmro(ClassName) affiche l’ordre de résolution sous la forme d’un tuple de classes.

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

Quand éviter l’héritage multiple

Les hiérarchies d’héritage multiple complexes sont difficiles à comprendre. Préférez la composition ou des classes de composition simples aux hiérarchies profondes.

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

Vérification rapide

Quel algorithme Python utilise-t-il pour calculer l’ordre de résolution des méthodes ?

Récapitulatif

Héritage multiple : classe C(A, B). Le MRO, obtenu par linéarisation C3, détermine la recherche des méthodes. Utilisez des mixins pour obtenir un héritage multiple clair. super() suit le MRO.

Continuez

Vos progrès sont excellents ! Continuez pour maîtriser le prochain concept.

Questions Fréquemment Posées

La leçon « Héritage multiple et MRO » est-elle gratuite ?

Oui — le texte complet de « Héritage multiple et MRO » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Héritage multiple et MRO » ?

Comprenez l’héritage multiple et le MRO de Python (linéarisation de C3). Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Héritage multiple et MRO » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy