Como funcionam herança e super()?

Question

Accepted Answer

**Herança** permite que uma classe derive de outra, reutilizando e estendendo seu comportamento. **`super()`** chama os métodos da classe pai. Python suporta **herança múltipla**, resolvida pelo **MRO** (Method Resolution Order).

## Herança e super() básicos

```python
class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "some sound"

class Dog(Animal):                  # Dog inherits from Animal
    def __init__(self, name, breed):
        super().__init__(name)       # call the parent's __init__ (reuse its logic)
        self.breed = breed
    def speak(self):                 # OVERRIDE the parent method
        return "Woof"

d = Dog("Rex", "Lab")
d.name      # "Rex" (set by Animal via super())
d.speak()   # "Woof" (Dog's override)
```

`super()` permite que uma subclasse invoque o comportamento da classe pai — essencial em `__init__` para executar a configuração da classe pai e estender (não apenas substituir) métodos sobrescritos.

## Estender vs substituir completamente

```python
class Cat(Animal):
    def speak(self):
        base = super().speak()       # call parent, then ADD to it
        return f"{base} ... Meow"
```

## Herança múltipla e o MRO

```python
class A:
    def greet(self): return "A"
class B(A):
    def greet(self): return "B"
class C(A):
    def greet(self): return "C"
class D(B, C):                       # inherits from BOTH B and C
    pass

D().greet()       # "B" — found via the MRO
D.__mro__         # (D, B, C, A, object) — the search order
```

Com herança múltipla, Python procura por métodos em uma ordem linearizada específica — o **MRO**, computado pelo algoritmo C3. `D.__mro__` o mostra; `super()` o segue. O MRO garante que cada classe seja visitada uma vez e as classes pai venham após as filhas, resolvendo o "diamond problem" de forma previsível.

## super() segue o MRO (não apenas o pai literal)

```python
# in cooperative multiple inheritance, super() goes to the NEXT class in the MRO,
# not necessarily the "parent" — enabling mixins to chain correctly
```

## Por que isso importa

Herança e `super()` são ferramentas OOP principais para reutilizar e estender comportamento, usadas em todo os frameworks Python (por exemplo, subclassificação de modelos Django, hierarquias de exceções).

Compreender `super()` (chamando lógica pai, especialmente em `__init__`) e o **MRO** é especialmente importante em Python porque ele suporta **herança múltipla** — o MRO é o que torna a resolução de métodos e as cadeias de `super()` previsíveis em hierarquias complexas e mixins.

Saber como o MRO funciona (e que `super()` o segue) previne confusão em designs em forma de diamante ou baseados em mixin que são comuns em codebases Python reais.