Programação orientada a objetos em Python
Nesta lição, você vai conhecer encapsulamento, herança, sobrescrita de métodos e polimorfismo com um exemplo de conta bancária em Python.
O que é programação orientada a objetos em Python?
O problema
Conforme um programa cresce, muitas partes precisam dos mesmos tipos de objeto com pequenas diferenças: uma conta normal e uma poupança, um gato e um cachorro. Copiar classes e mudar algumas linhas gera código duplicado, e verificar o tipo com if em todo lugar transforma cada tipo novo em uma grande mudança.
Pense assim
A programação orientada a objetos funciona como as contas de um mesmo banco. Toda conta guarda o saldo atrás do balcão (encapsulamento). Uma conta poupança é uma conta comum com um recurso a mais (herança). Quando o banco faz o fechamento do mês em todas as contas, cada uma faz isso do seu próprio jeito (polimorfismo).
self._balance🔒 O saldo atrás do balcão: só muda por deposit()class SavingsAccount(BankAccount):🏦 Uma poupança é uma conta, mais jurossuper().__init__(owner, balance)📋 Preencha primeiro o formulário da conta comumaccount.month_end()📅 O mesmo fechamento do mês, cada conta faz do seu jeitoA programação orientada a objetos organiza um programa em classes cujos objetos mantêm os seus dados privados (encapsulamento), reutilizam outras classes (herança) e respondem à mesma chamada do seu próprio jeito (polimorfismo).
A POO modela um sistema como objetos colaboradores. Cada objeto combina estado e operações válidas, tornando responsabilidades mais claras em aplicações grandes.
Os quatro princípios fundamentais
- Encapsulamento: reunir estado e comportamento e controlar o acesso.
- Abstração: expor uma interface útil e ocultar detalhes desnecessários.
- Herança: especializar uma classe apenas quando existe uma verdadeira relação é-um.
- Polimorfismo: usar a mesma operação com objetos distintos e comportamento adequado.
Como o exemplo foi projetado
- BankAccount possui o saldo e valida depósitos.
- SavingsAccount reutiliza o contrato base.
- SavingsAccount sobrescreve month_end para aplicar juros.
- O laço usa todas as contas pela mesma interface.
Quando usar?
- Vários tipos de objeto que compartilham a maior parte do comportamento: tipos de conta, formas, personagens de jogo.
- Código que precisa funcionar com tipos novos no futuro sem ser reescrito.
- Proteger dados que precisam continuar válidos, como um saldo que nunca pode ser negativo.
Quando não é preciso
- Scripts pequenos com poucas funções: classes e herança acrescentam uma estrutura que você não precisa.
- Cadeias longas de herança (A herda de B, que herda de C, que herda de D): são difíceis de acompanhar. Prefira composição.
Exemplo básico
class BankAccount:
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = float(balance)
@property
def balance(self):
return self._balance
def deposit(self, amount):
if amount <= 0:
raise ValueError("Deposit must be positive")
self._balance += amount
def month_end(self):
return "No interest"
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, interest_rate):
super().__init__(owner, balance)
self.interest_rate = interest_rate
def month_end(self):
self._balance *= 1 + self.interest_rate
return "Interest applied"
accounts = [
BankAccount("Ada", 100),
SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)
for account in accounts:
status = account.month_end()
print(f"{account.owner}: {account.balance:.2f} ({status})")
Resultado da execução
Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)
Os quatro princípios de POO na prática
Estes exemplos mostram como Python aplica encapsulamento, abstração, herança e polimorfismo no código cotidiano.
Encapsulamento
reunir estado e comportamento e controlar o acesso.
class BankAccount:
def __init__(self, balance=0):
# Double underscores prevent accidental direct access.
self.__balance = balance
@property
def balance(self):
# Expose read access without exposing mutation.
return self.__balance
def deposit(self, amount):
# Keep validation next to the state it protects.
if amount <= 0:
raise ValueError("Amount must be positive")
self.__balance += amount
account = BankAccount(100)
account.deposit(50)
print(account.balance) # 150
Abstração
expor uma interface útil e ocultar detalhes desnecessários.
from abc import ABC, abstractmethod
class PaymentMethod(ABC):
@abstractmethod
def pay(self, amount):
# Callers know what pay does, not how each provider does it.
pass
class CreditCard(PaymentMethod):
def pay(self, amount):
# The concrete class hides its payment implementation.
return f"Paid ${amount:.2f} by card"
payment = CreditCard()
print(payment.pay(25))
Herança
especializar uma classe apenas quando existe uma verdadeira relação é-um.
class Employee:
def __init__(self, name):
self.name = name
def describe(self):
return self.name
class Developer(Employee):
def __init__(self, name, language):
# Reuse initialization from the parent class.
super().__init__(name)
self.language = language
def describe(self):
# Extend inherited behavior instead of duplicating it.
return f"{super().describe()} writes {self.language}"
print(Developer("Ada", "Python").describe())
Polimorfismo
usar a mesma operação com objetos distintos e comportamento adequado.
class EmailNotification:
def send(self, message):
return f"Email: {message}"
class SmsNotification:
def send(self, message):
return f"SMS: {message}"
def notify(channels, message):
for channel in channels:
# The same call selects behavior from each concrete object.
print(channel.send(message))
channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")
Explicação do código
A classe BankAccount encapsula o saldo no atributo _balance e só permite alterá-lo por métodos com validação, como deposit(). A classe SavingsAccount herda todos esses métodos e sobrescreve month_end() para somar os juros. O laço chama o mesmo método nas duas contas, mas o Python escolhe a versão certa para cada tipo de objeto durante a execução. Isso é polimorfismo.
Altere os valores e execute o programa no compilador Python online CodeUtility sem instalar Python.
Exercícios práticos
Tente modificar o código seguindo as sugestões abaixo. Mudar o código e observar o resultado ajuda você a entender muito mais do que só ler.
- Mude os dados de entrada e tente prever o resultado antes de executar.
- Adicione uma verificação para dados vazios ou inválidos.
- Coloque a lógica em uma função separada e teste com vários conjuntos de dados.
Erros comuns
Esquecer de chamar super().__init__
Sem isso, a preparação da classe pai nunca roda e atributos como owner ficam faltando.
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
self.interest_rate = rate
class SavingsAccount(BankAccount):
def __init__(self, owner, balance, rate):
super().__init__(owner, balance)
self.interest_rate = rate
Mudar dados protegidos direto
Definir _balance de fora pula as verificações de deposit().
account._balance = -500
account.deposit(50)
Terminou esta lição?
Marque como aprendida para acompanhar seu progresso.
Pratique com um desafio
Use o conteúdo desta lição para resolver um problema real. Cada desafio roda no navegador, com testes instantâneos e uma revisão por IA.
Todos os desafios