Por que isso importa para POO?

Seus objetos vão armazenar nomes, descrições, CPFs, endereços — tudo como strings. Dominar os métodos de string é essencial para manipular esses atributos e para construir um bom __str__.

Os métodos mais usados

len() e in também funcionam em strings

nome = "Ana Silva"
print(len(nome))        # 9 — quantidade de caracteres
print("Silva" in nome)  # True — verifica se está contida

Strings são imutáveis

Métodos de string não modificam a string original — eles retornam uma nova string. Você precisa guardar o resultado.

nome = "ana"
nome.upper()       # resultado vai pro lixo
print(nome)        # ainda "ana"

nome = nome.upper()  # agora sim — guarda o novo valor
print(nome)          # "ANA"

Dentro de um objeto

class Pessoa:  
    # Salvando o retorno na variável
    def __init__(self, nome):
        self.nome = nome.strip().title()  # limpa e capitaliza na entrada

    def __str__(self):
        return f"Pessoa: {self.nome.upper()}"  # maiúsculas na saída

Por que isso importa para POO?

Nas classes que criamos, os atributos frequentemente são listas — histórico de operações, notas de alunos, itens de carrinho. Dominar os métodos de lista é essencial para trabalhar com esses atributos.

Os métodos mais usados

Diferença crucial: pop() vs remove()

nomes = ["Ana", "Bruno", "Carlos"]

nomes.pop()            # remove e retorna "Carlos" (último)
nomes.pop(0)           # remove e retorna "Ana" (índice 0)
nomes.remove("Bruno")  # remove pelo valor — sem retorno

Índice negativo

notas = [8.0, 7.5, 9.0]
print(notas[-1])   # 9.0 — último item
print(notas[-2])   # 7.5 — penúltimo

Listas como atributos de objeto

class ContaBancaria:
    def __init__(self, titular):
        self.titular   = titular
        self.historico = []           # lista vazia como atributo

    def depositar(self, valor):
        self.saldo += valor
        self.historico.append(f"+ R$ {valor:.2f}")  # append aqui

    def ultima_operacao(self):
        if len(self.historico) == 0:
            return "Nenhuma operação"
        return self.historico[-1]     # índice -1 = último

Quem é o dono da informação?

Antes de falar de métodos, precisamos entender que existem dois lugares onde o Python pode guardar um dado dentro de uma classe.

1. Atributos de Instância (Individuais)

São criados dentro do __init__ usando self. Cada objeto tem sua própria cópia.

• Exemplo: O saldo de uma conta. Se eu gasto o meu, o seu não muda.

2. Atributos de Classe (Compartilhados)

São definidos diretamente na classe, fora de qualquer método. Todos os objetos daquela classe enxergam o mesmo valor.

• Exemplo: A taxa de juros do banco. Se o banco decide mudar a taxa, ela muda para todos os clientes ao mesmo tempo.

class Conta:
    taxa = 0.05        # Atributo de CLASSE (Global)
    
    def __init__(self, titular):
        self.titular = titular  # Atributo de INSTÂNCIA (Individual)

Quando usar cada um?

O nome técnico do que você já sabe

Tudo que você fez nas aulas 01 e 02 — funções dentro de uma classe que recebem self — tem um nome: método de instância.

Um método de instância:

• Sempre recebe self como primeiro parâmetro
• Depende de um objeto específico (uma instância) para ser chamado
• Acessa e modifica os atributos daquele objeto via self

Anatomia completa

class ContaBancaria:
    def __init__(self, titular, saldo):
        self.titular = titular     # atributo de instância
        self.saldo   = saldo       # atributo de instância

    def depositar(self, valor):    # método de instância
        self.saldo += valor        # acessa o atributo via self
        return self.saldo          # return, não print

return vs print — a regra de ouro

Um método chamando outro

Dentro da classe, qualquer método pode chamar outro via self.metodo(). Isso evita repetição de código.

def situacao(self):
    media = self.calcular_media()  # delega para outro método
    return "Aprovado" if media >= 7 else "Reprovado"

Convenção do underscore

Métodos auxiliares/internos são nomeados com _ no início. Tecnicamente funcionam igual, mas sinalizam "isso é detalhe de implementação".

def _registrar(self, operacao):   # auxiliar interno
    self.historico.append(operacao)

