Quando uma classe herda de uma classe pai, a classe filha pode ter suas próprias variáveis de instância e métodos, mas às vezes ainda precisa usar partes do código do pai.

É aí que entra a função super().
Ela permite que a classe filha acesse métodos (e indiretamente atributos) da sua classe pai — sem precisar codificar o nome do pai explicitamente.

Um dos usos mais comuns de super() é chamar o construtor do pai (__init__) de dentro da classe filha, para que o pai possa configurar seus próprios atributos antes que a filha adicione novos.

Quando você cria uma classe filha que define seu próprio método init, ela sobrescreve o init do pai. Isso significa que quando você cria um objeto da classe filha, apenas o init da filha será executado — o construtor do pai não será chamado automaticamente. Como resultado, qualquer lógica de configuração, valores padrão ou atributos definidos no init do pai serão completamente ignorados, ficando indefinidos no objeto da filha. Isso pode causar erros inesperados se sua classe pai era responsável por inicializações importantes. Para evitar isso, você deve chamar super().init() dentro do construtor da filha, que executa explicitamente a inicialização do pai antes de adicionar ou sobrescrever qualquer coisa na filha.

Vamos explorar isso agora!

Por que Usar super().__init__()?

Quando você cria uma subclasse, pode querer adicionar dados extras para armazenar.
No entanto, você ainda quer que os atributos do pai sejam inicializados corretamente. Em vez de reescrever o código de inicialização do pai, você simplesmente o chama usando super().__init__().

Exemplo: Adicionando um Novo Atributo em uma Subclasse

Vamos supor que temos uma classe Animal que armazena name e age.
Queremos fazer uma subclasse Dog que também armazena a breed do cachorro (seu tipo), mas ainda queremos usar o construtor de Animal para definir name e age.

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)  # Chama o construtor de Animal
        self.breed = breed           # Adiciona o atributo próprio de Dog

Como Isso Funciona Passo a Passo

1. Quando criamos um objeto Dog, o Python executa o método __init__ da classe Dog.
2. Dentro de Dog.__init__, a linha super().__init__(name, age) chama Animal.__init__.
3. O construtor do pai (Animal.__init__) define self.name e self.age.
4. O controle volta para Dog.__init__, que então define self.breed.

Dessa forma:

• Os atributos do pai são inicializados exatamente como o pai planejou.
• A classe filha pode adicionar seus próprios atributos sem duplicar código.

Usando a Classe

dog = Dog("Rex", 4, "Golden Retriever")

print(dog.name)   # Rex
print(dog.age)    # 4
print(dog.breed)  # Golden Retriever

Por que super() É Melhor do que Chamar o Pai pelo Nome

Você poderia chamar Animal.__init__(self, name, age) diretamente, mas usar super() é mais flexível:

• Ele lida automaticamente com herança múltipla (se sua classe herdar de mais de um pai).
• Facilita a manutenção do código — se você renomear a classe pai, não precisa mudar todas as referências.
• Comunica claramente que você está chamando intencionalmente um método da classe pai.

DICA: Sempre chame `super().__init__()` antes de definir os atributos próprios da filha, para garantir que todos os atributos do pai estejam prontos para uso.

Conclusão

super() é sua ligação com a classe pai. Use-o quando quiser:

• Reutilizar o código de configuração do pai.
• Estender a funcionalidade do pai sem duplicá-la.
• Manter seu código limpo, fácil de manter e preparado para mudanças na hierarquia de classes.

Na próxima lição, exploraremos métodos e variáveis privadas — uma forma de proteger os dados internos da sua classe contra acesso ou modificação externa.