Fundamentos de Python

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.

  • Iniciante
  • 4 min de leitura
  • 1 exemplo executável

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).

De um banco ao código
self._balance🔒 O saldo atrás do balcão: só muda por deposit()
class SavingsAccount(BankAccount):🏦 Uma poupança é uma conta, mais juros
super().__init__(owner, balance)📋 Preencha primeiro o formulário da conta comum
account.month_end()📅 O mesmo fechamento do mês, cada conta faz do seu jeito
Regras comuns na classe base, diferenças na subclasse.
Em uma frase

A 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

  1. BankAccount possui o saldo e valida depósitos.
  2. SavingsAccount reutiliza o contrato base.
  3. SavingsAccount sobrescreve month_end para aplicar juros.
  4. O laço usa todas as contas pela mesma interface.
Dica: Prefira composição quando um objeto apenas usa outro; use herança somente quando o filho puder substituir corretamente o pai.

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

Executar código →
main.py
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})")
Gerar um botão Run para este exemplo

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

Executar código →

reunir estado e comportamento e controlar o acesso.

encapsulation.py
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

Executar código →

expor uma interface útil e ocultar detalhes desnecessários.

abstraction.py
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

Executar código →

especializar uma classe apenas quando existe uma verdadeira relação é-um.

inheritance.py
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

Executar código →

usar a mesma operação com objetos distintos e comportamento adequado.

polymorphism.py
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.

  1. Mude os dados de entrada e tente prever o resultado antes de executar.
  2. Adicione uma verificação para dados vazios ou inválidos.
  3. Coloque a lógica em uma função separada e teste com vários conjuntos de dados.
Executar no compilador Python →

Erros comuns

Esquecer de chamar super().__init__

Sem isso, a preparação da classe pai nunca roda e atributos como owner ficam faltando.

Problema
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        self.interest_rate = rate
Correção
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().

Problema
account._balance = -500
Correção
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