Lembra da dinâmica?

Classes que você já conhece
sem saber

Classe é um molde

Uma classe não é o objeto — é a descrição de como o objeto vai ser.

# Classe = molde
class Cachorro:
    pass  # ainda vazio, mas já é uma classe!

# Objetos = instâncias do molde
rex  = Cachorro()
bolt = Cachorro()

O método __init__

__init__ é chamado automaticamente quando você cria um objeto. É onde você define os atributos iniciais.

class Cachorro:
    def __init__(self, nome, raca, idade):
        self.nome  = nome   # atributo de instância
        self.raca  = raca
        self.idade = idade

rex  = Cachorro("Rex",  "Labrador", 3)
bolt = Cachorro("Bolt", "Husky",    1)

print(rex.nome)   # Rex
print(bolt.raca)  # Husky

Por que self?

self é a referência ao próprio objeto. Python passa o objeto automaticamente como primeiro argumento em todo método.

class Cachorro:
    def latir():  # falta self
        print("Au!")

rex = Cachorro()
rex.latir()  # ERRO!

class Cachorro:
    def latir(self):  # correto
        print("Au!")

rex = Cachorro()
rex.latir()  # Au!

Adicionando métodos

Métodos são funções que vivem dentro da classe e operam sobre os dados do objeto.

class Cachorro:
    def __init__(self, nome, idade):
        self.nome  = nome
        self.idade = idade

    def latir(self):
        print(f"{self.nome} diz: Au!")

    def apresentar(self):
        print(f"Meu nome é {self.nome} e tenho {self.idade} anos.")

rex = Cachorro("Rex", 3)
rex.latir()        # Rex diz: Au!
rex.apresentar()   # Meu nome é Rex e tenho 3 anos.

Cada objeto é independente

Alterar um objeto não afeta os outros.

class Pessoa:
    def __init__(self, nome, idade):
        self.nome  = nome
        self.idade = idade

    def aniversario(self):
        self.idade += 1
        print(f"Feliz aniversário, {self.nome}! Agora tem {self.idade} anos.")

ana   = Pessoa("Ana",   22)
pedro = Pessoa("Pedro", 30)

ana.aniversario()   # Feliz aniversário, Ana! Agora tem 23 anos.
print(pedro.idade)  # 30 — Pedro não mudou

A calculadora vira uma classe

A calculadora que você fez na semana passada, agora com memória.

class Calculadora:
    def __init__(self):
        self.historico = []   # atributo: guarda operações

    def somar(self, a, b):
        resultado = a + b
        self.historico.append(f"{a} + {b} = {resultado}")
        return resultado

    def ver_historico(self):
        for item in self.historico:
            print(item)

calc = Calculadora()
print(calc.somar(10, 5))   # 15
print(calc.somar(3, 7))    # 10
calc.ver_historico()

O método __str__

Define o que aparece quando você faz print(objeto).

class Produto:
    def __init__(self, nome, preco):
        self.nome  = nome
        self.preco = preco

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

camiseta = Produto("Camiseta", 49.90)
print(camiseta)   # Produto: Camiseta — R$ 49.90

Atributo de classe × instância

Nem todo atributo precisa ser passado no __init__.

class ContaBancaria:
    banco = "Banco Python"   # atributo de CLASSE — igual para todos

    def __init__(self, titular, saldo):
        self.titular = titular  # atributo de INSTÂNCIA — único
        self.saldo   = saldo

c1 = ContaBancaria("Ana", 1000)
c2 = ContaBancaria("Pedro", 500)

print(c1.banco)    # Banco Python
print(c2.banco)    # Banco Python
print(c1.titular)  # Ana
print(c2.titular)  # Pedro

Erros mais comuns
de iniciantes

• 1
  Esquecer o self no método — todo método de instância precisa de self como primeiro parâmetro, sem exceção
• 2
  Não usar self. para acessar atributos — dentro da classe, sempre self.nome, nunca só nome
• 3
  Lista como atributo de classe — coloque listas no __init__ com self.lista = [], não no corpo da classe
• 4
  Chamar método com parênteses errados — obj.metodo() é correto, obj.metodo sem parênteses não executa o método
