Quando falamos de programação orientada a objetos, a herança é um dos recursos mais importantes para estruturar e organizar sistemas. Em Python, ela permite criar novas classes a partir de outras já existentes, aproveitando atributos e métodos prontos e ao mesmo tempo oferecendo flexibilidade para acrescentar ou modificar comportamentos. Isso torna o código mais limpo, reutilizável e fácil de manter em projetos de qualquer tamanho.

Neste artigo, vamos explorar desde os conceitos básicos até exemplos práticos de herança em Python.

O que é Herança?

Na POO, herança significa criar uma nova classe (chamada de classe derivada ou subclasse) que herda características de uma classe existente (chamada de classe base ou superclasse).

Classe base (superclasse): fornece atributos e métodos.

Classe derivada (subclasse): herda os atributos e métodos da base, podendo utilizá-los, modificá-los ou adicionar novos.

Exemplo Básico de Herança em Python

# Classe base
class Pessoa:
   def __init__(self, nome, idade):
       self.nome = nome
       self.idade = idade
   
   def apresentar(self):
       return f"Olá, meu nome é {self.nome} e tenho {self.idade} anos."

# Classe derivada
class Estudante(Pessoa):
   def __init__(self, nome, idade, curso):
       # Chamando o construtor da superclasse
       super().__init__(nome, idade)
       self.curso = curso
   
   def apresentar(self):
       return f"Sou {self.nome}, tenho {self.idade} anos e estudo {self.curso}."

# Testando
p1 = Pessoa("Carlos", 40)
print(p1.apresentar())

e1 = Estudante("Ana", 22, "Engenharia")
print(e1.apresentar())
 

Saída:
Olá, meu nome é Carlos e tenho 40 anos.
Sou Ana, tenho 22 anos e estudo Engenharia.

Aqui, a classe Estudante herda de Pessoa, mas sobrescreve o método apresentar().

O papel do super()

O método super() permite chamar métodos e atributos da classe base dentro da subclasse.
No exemplo anterior, usamos super().init(nome, idade) para reaproveitar o construtor da classe Pessoa, evitando repetir código.

Herança Múltipla

Em Python, uma classe pode herdar de mais de uma superclasse. Isso é chamado de herança múltipla.

class Trabalhador:
   def trabalhar(self):
       return "Estou trabalhando."

class Estudioso:
   def estudar(self):
       return "Estou estudando."

# Herança múltipla
class Estagiario(Trabalhador, Estudioso):
   pass

e = Estagiario()
print(e.trabalhar())
print(e.estudar())
 

Saída:
Estou trabalhando.
Estou estudando.

O estagiário herda tanto de Trabalhador quanto de Estudioso.

O MRO (Method Resolution Order)

Quando usamos herança múltipla, o Python segue uma ordem de busca de métodos e atributos chamada MRO (Method Resolution Order).

print(Estagiario.mro())

Isso mostra a ordem em que o Python procura os métodos.

Classes Abstratas

Em alguns casos, queremos apenas definir um contrato para que as subclasses implementem certos métodos. Para isso, usamos classes abstratas com o módulo abc.

from abc import ABC, abstractmethod

class Animal(ABC):
   @abstractmethod
   def emitir_som(self):
       pass

class Cachorro(Animal):
   def emitir_som(self):
       return "Au au!"

class Gato(Animal):
   def emitir_som(self):
       return "Miau!"

# Testando
animais = [Cachorro(), Gato()]

for a in animais:
   print(a.emitir_som())
 

Saída:
Au au!
Miau!

Animal é abstrata e não pode ser instanciada diretamente. Apenas suas subclasses concretas (Cachorro, Gato) implementam o método obrigatório emitir_som().

Vantagens da Herança

• Reutilização de código: evita duplicação.

• Extensibilidade: fácil adicionar novas funcionalidades.

• Organização: código mais limpo e modular.

• Polimorfismo: objetos diferentes podem compartilhar a mesma interface.

Conclusão

A herança é um recurso poderoso da programação orientada a objetos em Python, mas não deve ser usada de forma automática. O grande valor está em escolher quando ela realmente faz sentido: ao estruturar hierarquias de classes, evitar repetição de código e permitir extensibilidade. Porém, em muitos cenários, a composição pode ser uma alternativa mais simples e flexível. O mais importante é entender bem as possibilidades para aplicar a técnica certa no momento certo. Com os exemplos deste artigo, você já tem uma base sólida para explorar herança nos seus próprios projetos e evoluir a qualidade do seu código.