Python Academy · Aula

Herança simples

Crie classes filhas que herdem atributos e métodos de uma classe pai.

Herança simples é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 1 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

A herança permite que uma classe filha reutilize e amplie o comportamento de uma classe pai sem duplicar código.

Definindo uma classe filha

class Dog(Animal): herda tudo de Animal. A classe filha pode adicionar novos métodos ou substituir os existentes.

class Animal:
    def __init__(self, name): self.name = name
    def speak(self): return '...'
class Dog(Animal):
    def speak(self): return 'Woof'
d = Dog('Rex')
print(d.name, d.speak())

Chamando super().init

super().__init__(args) chama o __init__ do pai. Sempre o chame na classe filha quando o pai tiver lógica de configuração.

class Animal:
    def __init__(self, name): self.name = name
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
d = Dog('Rex', 'Labrador')
print(d.name, d.breed)

Herdando métodos

A classe filha herda todos os métodos do pai. Se você não os substituir, eles funcionarão sem alterações.

class Vehicle:
    def start(self): return 'starting'
class Car(Vehicle):
    pass
print(Car().start())

Substituindo métodos

Defina o mesmo nome de método na classe filha para substituir a versão do pai. A versão da filha será chamada.

class Shape:
    def area(self): return 0
class Square(Shape):
    def __init__(self, s): self.s = s
    def area(self): return self.s**2
print(Square(4).area())

Ampliando o comportamento do pai

Chame super().method() dentro da substituição para executar primeiro a versão do pai e depois adicionar mais comportamentos.

class Animal:
    def describe(self): return 'I am an animal'
class Dog(Animal):
    def describe(self): return super().describe() + ' and a dog'
print(Dog().describe())

isinstance() e issubclass()

isinstance(obj, Parent) retorna True também para instâncias filhas. issubclass(Child, Parent) verifica a hierarquia de classes.

class Animal: pass
class Dog(Animal): pass
d = Dog()
print(isinstance(d, Animal))
print(issubclass(Dog, Animal))

A classe filha adiciona novos métodos

A classe filha pode definir métodos totalmente novos que o pai não possui.

class Animal:
    def __init__(self, name): self.name = name
class Dog(Animal):
    def fetch(self): return f'{self.name} fetches!'
print(Dog('Rex').fetch())

Atributos protegidos

A convenção _name indica que não se deve acessá-lo de fora da classe. As subclasses CAN usá-lo.

class Animal:
    def __init__(self, name): self._name = name
    def name(self): return self._name
class Dog(Animal):
    def bark(self): return f'{self._name} barks'
print(Dog('Rex').bark())

Classes base abstratas

from abc import ABC, abstractmethod força as subclasses a implementarem métodos.

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self): pass
class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self):
        import math
        return math.pi * self.r**2
print(Circle(3).area())

bases e mro

Dog.__bases__ mostra os pais diretos. Dog.__mro__ mostra a ordem completa de resolução de métodos.

class A: pass
class B(A): pass
class C(B): pass
print(C.__mro__)

Verificação rápida

O que super().__init__() faz em uma classe filha?

Recapitulação

Herança: class Child(Parent). super() acessa o pai. Substitua métodos para alterar o comportamento. isinstance() verifica a hierarquia. ABC impõe contratos abstratos.

Continue

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

Perguntas Frequentes

A aula “Herança simples” é grátis?

Sim — o texto completo de “Herança simples” é 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 simples”?

Crie classes filhas que herdem atributos e métodos de uma classe pai. 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 1 de 4.

Quanto tempo leva a aula “Herança simples”?

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