Programação Orientada a Objetos

Classes e Objetos

class Usuario:
    def __init__(self, nome, email):
        self.nome = nome
        self.email = email
        self.logado = False

    def login(self):
        self.logado = True
        return f"{self.nome} logou"

    def logout(self):
        self.logado = False

    def __str__(self):
        return f"<Usuario: {self.nome}>"

# Uso
user = Usuario("João", "[email protected]")
print(user.login())          # João logou
print(user)                  # <Usuario: João>

Herança

class Animal:
    def __init__(self, nome):
        self.nome = nome

    def som(self):
        raise NotImplementedError

class Cachorro(Animal):
    def som(self):
        return "Au au!"

class Gato(Animal):
    def som(self):
        return "Miau!"

# Polimorfismo
animais = [Cachorro("Rex"), Gato("Mimi")]
for animal in animais:
    print(f"{animal.nome} faz {animal.som()}")

Propriedades

class Conta:
    def __init__(self, saldo=0):
        self._saldo = saldo     # privado por convenção

    @property
    def saldo(self):
        """Getter: retorna saldo formatado."""
        return f"R$ {self._saldo:,.2f}"

    @saldo.setter
    def saldo(self, valor):
        if valor < 0:
            raise ValueError("Saldo não pode ser negativo")
        self._saldo = valor

    @saldo.deleter
    def saldo(self):
        raise PermissionError("Não é permitido deletar saldo")

conta = Conta(1000)
print(conta.saldo)      # R$ 1.000,00
conta.saldo = 2000      # usa setter

Métodos de Classe e Estáticos

class Config:
    ambiente = "desenvolvimento"

    @classmethod
    def from_env(cls):
        """Cria instância a partir de variável de ambiente."""
        return cls()

    @staticmethod
    def validar_email(email):
        """Valida formato de email (não precisa de self)."""
        return "@" in email and "." in email

    @classmethod
    def mudar_ambiente(cls, novo):
        cls.ambiente = novo

Dunder Methods

class Ponto:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):           # representação
        return f"Ponto({self.x}, {self.y})"

    def __eq__(self, outro):      # ==
        return self.x == outro.x and self.y == outro.y

    def __add__(self, outro):     # +
        return Ponto(self.x + outro.x, self.y + outro.y)

    def __len__(self):
        return abs(self.x - 0) + abs(self.y - 0)

p1 = Ponto(1, 2)
p2 = Ponto(1, 2)
print(p1 == p2)     # True (sem __eq__, seria False)
print(p1 + p2)      # Ponto(2, 4)

POO em Python é elegante e flexível. Use @property para encapsulamento, @classmethod para factory methods, e slots para otimização de memória.