Mengapa Saya Berhenti Menggunakan Class di Python (Dan Apa yang Saya Gunakan Sebagai Gantinya)

Mengapa Saya Berhenti Menggunakan Class di Python (Dan Apa yang Saya Gunakan Sebagai Gantinya)

Dulu, setiap kali menulis kode Python, refleks saya selalu sama: bikin class dulu. Kebiasaan ini datang dari latar belakang belajar bahasa seperti Java dan C++, di mana hampir semua hal dibungkus dalam class. Rasanya seperti “aturan tak tertulis” bahwa kode yang bagus harus berbentuk objek.

Tapi semakin lama menulis Python—terutama untuk scripting, automation, backend ringan, dan data processing—saya mulai sadar sesuatu: tidak semua hal perlu class. Bahkan, dalam banyak kasus, class justru menambah kompleksitas yang tidak perlu.

Ini bukan artikel anti-OOP. Saya tetap menggunakan class ketika memang tepat. Tapi saya berhenti menggunakannya secara default. Dan jujur saja, kode saya jadi lebih simpel, lebih bersih, dan lebih Pythonic.

1. Python Bukan Sekadar Bahasa OOP

Salah satu kesalahan umum yang sering terjadi adalah menganggap Python seperti Java versi lebih santai. Padahal Python adalah multi-paradigm language. Ia mendukung:

• Object-Oriented Programming (OOP)
• Functional Programming
• Procedural Programming

Artinya, kamu tidak wajib membungkus semuanya dalam class.

Di Java, hampir semua hal harus ada di dalam class. Bahkan fungsi pun harus menjadi method. Tapi di Python? Kamu bisa menulis fungsi langsung di file dan langsung menjalankannya.

Contoh sederhana:

def greet(name):
    return f"Hello, {name}"

Selesai. Tidak perlu class Greeter. Tidak perlu constructor. Tidak perlu self.

Untuk banyak script kecil—automation, CLI tools, parsing file, API request sederhana—OOP justru terasa berlebihan.

Baca Juga

• Python Time.Sleep()
• Tips & Trik Shortcut Vs Code

 

2. Classes Menambah Boilerplate

Mari kita bandingkan dua pendekatan untuk hal sederhana.

Versi class:

class Calculator:
    def add(self, a, b):
        return a + b

Versi fungsi biasa:

def add(a, b):
    return a + b

Untuk kasus sekecil ini, class jelas terasa overkill.

Dalam versi class, kita punya:

• Keyword class
• Method definition
• Parameter self
• Harus instansiasi objek dulu sebelum dipakai

Sedangkan versi fungsi:

• Lebih pendek
• Langsung bisa dipakai
• Lebih jelas maksudnya

Semakin kecil problemnya, semakin terasa berat penggunaan class. Boilerplate seperti ini memang tidak terasa besar di awal, tapi ketika kode makin panjang, struktur yang tidak perlu bisa memperumit pemeliharaan.

 

3. Functions + Modules Sudah Lebih dari Cukup

Alih-alih membuat satu class besar dengan banyak method, saya sekarang lebih suka memecah logika ke dalam fungsi-fungsi kecil dan mengelompokkannya dalam module (.py file).

Contohnya:

project/
│
├── math_utils.py
├── file_utils.py
└── main.py


Di math_utils.py:
def add(a, b):
    return a + b


def subtract(a, b):
    return a - b

Pendekatan ini:

• Lebih modular
• Mudah dibaca
• Mudah dites
• Tidak perlu instansiasi objek

Ini sangat “Pythonic”. Filosofi Python sendiri (Zen of Python) menekankan kesederhanaan dan keterbacaan.

Kalau sebuah fungsi tidak perlu menyimpan state kompleks, kenapa harus jadi method dalam class?

 

4. Dataclasses & NamedTuple Menggantikan Class Data Kosong

Sering kali kita membuat class hanya untuk menyimpan data.

Contoh klasik:

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

Padahal Python sudah menyediakan solusi yang jauh lebih bersih: dataclass.

from dataclasses import dataclass


@dataclass
class User:
    name: str
    age: int

Lebih pendek. Lebih jelas. Tidak perlu menulis __init__. Tidak perlu set atribut manual.

Atau bahkan lebih ringan lagi:

from collections import namedtuple


User = namedtuple("User", ["name", "age"])

Untuk class yang hanya menyimpan data tanpa logika kompleks, dataclass atau namedtuple adalah pilihan yang jauh lebih elegan.

 

