Python Academy · Aula

Herança múltipla e MRO

Entenda a herança múltipla e a MRO do Python (linearização C3).

Herança múltipla e MRO é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Introdução

Python oferece suporte à herança múltipla. A Ordem de Resolução de Métodos (MRO) define qual método é chamado quando há conflito entre nomes.

Sintaxe da herança múltipla

class C(A, B): herda de A e B. C recebe todos os 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())

Ordem de resolução de métodos (MRO)

O MRO define a ordem de busca. C.__mro__ mostra a ordem: C, A, B, object. A primeira classe com um método correspondente vence.

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

Linearização C3

Python usa a linearização C3 para calcular o MRO. Ela garante: a filha antes do pai e a ordem da esquerda para a direita para múltiplas classes base.

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

Herança em diamante

D(B,C), em que B e C herdam de A, é o problema do diamante. C3 garante que o __init__ de A seja chamado apenas uma 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()

Componentes de composição

Um componente de composição é uma classe criada para herança múltipla. Ele adiciona métodos sem funcionar sozinho como uma classe completa.

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

Regras de design para componentes de composição

Os componentes de composição devem: não ter __init__, não herdar de classes que não sejam componentes de composição e fazer uma única coisa. Nomeie-os com o sufixo 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() na herança múltipla

super() chama a próxima classe no MRO, que não é necessariamente o pai direto. Cada classe deve chamar super() para um comportamento 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 criação dinâmica de classes

type('NewClass', (Base,), {'method': fn}) cria uma classe dinamicamente. É útil para metaprogramação.

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

Verificando o MRO

ClassName.__mro__ ou inspect.getmro(ClassName) mostra a ordem de resolução como uma tupla de classes.

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

Quando evitar a herança múltipla

Hierarquias complexas de herança múltipla são difíceis de entender. Prefira composição ou componentes de composição simples a hierarquias profundas.

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

Verificação rápida

Qual algoritmo o Python usa para calcular a Ordem de Resolução de Métodos?

Recapitulação

Herança múltipla: class C(A, B). A MRO, por meio da linearização C3, determina a busca de métodos. Use mixins para obter uma herança múltipla organizada. super() segue a MRO.

Continue

Excelente progresso! Continue para dominar o próximo conceito.

Perguntas Frequentes

A aula “Herança múltipla e MRO” é grátis?

Sim — o texto completo de “Herança múltipla e MRO” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Herança múltipla e MRO”?

Entenda a herança múltipla e a MRO do Python (linearização C3). Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Herança múltipla e MRO”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy