Programação orientada a objetos em Python: guia com exemplos

Programação orientada a objetos (POO) é o jeito de organizar um programa em torno de objetos, que juntam num só lugar os dados e as funções que mexem nesses dados. É o passo que separa quem escreve scripts curtos de quem consegue tocar um projeto maior sem se perder. Este guia mostra os quatro pilares na prática, com código Python que roda: classe e objeto, encapsulamento, herança e polimorfismo. Para estudar com playground no navegador, exercícios e certificado, use o curso de Python intermediário, gratuito.

De função solta a objeto

Imagine controlar uma conta bancária com variáveis soltas. O saldo fica numa variável, e você escreve funções separadas para depositar e sacar, passando o saldo toda hora. Com uma conta só já dá trabalho; com dez, o código vira um emaranhado de variáveis parecidas. A orientação a objetos resolve isso juntando o dado (o saldo) e o comportamento (depositar, sacar) numa mesma unidade.

class Conta:
    def __init__(self, dono, saldo=0):
        self.dono = dono
        self.saldo = saldo

    def depositar(self, valor):
        self.saldo += valor

    def sacar(self, valor):
        if valor > self.saldo:
            print("Saldo insuficiente")
        else:
            self.saldo -= valor

conta = Conta("Ana", 100)
conta.depositar(50)
conta.sacar(30)
print(conta.saldo)  # 120

A class Conta é o molde. O método __init__ roda quando você cria a conta e guarda os valores iniciais em self.dono e self.saldo. O self é o próprio objeto: é ele que permite a cada conta ter o seu saldo. A partir de um molde você cria quantos objetos quiser, cada um com seus dados.

Os quatro pilares, sem decoreba

A POO costuma ser resumida em quatro ideias. Não decore os nomes: entenda o problema que cada uma resolve.

Encapsulamento: proteger o saldo

Repare que, no exemplo, alguém poderia escrever conta.saldo = -999 e furar a regra. Encapsular é impedir isso, oferecendo métodos que controlam o acesso. Em Python, um nome começado por um sublinhado sinaliza uso interno, e a propriedade permite validar antes de gravar:

class Conta:
    def __init__(self, saldo=0):
        self._saldo = saldo

    @property
    def saldo(self):
        return self._saldo

    def depositar(self, valor):
        if valor <= 0:
            raise ValueError("Valor deve ser positivo")
        self._saldo += valor

Agora o saldo só muda passando pelo depositar, que recusa valor negativo. Quem usa a classe não precisa saber como o saldo é guardado por dentro. Isso é abstração e encapsulamento trabalhando juntos.

Herança: reaproveitar sem copiar

Uma poupança é uma conta que rende. Em vez de reescrever depósito e saque, você herda de Conta e acrescenta o que muda:

class Poupanca(Conta):
    def render(self, taxa):
        self._saldo += self._saldo * taxa

p = Poupanca(1000)
p.depositar(200)
p.render(0.005)
print(p.saldo)  # 1206.0

A Poupanca ganha de graça tudo o que a Conta tem e adiciona o render. Use herança quando a frase é um faz sentido (poupança é uma conta). Quando a relação é tem um, como um carro que tem um motor, prefira composição: o objeto guarda outro objeto por dentro em vez de herdar dele.

Polimorfismo: mesma chamada, respostas diferentes

Polimorfismo é poder chamar o mesmo método em objetos de tipos diferentes e cada um responder do seu jeito. Se várias classes têm um método area(), um único laço percorre todas sem se importar com o tipo:

class Quadrado:
    def __init__(self, lado):
        self.lado = lado
    def area(self):
        return self.lado ** 2

class Circulo:
    def __init__(self, raio):
        self.raio = raio
    def area(self):
        return 3.14159 * self.raio ** 2

for figura in [Quadrado(4), Circulo(3)]:
    print(figura.area())

O laço não pergunta se a figura é quadrado ou círculo. Ele confia que cada uma sabe calcular a própria área. Adicionar um triângulo depois não exige mexer no laço, só criar a classe nova com o método area.

Erros comuns de quem está começando na POO

• Esquecer o self nos métodos ou ao ler um atributo (usar saldo em vez de self.saldo).
• Criar classe para tudo. Um dado simples que não tem comportamento pode continuar sendo uma variável ou um dicionário.
• Abusar de herança. Cadeias longas de classes que herdam de classes ficam difíceis de seguir; muitas vezes composição resolve melhor.
• Deixar todos os dados públicos e mexer neles de fora, o que desfaz o encapsulamento que a classe tentou criar.

Fontes

• Documentação oficial do Python: Classes: referência da sintaxe de classes, herança e escopo.
• Python.org: site oficial da linguagem, com tutorial de introdução.
• MDN Web Docs: referência de conceitos de programação, útil para complementar.

Conclusão

Orientação a objetos é agrupar dados e comportamento em classes e criar objetos a partir delas. Encapsule para proteger os dados, use herança só quando existe relação de é um e deixe o polimorfismo simplificar o código que trata muitos tipos. A melhor forma de fixar é escrever suas próprias classes e testar. Para praticar com playground, exercícios e certificado gratuitos, use o curso de Python intermediário e conheça todos os cursos gratuitos do ValorFinal.