classmethod dan staticmethod

Instance method bekerja atas satu object lewat self, dan itu menutupi hampir semua kebutuhan sehari-hari. Namun ada dua situasi yang tidak pas dengan pola tersebut: membuat object lewat cara yang berbeda dari __init__ (misalnya menafsirkan satu string "judul|penulis|tahun"), dan menyimpan fungsi bantu yang memang tidak butuh object maupun class. Python menyediakan dua jenis method tambahan untuk itu: classmethod yang menerima class itu sendiri, dan staticmethod yang tidak menerima apa pun. Keduanya diaktifkan lewat decorator — penanda @nama yang ditulis tepat di atas def.

classmethod dan Alternative Constructor #

Decorator @classmethod memberi tahu interpreter: saat method ini dipanggil, oper object class sebagai argumen pertama — parameter ini kebiasaannya dinamai cls. Kegunaan paling klasiknya adalah alternative constructor: cara kedua (atau ketiga) untuk membangun object dari bentuk data yang berbeda:

class Buku:
    def __init__(self, judul, penulis, tahun):
        self.judul = judul
        self.penulis = penulis
        self.tahun = tahun

    @classmethod
    def dari_string(cls, teks):
        judul, penulis, tahun = teks.split("|")
        return cls(judul, penulis, int(tahun))

    def deskripsi(self):
        return f"{self.judul} ({self.penulis}, {self.tahun})"

buku1 = Buku("Laskar Pelangi", "Andrea Hirata", 2005)
buku2 = Buku.dari_string("Bumi Manusia|Pramoedya A. Toer|1980")

print(buku1.deskripsi())
print(buku2.deskripsi())

Output yang Dihasilkan:

Laskar Pelangi (Andrea Hirata, 2005)
Bumi Manusia (Pramoedya A. Toer, 1980)

Mari kita telaah baris-baris kode di atas:

1. Baris 7 (@classmethod): decorator mengubah cara interpreter mengoper argumen — cls diisi object class Buku, bukan instance.
2. Baris 8 (def dari_string(cls, teks):): method ini bisa dipanggil langsung dari class (Buku.dari_string(...)) tanpa object apa pun, karena yang dibutuhkan justru class-nya.
3. Baris 9 (judul, penulis, tahun = teks.split("|")): satu string dipecah menjadi tiga bagian — unpacking sequence dari Section Struktur Data Dasar.
4. Baris 10 (return cls(judul, penulis, int(tahun))): cls(...) sama dengan memanggil Buku(...) — object tetap dibangun lewat __init__ seperti biasa.

Mengapa menulis cls(...) dan bukan langsung Buku(...)? Karena cls selalu berisi class yang menjadi pemanggil. Jika kelak BukuDigital mewarisi Buku, pemanggilan BukuDigital.dari_string(...) otomatis membangun object BukuDigital — perilaku yang benar untuk inheritance. Pola ini dipakai luas di standard library: dict.fromkeys(...) dan datetime.fromisoformat(...) adalah classmethod yang kita pakai tanpa sadari.

staticmethod untuk Fungsi Utility #

Decorator @staticmethod berarti kebalikan keduanya: method tidak menerima self maupun cls. Fungsinya murni input → output — hanya diparkir di dalam class karena secara konsep memang milik domain itu:

class Buku:
    def __init__(self, judul, harga):
        self.judul = judul
        self.harga = harga

    @staticmethod
    def format_rupiah(angka):
        return ("Rp" + f"{angka:,}").replace(",", ".")

    def label_harga(self):
        return f"{self.judul}: {Buku.format_rupiah(self.harga)}"

buku = Buku("Laskar Pelangi", 75000)

print(buku.label_harga())
print(Buku.format_rupiah(1250000))

Output yang Dihasilkan:

Laskar Pelangi: Rp75.000
Rp1.250.000

Method format_rupiah() tidak membaca attribute apa pun — berikan angka, terima string. Karena tidak butuh self, decorator @staticmethod membuat tanda kurungnya benar-benar hanya berisi data yang dibutuhkan. Pemanggilan bisa lewat class (Buku.format_rupiah(1250000)) maupun lewat instance, dan keduanya sama.

Tiga Jenis Method Berdampingan #

Ketiga jenis method bisa hidup berdampingan dalam satu class. Demo berikut memperlihatkan apa yang diterima masing-masing:

class Demo:
    def method_biasa(self):
        return "menerima self"

    @classmethod
    def method_class(cls):
        return f"menerima cls: {cls.__name__}"

    @staticmethod
    def method_static():
        return "tidak menerima self maupun cls"

demo = Demo()

print(demo.method_biasa())
print(demo.method_class())
print(demo.method_static())

Output yang Dihasilkan:

menerima self
menerima cls: Demo
tidak menerima self maupun cls

Ekspresi cls.__name__ membaca nama class yang mengoper cls — terbukti bernilai "Demo". Tabel berikut merangkum ketiganya: