A herança é um dos pilares fundamentais da Programação Orientada a Objetos (POO). Ela permite que uma classe (subclasse) herde atributos e métodos de outra classe (superclasse), facilitando o reuso de código e a criação de hierarquias lógicas.

1. Definição e Sintaxe

Quando identificamos características comuns entre diferentes classes, podemos extraí-las para uma classe base. A classe que herda é chamada de classe filha ou subclasse, e a classe de onde se herda é a classe pai ou superclasse.

class NomeDaSubclasse(NomeDaSuperclasse):
    pass

2. Vantagens da Herança

A principal motivação para utilizar herança é evitar a duplicidade de código. Ao centralizar comportamentos comuns em uma superclasse, qualquer alteração ou correção reflete automaticamente em todas as subclasses derivadas.

3. Inspeção de Hierarquia

Para verificar quais são as classes pai de uma determinada classe, o Python fornece o atributo especial __bases__, que retorna uma tupla com as classes ascendentes diretas.

print(MinhaClasse.__bases__)

4. Exemplo Prático de Implementação

No exemplo abaixo, definimos uma classe base Colaborador e subclasses específicas que herdam suas propriedades fundamentais.

class Colaborador:
    empresa = 'TechSolutions'

    def __init__(self, nome, salario):
        self.nome = nome
        self.salario = salario

class Desenvolvedor(Colaborador):
    def __init__(self, nome, salario, linguagem):
        # Chamada explícita do construtor da superclasse
        Colaborador.__init__(self, nome, salario)
        self.linguagem = linguagem

    def reportar_progresso(self):
        print(f"O dev {self.nome} está codificando em {self.linguagem}.")

class Gerente(Colaborador):
    def __init__(self, nome, salario):
        Colaborador.__init__(self, nome, salario)
        self.equipe = []

    def adicionar_membro(self, nome_membro):
        self.equipe.append(nome_membro)
        print(f"Equipe atualizada: {self.equipe}")

# Instanciação
dev_junior = Desenvolvedor('Lucas', 5000, 'Python')
dev_junior.reportar_progresso()

5. Ordem de Busca de Atrbiutos (Herança Simples)

Em uma estrutura de herança simples, o interpretador Python busca atributos seguindo esta prioridade:

1. Espaço de nomes do próprio objeto (instância).
2. Espaço de nomes da classe do objeto (subclasse).
3. Espaço de nomes da superclasse.

6. Herança Múltipla e o Algoritmo MRO

Python suporta herança múltipla, onde uma classe pode derivar de vários pais. A resolução de conflitos de atributos é feita através do MRO (Method Resolution Order).

• Python 3: Utiliza a estratégia de busca em largura (C3 Linearization).
• Classes de Novo Estilo: São aquelas que herdam de object (padrão no Python 3).
• Classes Clássicas: Existiam no Python 2 e usavam busca em profundidade (não aplicável ao Python 3).

class Topo:
    def exibir(self):
        print('Executando Topo')

class Esquerda(Topo):
    pass

class Direita(Topo):
    def exibir(self):
        print('Executando Direita')

class Final(Esquerda, Direita):
    pass

instancia = Final()
instancia.exibir() 
# No Python 3, a busca seguirá a ordem definida no MRO

7. O uso de super() e MRO

A função super() é usada para delegar chamadas de métodos para a próxima classe na hierarquia definida pelo MRO, e não necessariamente para o "pai direto" de forma estática.

class Base:
    def acao(self):
        print('Ação na Base')

class Alpha(Base):
    def acao(self):
        print('Início Alpha')
        super().acao()
        print('Fim Alpha')

class Beta:
    def acao(self):
        print('Ação em Beta')

class Composta(Alpha, Beta):
    pass

# Ao executar:
obj = Composta()
obj.acao()

# Fluxo de resolução:
# 1. Busca em Composta -> Não existe acao()
# 2. Busca em Alpha -> Encontra acao(), executa print e chama super()
# 3. super() consulta Composta.mro() para saber quem vem após Alpha
# 4. Se Beta estiver na lista de prioridade, o super().acao() de Alpha pode chamar Beta.acao()

Para visualizar a ordem exata de resolução, utilize Classe.mro() ou o atributo __mro__. Isso é essencial para entender comportamentos em sistemas complexos com herança múltipla.