• 5
  Confundir classe com objeto — Cachorro é a classe (molde), rex = Cachorro() é o objeto (instância)

Como inspecionar
seus objetos

Quando algo não funciona, essas ferramentas ajudam a entender o que está acontecendo.

class Pessoa:
    def __init__(self, nome, idade):
        self.nome  = nome
        self.idade = idade

p = Pessoa("Ana", 22)

# Ver todos os atributos do objeto
print(vars(p))
# {'nome': 'Ana', 'idade': 22}

# Confirmar o tipo do objeto
print(type(p))
# <class '__main__.Pessoa'>

# Ver se é instância de uma classe
print(isinstance(p, Pessoa))
# True

Estrutura mínima
de uma classe

Guarde esse template — é o ponto de partida para qualquer classe que você criar.

class MinhaClasse:

    atributo_de_classe = "valor"   # compartilhado

    def __init__(self, param1, param2):
        self.param1 = param1   # atributo de instância
        self.param2 = param2

    def meu_metodo(self):
        return f"valor: {self.param1}"

    def __str__(self):
        return f"MinhaClasse({self.param1})"

# uso
obj = MinhaClasse("a", "b")
print(obj)
obj.meu_metodo()

Sistema de cadastro de alunos

Vamos criar uma classe Aluno do zero, juntos.

Criando a classe Aluno

class Aluno:
    def __init__(self, nome, matricula):
        self.nome      = nome
        self.matricula = matricula
        self.notas     = []   # lista vazia

    def __str__(self):
        return f"Aluno: {self.nome} | Matrícula: {self.matricula}"

# Teste
a1 = Aluno("Ana Silva", "2026001")
print(a1)

Adicionando lógica

class Aluno:
    def __init__(self, nome, matricula):
        self.nome      = nome
        self.matricula = matricula
        self.notas     = []

    def adicionar_nota(self, nota):
        self.notas.append(nota)

    def calcular_media(self):
        if len(self.notas) == 0:
            return 0
        return sum(self.notas) / len(self.notas)

    def situacao(self):
        media = self.calcular_media()
        if media >= 7:
            return "Aprovado"
        elif media >= 5:
            return "Recuperação"
        else:
            return "Reprovado"

    def __str__(self):
        return (f"Aluno: {self.nome} | "
                f"Média: {self.calcular_media():.1f} | "
                f"{self.situacao()}")

a1 = Aluno("Ana Silva", "2026001")
a1.adicionar_nota(8.0)
a1.adicionar_nota(7.5)
a1.adicionar_nota(9.0)
print(a1)

Perguntas que
todo mundo tem

• ?
  Por que self aparece na definição mas não na chamada?
  Python passa o objeto automaticamente. rex.latir() vira Cachorro.latir(rex) nos bastidores.
• ?
  Qual a diferença entre Cachorro e Cachorro()?
  Cachorro é a classe em si. Cachorro() chama o construtor e cria um objeto.
• ?
  Posso ter uma classe sem __init__?
  Sim. Python usa um __init__ vazio padrão. Mas na prática, quase toda classe precisa de um.
• ?
  Quando devo criar uma classe e quando uso só funções?
  Se você tem dados que andam juntos e ações que operam sobre esses dados, use classe. Se é uma operação isolada sem estado, use função.

O que vimos hoje

• ✓
  class NomeDaClasse: — como declarar uma classe
• ✓
  __init__(self, ...) — construtor, onde nascem os atributos
• ✓
  self — a referência ao próprio objeto
• ✓
  Métodos de instância — funções que operam sobre self
• ✓
  __str__ — como o objeto se apresenta no print
• ✓
  Atributos de classe vs atributos de instância

20 exercícios
gradativos

Faça o máximo que conseguir e anote suas dúvidas para a próxima aula.

Nível Fácil

Nível Médio

Nível Difícil

Nível Avançado

Aula 03 · 08/04

Métodos e o
parâmetro self

Vamos aprofundar o uso de métodos, entender o self em detalhes e aprender sobre __str__, __repr__ e outras formas de representar um objeto.