0Pricing
Python Academy · Pelajaran

__slots__ dan Optimasi Memori

Gunakan __slots__ untuk mengurangi penggunaan memori setiap instance.

__slots__ dan Optimasi Memori adalah pelajaran Python Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Python Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Python Academy mencakup 4 pelajaran total.

Overhead Bawaan __dict__

Secara bawaan, setiap instans Python menyimpan atribut dalam kamus __dict__, yang memiliki overhead memori cukup besar—biasanya 200–400 byte per instans.

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

Mendeklarasikan __slots__

Definisikan __slots__ sebagai urutan nama atribut. Python akan mengalokasikan larik berukuran tetap sebagai pengganti kamus sehingga menghemat memori.

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__

Penghematan Memori

Dengan __slots__, setiap instans biasanya menghemat 30–50% memori dibandingkan instans berbasis kamus—penghematan yang signifikan saat membuat jutaan objek.

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)

Tidak Ada __dict__ secara Bawaan

Kelas dengan __slots__ tidak memiliki __dict__, sehingga Anda tidak dapat menambahkan atribut sembarang setelah pembuatannya.

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

Mempertahankan __dict__ dengan __slots__

Sertakan "__dict__" dalam __slots__ untuk mempertahankan kamus per instans, sekaligus mendeklarasikan atribut umum terlebih dahulu sebagai slot.

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

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

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

__weakref__ dalam __slots__

Kelas dengan __slots__ kehilangan dukungan referensi lemah. Tambahkan "__weakref__" ke __slots__ untuk mengaktifkannya kembali.

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>

Pewarisan dan __slots__

Jika kelas induk tidak menggunakan __slots__, kelas turunan tetap mendapatkan __dict__. Untuk penghematan penuh, seluruh hierarki harus mendefinisikan __slots__.

class Base:
    __slots__ = ("x",)

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

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

Mengukur Memori

Gunakan tracemalloc atau pympler untuk mengukur penggunaan memori yang sebenarnya sebelum dan sesudah menambahkan __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__ dan Pickle

Objek dengan __slots__ dapat diserialisasikan dengan pickle jika Anda mendefinisikan __getstate__ dan __setstate__, atau menggunakan protokol pickle bawaan yang menangani slot secara otomatis mulai 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

dataclass dengan __slots__ — Python 3.10+

Berikan slots=True kepada @dataclass untuk membuat __slots__ secara otomatis.

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

Kapan Menggunakan __slots__

Gunakan __slots__ saat Anda membuat jutaan instans, memori terbatas, atau kecepatan akses atribut sangat penting. Jangan menggunakannya untuk kelas serbaguna jika fleksibilitas lebih diutamakan.

# 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

Pemeriksaan Singkat

Apa yang terjadi saat Anda mencoba menetapkan atribut yang tidak tercantum dalam __slots__ pada instans dengan slot?

Ringkasan

__slots__ menggantikan __dict__ per instans dengan larik berukuran tetap sehingga menghemat 30–50% memori. Sertakan "__dict__" atau "__weakref__" jika Anda membutuhkannya. Seluruh rantai pewarisan harus menggunakan __slots__ agar penghematan penuh tercapai. Dalam Python 3.10+, gunakan @dataclass(slots=True).

Pertanyaan yang Sering Diajukan

Apakah pelajaran “__slots__ dan Optimasi Memori” gratis?

Ya — teks lengkap “__slots__ dan Optimasi Memori” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Python Academy, upgrade ke CoddyKit PRO. Kursus Python Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “__slots__ dan Optimasi Memori”?

Gunakan __slots__ untuk mengurangi penggunaan memori setiap instance. Kamu berlatih Python Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Python Academy?

Tidak diperlukan pengalaman sebelumnya. Python Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “__slots__ dan Optimasi Memori” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Python Academy ini?

Ya. Setiap pelajaran Python Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Cara Class Python Dibuat
  2. Menulis Metaclass Kustom
  3. Descriptor: __get__, __set__, __delete__
  4. __slots__ dan Optimasi Memori
← Kembali ke Python Academy