0Pricing
Python Academy · Aula

__slots__ e otimização de memória

Use __slots__ para reduzir o consumo de memória por instância.

__slots__ e otimização de memória é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

A sobrecarga padrão de __dict__

Por padrão, cada instância do Python armazena atributos em um dicionário __dict__, que gera uma sobrecarga significativa de memória — normalmente, de 200 a 400 bytes por instância.

import sys

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

p = Point(1, 2)
print(sys.getsizeof(p.__dict__))   # ~200 bytes

Declarando __slots__

Defina __slots__ como uma sequência de nomes de atributos. O Python aloca um vetor de tamanho fixo em vez de um dicionário, economizando memória.

class SlottedPoint:
    __slots__ = ("x", "y")

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

p = SlottedPoint(1, 2)
print(p.x, p.y)   # 1 2
# p.z = 3   # AttributeError: no __dict__

Economia de memória

Com __slots__, cada instância normalmente economiza de 30% a 50% de memória em comparação com uma instância baseada em dicionário — uma diferença significativa ao criar milhões de objetos.

import sys

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

class Slotted:
    __slots__ = ("x","y")
    def __init__(self, x, y): self.x, self.y = x, y

print(sys.getsizeof(Reg(1,2)))      # ~56 bytes + ~200 dict
print(sys.getsizeof(Slotted(1,2)))  # ~56 bytes (no dict)

Sem __dict__ por padrão

Uma classe que usa __slots__ não tem __dict__, portanto você não pode adicionar atributos arbitrários depois da criação.

class Config:
    __slots__ = ("host", "port")
    def __init__(self, h, p): self.host, self.port = h, p

c = Config("localhost", 8080)
# c.debug = True   # AttributeError
print(hasattr(c, "__dict__"))   # False

Mantendo __dict__ com __slots__

Inclua "__dict__" em __slots__ para manter um dicionário por instância e, ao mesmo tempo, declarar previamente os atributos comuns como slots.

class Hybrid:
    __slots__ = ("x", "__dict__")

    def __init__(self, x):
        self.x = x

h = Hybrid(1)
h.extra = "dynamic"   # allowed
print(h.extra)

__weakref__ em __slots__

As classes que usam slots perdem o suporte a referências fracas. Adicione "__weakref__" a __slots__ para reativá-lo.

import weakref

class Node:
    __slots__ = ("value", "__weakref__")
    def __init__(self, v): self.value = v

n = Node(42)
ref = weakref.ref(n)
print(ref())  # <Node object>

Herança e __slots__

Se uma classe pai não usar __slots__, a classe filha ainda terá um __dict__. Para obter a economia total, toda a hierarquia deve definir __slots__.

class Base:
    __slots__ = ("x",)

class Child(Base):
    __slots__ = ("y",)   # no __dict__

class WithoutSlots(Base):
    pass   # gets __dict__ from object

Medindo a memória

Use tracemalloc ou pympler para medir o uso real de memória antes e depois de adicionar __slots__.

import tracemalloc

tracemalloc.start()
points = [SlottedPoint(i, i) for i in range(100_000)]
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak: {peak/1024/1024:.1f} MB")

__slots__ e serialização

Objetos que usam slots podem ser serializados com pickle se você definir __getstate__ e __setstate__ ou usar o protocolo padrão de pickle, que lida automaticamente com slots a partir do Python 3.

import pickle

class Point:
    __slots__ = ("x", "y")
    def __init__(self, x, y): self.x, self.y = x, y

p = Point(3, 4)
data = pickle.dumps(p)
p2 = pickle.loads(data)
print(p2.x, p2.y)   # 3 4

Classes de dados com __slots__ — Python 3.10+

Passe slots=True para @dataclass para gerar __slots__ automaticamente.

from dataclasses import dataclass

@dataclass(slots=True)
class Vector:
    x: float
    y: float

v = Vector(1.0, 2.0)
print(v.x, v.y)   # 1.0 2.0
print(hasattr(v, "__dict__"))   # False

Quando usar __slots__

Use __slots__ ao criar milhões de instâncias, quando a memória for limitada ou quando a velocidade de acesso a atributos for essencial. Não o use em classes de propósito geral nas quais a flexibilidade seja mais importante.

# Good candidates:
# - Nodes in a large graph or tree
# - Records in a large dataset
# - High-frequency event objects

# Bad candidates:
# - Configuration objects added to ad-hoc
# - Classes that mix-in dynamic attributes

Verificação rápida

O que acontece quando você tenta definir, em uma instância que usa slots, um atributo que não está listado em __slots__?

Recapitulação

__slots__ substitui o __dict__ por instância por um vetor fixo, economizando de 30% a 50% de memória. Inclua "__dict__" ou "__weakref__" se precisar deles. Toda a cadeia de herança deve usar __slots__ para obter a economia total. No Python 3.10 ou posterior, use @dataclass(slots=True).

Perguntas Frequentes

A aula “__slots__ e otimização de memória” é grátis?

Sim — o texto completo de “__slots__ e otimização de memória” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “__slots__ e otimização de memória”?

Use __slots__ para reduzir o consumo de memória por instância. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “__slots__ e otimização de memória”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Como as classes Python são criadas
  2. Escrita de metaclasses personalizadas
  3. Descritores: __get__, __set__, __delete__
  4. __slots__ e otimização de memória
← Voltar para Python Academy