O que é um método de classe?

Um método de classe não depende de um objeto específico — ele pertence à classe como um todo. É decorado com @classmethod e recebe cls (a classe) em vez de self (o objeto).

O contraste fundamental

Exemplo prático

class ContaBancaria:
    taxa_juros = 0.05   # atributo de CLASSE

    @classmethod
    def criar_zerada(cls, titular):
        return cls(titular, 0)

    @classmethod
    def alterar_taxa(cls, nova_taxa):
        cls.taxa_juros = nova_taxa

Regra prática

Use @classmethod quando a operação faz sentido sem ter um objeto ainda criado. Os casos mais comuns são construtores alternativos e configurações globais.

O problema da representação padrão

Sem definir como um objeto deve ser exibido, o Python mostra apenas o endereço de memória, o que dificulta o processo de depuração:

p = Produto("Teclado", 149.90)
print(p)  # Saída: <__main__.Produto object at 0x7f3c...>

1. __str__ (Para o Usuário)

O método __str__ define a representação amigável e legível do objeto. É o método chamado automaticamente pelo print(), por f-strings ou pela função str().

def __str__(self):
    return f"Produto: {self.nome} — R$ {self.preco:.2f}"

2. __repr__ (Para o Desenvolvedor)

O método __repr__ define a representação técnica. Ele deve mostrar exatamente como recriar o objeto no código.

def __repr__(self):
    return f"Produto('{self.nome}', {self.preco})"

Diferenças fundamentais

Regras de aplicação

• Ambos os métodos devem obrigatoriamente retornar uma string.
• Se você definir apenas __repr__, o Python o utilizará como padrão para o print().

O que são dunder methods?

Dunder vem de double underscore — dois underscores de cada lado. São também chamados de métodos mágicos. O Python os chama automaticamente em situações específicas — você nunca os chama diretamente pelo nome.

A lógica por trás

Quando você escreve len(lista), o Python internamente chama lista.__len__(). Quando escreve a + b, chama a.__add__(b). Os dunders são o que torna os operadores e funções built-in funcionarem com seus objetos.

Os dunders mais importantes

Exemplo: __len__

class Carrinho:
    def __init__(self):
        self.itens = []

    def adicionar(self, item):
        self.itens.append(item)

    def __len__(self):
        return len(self.itens)   # permite: len(carrinho)

Não precisa decorar tudo agora

O objetivo é entender o padrão: Python usa os dunders nos bastidores, e você pode defini-los para controlar o comportamento dos seus objetos. Ao longo do curso, você vai encontrando e usando cada um no contexto certo.

1. Método de string não salvo

❌ Errado:

self.nome.strip()   # resultado vai pro lixo

✅ Certo:

self.nome = self.nome.strip()   # guarda o resultado

2. __str__ retornando algo que não é string

❌ Errado:

def __str__(self): return self.saldo # float → TypeError

✅ Certo:

def __str__(self): return f"Saldo: R$ {self.saldo:.2f}"

3. print dentro de método de cálculo

❌ Errado:

def area(self): print(3.14 * r**2) # valor desaparece

✅ Certo:

def area(self): return 3.14 * r**2

4. Método chamando outro sem self.

❌ Errado:

media = calcular_media() # NameError

✅ Certo:

media = self.calcular_media()

5. Um underscore em vez de dois

❌ Errado:

def _str_(self): # não é dunder

✅ Certo:

def __str__(self): # dois underscores

1. Strings são imutáveis — como isso afeta meus objetos?

Métodos de string nunca modificam a string original — sempre retornam uma nova. O correto é self.nome = nome.strip().

2. Qual a diferença entre pop() e remove()?

pop() remove por posição e retorna o item. remove(valor) remove por valor e não retorna nada.

3. Qual a diferença entre __str__ e um método exibir()?

__str__ é integrado ao Python: automático em prints e f-strings. exibir() é manual.

4. Quando uso @classmethod?

Use quando a ação faz sentido sem um objeto pronto, como criar um objeto de forma alternativa.

5. __str__ pode chamar outros métodos?

Sim! É comum usar self.calcular_media() dentro dele para compor a string de retorno.

6. Posso usar .split() no input do usuário?

Sim. Excelente para transformar uma entrada única de usuário em uma lista de dados.