À medida que um script cresce, você acaba passando o mesmo grupo de variáveis ​​entre funções e fica difícil dizer quais dados pertencem a qual lógica. Classes e objetos Python resolvem isso agrupando dados e comportamento em uma unidade.

Neste tutorial construímos uma pequena conta bancária passo a passo e adicionamos cada ideia OOP somente quando ela resolve um problema. Executamos todos os exemplos no Python 3.13 e a saída mostrada vem dessa execução. Se você é novo na linguagem, leia nosso tutorial Python para iniciantes primeiro.

O que são classes e objetos?

Uma classe descreve o que algo é e o que pode fazer. Um objeto, também chamado de instância, é aquele específico criado a partir dessa descrição. “Conta” é uma classe, enquanto a conta de Asha e a conta de Ben são dois objetos.

Você tem usado objetos o tempo todo. Em Python, strings, listas e até funções são objetos, e é por isso que você pode escrever "hello".upper().

Sua primeira aula

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ é executado automaticamente sempre que você cria um objeto e define o estado inicial. O depósito em a não afetou b, pois cada objeto possui seus próprios dados. Observe que o método também protege o saldo de um valor ruim. Nosso guia para tratamento de exceções em Python explica raise com mais detalhes.

O que é eu?

self é simplesmente o objeto no qual um método está trabalhando. Quando você escreve a.deposit(50), o Python efetivamente chama Account.deposit(a, 50), passando o objeto como primeiro argumento. É assim que uma definição de método pode servir a todos os objetos.

O nome self é uma convenção forte e não uma palavra-chave, mas sempre use-a. Esquecê-lo na definição de um método é o erro mais comum para iniciantes e produz uma mensagem confusa sobre o número de argumentos.

Atributos de classe versus atributos de instância

Um atributo definido diretamente no corpo da classe é compartilhado por todos os objetos. Um conjunto em self pertence apenas a esse objeto. Este exemplo mostra como as pesquisas se comportam:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Essa última linha surpreende as pessoas. Atribuir por meio de a não alterou o valor compartilhado. Ele criou um novo atributo de instância em a que oculta o da classe. Python examina primeiro o objeto e depois a classe.

Métodos especiais (dunder)

Métodos com sublinhados duplos permitem que seus objetos funcionem com os recursos integrados do Python. Sem eles, a impressão de uma conta mostra um endereço de memória inútil. Adicionar dois fornece um formato legível:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

    def __repr__(self):
        return f"Account({self.owner!r}, {self.balance})"

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Herança

A herança permite que uma nova classe reutilize uma classe existente e altere apenas o que for diferente. Aqui, Savings é um Account com uma configuração extra:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() chama a versão pai, para que a lógica de configuração não seja repetida. deposit foi herdado como estava e __str__ foi substituído para adicionar um rótulo. Use herança apenas para um relacionamento “é um” real. Se uma classe apenas precisa de algo, como um carro precisando de um motor, dê a ela esse objeto como um atributo. Isso é conhecido como composição e geralmente é mais flexível do que cadeias de herança profundas.

Polimorfismo

Polimorfismo significa que objetos diferentes podem responder à mesma chamada de método à sua maneira. O código de chamada não precisa saber o tipo exato:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Essas duas classes nem sequer compartilham um pai. Python só se importa que o objeto tenha um método area, uma abordagem conhecida como duck tipagem. Adicionar um Triangle posteriormente não precisaria de alterações no loop.

Encapsulamento e propriedades

Python não possui atributos verdadeiramente privados e, em vez disso, depende de convenções. Um único sublinhado, como em _price, diz aos outros desenvolvedores “isso é interno, por favor, não toque”. Para verificar os valores quando eles são definidos, use uma propriedade, que parece um atributo simples visto de fora:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Isso significa que você pode começar com um atributo simples e adicionar validação posteriormente sem alterar nenhum código que use a classe. Portanto, não escreva métodos get_price() e set_price() por hábito, como faria em Java. A sintaxe @ aqui é um decorador, que explicamos em Decoradores Python explicados.

Métodos de classe e métodos estáticos

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Classes de dados

Quando uma classe contém principalmente dados, escrever __init__, __repr__ e __eq__ manualmente é entediante. @dataclass os gera a partir de anotações de tipo:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Erros comuns

Usando um atributo de classe mutável

Este é um bug clássico. A lista é definida na classe, então todos os carrinhos a compartilham:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Crie-o em __init__ com self.items = [], para que cada objeto obtenha sua própria lista.

Outros erros comuns

• Esquecendo self. Escreva self.balance, não balance, dentro dos métodos.
• Esquecimento super().__init__(). O filho então perde os atributos configurados pelo pai.
• Construindo classes enormes. Uma classe que faz tudo é difícil de testar. Divida por responsabilidade.
• Herança profunda. Dois níveis geralmente são suficientes e a composição costuma ser mais clara.
• Não escrever testes. Classes com regras são fáceis de testar, como mostra nosso tutorial pytest usando um carrinho pequeno.

Considerações finais

Python orientado a objetos se resume a agrupar dados com o comportamento que os protege. Comece com __init__, métodos e __str__ e, em seguida, adicione herança e propriedades quando encontrar um problema que eles resolvam. Na próxima etapa, pegue um script que passe as mesmas variáveis ​​em todos os lugares e transforme-as em uma pequena classe.

Perguntas frequentes

Continue aprendendo