5. Closure & Higher-Order Functions Menggantikan Class Stateful

Kadang kita membuat class hanya untuk menyimpan satu state kecil.

Contoh:

class Multiplier:
    def __init__(self, factor):
        self.factor = factor


    def multiply(self, x):
        return x * self.factor

Padahal kita bisa melakukannya dengan closure:

def multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply


times3 = multiplier(3)
print(times3(5))  # 15

Tidak ada class. Tidak ada instansiasi. Tidak ada atribut. Tapi tetap menyimpan state (factor).

Closure adalah fitur powerful di Python yang sering diremehkan. Dengan ini, kita bisa membuat fungsi yang “mengingat” nilai tertentu tanpa perlu membuat objek.

 

6. Komposisi Lebih Fleksibel daripada Inheritance

Dalam OOP tradisional, kita sering menggunakan inheritance untuk memperluas perilaku.

Tapi inheritance bisa menjadi rumit:

• Hierarki kelas panjang
• Sulit dipahami
• Sulit di-debug

Alternatifnya? Gunakan fungsi dan komposisi.

Contoh decorator sederhana:

def log_function(func):
    def wrapper(*args, **kwargs):
        print("Function is running")
        return func(*args, **kwargs)
    return wrapper

Ini adalah cara Pythonic untuk menambahkan perilaku tanpa inheritance.

 

7. Kode Lebih Mudah Dites

Function-based design sering lebih mudah dites dibanding class-heavy design.

Contoh unit test untuk fungsi:

def add(a, b):
    return a + b

Test-nya sangat simpel:

• Input → Output
• Tidak perlu mock object
• Tidak perlu setup state kompleks

Class sering memerlukan:

• Setup object
• Inisialisasi dependency
• Mocking attribute

Semakin sederhana struktur kode, semakin mudah testing-nya.

 

8. Lebih Mudah Dibaca dan Dipahami

Ketika membaca kode orang lain, struktur yang terlalu banyak class bisa membuat alur logika terasa tersembunyi.

Fungsi yang berdiri sendiri biasanya:

• Jelas inputnya
• Jelas outputnya
• Tidak tergantung pada state tersembunyi

Python terkenal dengan keterbacaannya. Terlalu banyak class bisa mengurangi keunggulan itu.

 

9. Performa dan Memory (Dalam Skala Tertentu)

Setiap object instance memiliki overhead memory. Untuk aplikasi kecil mungkin tidak terasa. Tapi dalam data processing skala besar, ribuan instance class bisa memberi dampak.

Function + dataclass ringan sering lebih efisien dibanding class kompleks dengan banyak method dan atribut tambahan.

 

10. Kapan Saya Tetap Menggunakan Class?

Saya tidak anti-class. Saya tetap menggunakannya ketika memang tepat.

Contohnya:

1. Framework-Based Code

• Django models
• FastAPI dependencies
• Pydantic models

Framework sering memang dirancang berbasis class.

2. Sistem Kompleks dengan Banyak State

Jika ada banyak interaksi antar state dan behavior, class memang masuk akal.

3. Inheritance & Polymorphism

Jika desain benar-benar membutuhkan hierarki perilaku, OOP tetap relevan.

Tapi di luar itu? Saya lebih sering menggunakan:

• Functions
• Modules
• Dataclasses
• Closures

 

Takeaway Besar: Python Bukan Java

Kesalahan terbesar saat belajar Python adalah membawanya dengan mindset Java.

Python tidak memaksa kamu menggunakan class untuk semuanya. Python memberi pilihan.

Dan sering kali, solusi paling sederhana adalah:

• Fungsi kecil
• Module terpisah
• Data container ringan

Kode jadi:

• Lebih pendek
• Lebih bersih
• Lebih mudah dirawat
• Lebih Pythonic

 

Kesimpulan Akhir

Berhenti menggunakan class secara default bukan berarti meninggalkan OOP sepenuhnya. Ini tentang memilih alat yang tepat untuk masalah yang tepat.

Kalau problemnya sederhana, gunakan fungsi. Kalau hanya menyimpan data, gunakan dataclass. Kalau butuh state kecil, gunakan closure. Kalau sistemnya kompleks, barulah gunakan class.

Python itu fleksibel. Jangan membatasi diri pada satu paradigma saja. Karena pada akhirnya, kode yang baik bukan tentang mengikuti satu gaya tertentu—melainkan tentang membuat solusi yang jelas, sederhana, dan mudah dipahami.

Published on May 15, 2026
Last updated on June 03, 2026