Este guia abrangente foi elaborado para ajudar desenvolvedores a dominar a Programação Orientada a Objetos (POO) em Python. O conteúdo é dividido em cinco módulos sequenciais, projetados para construir conhecimento de forma progressiva.

Estrutura do Guia

1. Fundamentos Rápidos: Conceitos-chave e sintaxe essencial da POO em Python.
2. Exemplos Práticos: Aplicações do mundo real demonstrando técnicas avançadas.
3. Erros Comuns: Identificação e correção de problemas frequentes.
4. Avaliação: Exercícios práticos com gabarito para autoavaliação.
5. Projetos: Desenvolvimento de aplicações completas do início ao fim.

Recomendações de Estudo

• Para Iniciantes: Siga a sequência sugerida, começando pelos fundamentos.
• Para Desenvolvedores Experientes: Concentre-se nos exemplos práticos e nos erros comuns.
• Aprendizado Focado: Acesse diretamente os tópicos de interesse.
• Prática Ativa: Use os projetos para aplicar o conhecimento teórico.

1. Conceitos Fundamentais de POO

A POO organiza o código em torno de "objetos" que combinam dados e comportamentos. Esta abordagem promove modulação, reutilização e manutenção mais fácil do código.

Classes e Objetos

Uma classe serve como plantilla para criar objetos. Ela define os atributos (dados) e métodos (funções) que os objetos terão.

class AnimalEstimacao:
    def __init__(self, nome_especie, idade):
        self.especie = nome_especie
        self.idade_anos = idade
    
    def emitir_som(self):
        print(f"{self.especie} fez um som!")

# Criando uma instância da classe
meu_animal = AnimalEstimacao("Cachorro", 5)
meu_animal.emitir_som()  # Saída: "Cachorro fez um som!"

Princípios da POO

Encapsulamento: Agrupa dados e métodos relacionados em uma classe, controlando o acesso a eles. Python utiliza convenções de nomenclatura para visibilidade:

class ContaBancaria:
    def __init__(self):
        self._saldo = 0  # Atributo protegido
    
    def depositar(self, valor):
        self._saldo += valor
    
    def consultar_saldo(self):
        return self._saldo

Herança: Permite que uma classe filha herde atributos e métodos de uma classe pai, promovendo reutilização de código.

class Veiculo:
    def __init__(self, marca):
        self.marca = marca
    
    def acelerar(self):
        raise NotImplementedError

class Carro(Veiculo):
    def acelerar(self):
        return f"O {self.marca} está acelerando."

Polimorfismo: Diferentes classes podem implementar o mesmo método de formas distintas.

def teste_veiculo(veiculo):
    print(veiculo.acelerar())

meu_carro = Carro("Toyota")
teste_veiculo(meu_carro)  # Saída: "O Toyota está acelerando."

Abstração: Define interfaces sem expor detalhes de implementação complexos. Python utiliza o módulo abc.

from abc import ABC, abstractmethod

class Forma(ABC):
    @abstractmethod
    def calcular_area(self):
        pass

class Retangulo(Forma):
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
    
    def calcular_area(self):
        return self.largura * self.altura

Métodos Especiais (Dunder Methods)

Permitem personalizar o comportamento de classes, como operadores e representações em string.

class Ponto:
    def __init__(self, coordenada_x, coordenada_y):
        self.x = coordenada_x
        self.y = coordenada_y
    
    def __add__(self, outro_ponto):
        return Ponto(self.x + outro_ponto.x, self.y + outro_ponto.y)
    
    def __str__(self):
        return f"({self.x}, {self.y})"

p1 = Ponto(1, 2)
p2 = Ponto(3, 4)
print(p1 + p2)  # Saída: (4, 6)

2. Exemplos Práticos de POO

Exemplos ilustrando técnicas comuns:

# Demonstração de encapsulamento com propriedades
class Produto:
    def __init__(self, nome, preco_custo):
        self._nome = nome
        self._preco_custo = preco_custo
    
    @property
    def nome(self):
        return self._nome
    
    @property
    def preco_venda(self):
        return self._preco_custo * 1.3  # Margem de 30%

item = Produto("Caderno", 10.0)
print(item.preco_venda)  # Saída: 13.0

# Herança múltipla e Método de Resolução de Ordem (MRO)
class BaseA:
    def processar(self):
        return "A"

class BaseB(BaseA):
    def processar(self):
        return "B"

class BaseC(BaseA):
    def processar(self):
        return "C"

class Combinada(BaseB, BaseC):
    pass

obj = Combinada()
print(obj.processar())  # Saída: "B" (BaseB tem prioridade)

3. Erros Comuns e Soluções

Erro 1: Esquecer do parâmetro self em métodos de instância

# Código incorreto
class Exemplo:
    def metodo(valor):  # Falta o 'self'
        print(valor)

# Correção
class Exemplo:
    def metodo(self, valor):
        print(valor)

Erro 2: Usar objetos mutáveis como valores padrão em parâmetros

# Código incorreto
class ProcessadorDados:
    def __init__(self, itens=[]):  # Lista compartilhada entre instâncias
        self.itens = itens

# Correção
class ProcessadorDados:
    def __init__(self, itens=None):
        self.itens = itens if itens is not None else []

4. Exercícios de Avaliação

1. Qual método é chamado automaticamente ao criar um novo objeto em Python?
   Resposta: __init__
2. Como se declara uma classe que herda de outra classe?
   Resposta: class ClasseFilha(ClassePai):
3. Qual é o objetivo do método __str__?
   Resposta: Define a representação legível do objeto quando usado com print() ou str()

5. Projetos Práticos

Projeto: Sistema de Gestão de Funcionários

class Funcionario:
    def __init__(self, nome, salario_base):
        self.nome = nome
        self.salario_base = salario_base
    
    def calcular_salario(self):
        return self.salario_base

class Gerente(Funcionario):
    def calcular_salario(self):
        return self.salario_base * 1.5

class Tecnico(Funcionario):
    def calcular_salario(self):
        return self.salario_base * 1.2

class SistemaPagamento:
    def processar_folha(self, funcionarios):
        for func in funcionarios:
            print(f"{func.nome}: R${func.calcular_salario():.2f}")

# Uso do sistema
gerente = Gerente("Ana", 8000)
tecnico = Tecnico("Bruno", 5000)

sistema = SistemaPagamento()
sistema.processar_folha([gerente, tecnico])