Class di Python: __init__, self, method, inheritance, dan dataclass

Class membungkus data dan apa yang kamu lakukan dengannya

Class memungkinkan kamu mendefinisikan sebuah jenis benda, misalnya pengguna, rekening bank, konfigurasi, atau request, beserta semua hal yang bisa dilakukan benda itu. Benda itu adalah instance dari class. Tindakannya disebut method.

Ini class paling sederhana yang bisa dibuat:

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def greet(self):
        print(f"Hi, I'm {self.name}. Reach me at {self.email}.")

user = User("Rosa", "rosa@example.com")
user.greet()

print(user.name)
print(user.email)

Penjelasannya:

• class User: memulai definisi class. Menurut konvensi, nama class memakai PascalCase.
• __init__ adalah initializer. Method ini berjalan otomatis saat kamu membuat instance baru, dan menyiapkan atribut instance itu dengan self.whatever = ....
• greet adalah sebuah method. self adalah cara method merujuk ke instance tempat method itu dipanggil.
• User("Rosa", "rosa@example.com") membuat sebuah instance. Python memanggil __init__ dengan self diisi instance baru itu dan argumen lainnya diteruskan.
• user.greet() memanggil method-nya. Python otomatis mengirim user sebagai self.

self hanyalah argumen pertama

self bukan kata kunci. Itu nama yang dipakai untuk parameter pertama method instance, yaitu instance tempat method sedang berjalan. Kamu bisa menamainya apa saja; semua orang memakai self karena memang itulah kebiasaannya.

Setiap method instance menerima self sebagai parameter pertamanya. Dengan cara itulah sebuah method tahu instance mana yang harus dibaca atau diubah.

Menambahkan perilaku

Method bisa membaca dan mengubah state:

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

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount

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

a = BankAccount("Rosa", 100)
a.deposit(50)
a.withdraw(30)
print(a)

__repr__ adalah method khusus lain, semacam hook untuk "bagaimana objek ini ditampilkan saat di-print?". Menulis versi yang bagus akan sangat membantu saat debugging.

Atribut class vs atribut instance

Atribut yang didefinisikan di badan class (di luar __init__) dipakai bersama oleh semua instance. Atribut yang di-assign ke self berlaku per instance:

class Dog:
    species = "Canis familiaris"   # class attribute, shared

    def __init__(self, name):
        self.name = name           # instance attribute, per-dog

a = Dog("Rex")
b = Dog("Luna")

print(a.species, a.name)
print(b.species, b.name)

Dog.species = "Canis lupus familiaris"  # changes for every instance
print(a.species, b.species)

Pakai atribut class untuk nilai yang memang dipakai bersama, seperti konstanta, penghitung, atau konfigurasi. Taruh data yang khusus untuk tiap instance di __init__.

Inheritance

Sebuah class bisa mewarisi class lain, mendapatkan method dan atributnya secara gratis, lalu menambah atau menimpa (override) yang perlu:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks.")

class Cat(Animal):
    def speak(self):
        print(f"{self.name} meows.")

rex = Dog("Rex")
luna = Cat("Luna")
rex.speak()
luna.speak()

super() memberimu akses ke class induk. Biasanya dipakai di dalam __init__ untuk menginisialisasi atribut induk sebelum menambahkan atributmu sendiri:

class Animal:
    def __init__(self, name):
        self.name = name

class LabeledDog(Animal):
    def __init__(self, name, tag_number):
        super().__init__(name)
        self.tag_number = tag_number

d = LabeledDog("Rex", tag_number=42)
print(d.name, d.tag_number)

Inheritance berguna tapi gampang dipakai berlebihan. Programmer Python pemula sering langsung memakai inheritance padahal komposisi, yaitu menyimpan sebuah objek sebagai atribut, akan lebih jelas. Mulailah dengan struktur class yang datar, dan baru pakai inheritance kalau memang ada hubungan "adalah sebuah" (is-a) yang nyata.

Halaman inheritance Python membahas lebih jauh: memperluas method induk dengan super(), isinstance dan issubclass, abstract base class, multiple inheritance, dan method resolution order.

Dataclass: default yang lebih enak untuk data rekaman

Kalau kamu ingin class yang tugas utamanya menyimpan beberapa atribut, dengan perbandingan kesamaan dan tampilan yang wajar, @dataclass menghemat banyak kode berulang (boilerplate):

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p = Point(3.0, 4.0)
q = Point(3.0, 4.0)

print(p)
print(p == q)     # True - dataclasses handle equality automatically
print(p.x, p.y)

Bandingkan dengan menulis __init__, __repr__, dan __eq__ sendiri. Dataclass adalah pilihan pertama yang tepat setiap kali kamu sebenarnya akan menulis class Thing yang isinya hanya __init__ untuk mengisi atribut.

Property: atribut yang dihitung

Kadang kamu ingin sebuah "atribut" yang sebenarnya dihitung. @property membuatnya terlihat seperti mengakses atribut:

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def area(self):
        return 3.14159 * self.radius ** 2

c = Circle(5)
print(c.area)       # called like an attribute, not c.area()

Pakai property setiap kali kamu akan menulis obj.get_something(): menggantinya dengan property membuat API-nya terasa lebih alami. Jangan memakainya untuk menyembunyikan operasi yang berat, karena pengguna mengira mengakses atribut itu cepat.

Private berdasarkan konvensi

Python tidak punya private yang sungguhan. Menurut konvensi, atribut yang diawali garis bawah dimaksudkan sebagai private: pembaca diharapkan tidak menyentuhnya dari luar class.

class Cache:
    def __init__(self):
        self._store = {}

    def put(self, key, value):
        self._store[key] = value

    def get(self, key, default=None):
        return self._store.get(key, default)

Nama dengan dua garis bawah (__name) memicu name mangling, yang menambahkan nama class ke atribut itu. Itu alat untuk menghindari bentrokan nama dalam inheritance, bukan langkah keamanan.

Kapan tidak perlu memakai class

Kalau yang kamu punya hanya sekumpulan data yang saling terkait, sebuah dataclass, dict biasa, atau named tuple sudah cukup. Kalau yang kamu punya hanya satu fungsi, fungsi itu tidak perlu dibungkus class. Pakai class kalau kamu punya state dan perilaku yang saling terikat, terutama kalau nanti akan ada banyak instance dari jenis yang sama.

Contoh terakhir

Buffer log kecil yang mirip file:

from datetime import datetime

class Logger:
    def __init__(self, name):
        self.name = name
        self._entries = []

    def log(self, message):
        timestamp = datetime.now().strftime("%H:%M:%S")
        self._entries.append(f"[{timestamp}] {self.name}: {message}")

    def dump(self):
        return "\n".join(self._entries)

    def __len__(self):
        return len(self._entries)

logger = Logger("api")
logger.log("starting")
logger.log("ready")
logger.log("shutting down")

print(logger.dump())
print(len(logger))

Perhatikan __len__, satu lagi magic method. Mendefinisikannya membuat len(logger) bisa dipakai, karena len(x) sebenarnya adalah pemanggilan x.__len__(). Python punya puluhan hook seperti ini; kamu akan mempelajarinya sesuai kebutuhan.