Belajar Python OOP Untuk Pemula

oop itu materi yang paling lama saya hindari pas belajar python. alasannya simpel, hampir semua tutorial nyebut “class itu blueprint” tapi jarang ada yang nunjukin kenapa saya butuh class di project beneran. kalau kalian di posisi itu sekarang, tenang, artikel ini saya tulis dari sudut pandang orang yang dulu juga bingung dan akhirnya “klik” 🙂

sebelum lanjut, pastikan kalian sudah paham function dan lambda Python, karena method di dalam class itu sebenarnya fungsi yang “menempel” ke object. kalau mau sekalian refresh dasar-dasarnya, bisa cek juga tipe data dan variabel Python.

saya ngerasain sendiri momen butuhnya oop pas project mulai gede. fungsi-fungsi terpisah yang tadinya rapi mulai berantakan, ada tujuh fungsi yang cuma buat ngolah data mahasiswa, dan kalau satu diubah, tiga tempat lain ikut rusak. class dan object ngebenerin itu, data sama perilakunya dijadiin satu tempat.

1. Apa Itu OOP?

oop (object oriented programming) itu paradigma pemrograman yang ngatur kode lewat “object”, bukan cuma fungsi-fungsi yang berjejer. tiap object bawa dua hal:

• atribut (data), hal yang menggambarkan object, kayak nama, umur, saldo
• method (perilaku), hal yang bisa dilakukan object, kayak menyapa atau menghitung luas

kenapa repot-repot? karena di project yang gede, oop bikin kode lebih terstruktur, gampang dirawat, dan bisa dipakai ulang. begitu konsepnya nyantol, baca kode framework macam django atau flask juga langsung kebayang, karena hampir semuanya ditulis pakai class.

2. Class dan Object

class itu cetakannya, object itu hasil cetakannya.

analogi yang paling membantu saya waktu itu: class itu seperti cetakan kue, dan object adalah kue-kue yang dihasilkan. cetakannya satu, tapi kue-nya bisa banyak dan masing-masing bisa diberi isian berbeda. dengan analogi itu, perbedaan class dan object langsung terasa masuk akal.

# Membuat class
class Mahasiswa:
    # Atribut class (sama untuk semua instance)
    jurusan = "Informatika"
    
    # Constructor, dipanggil saat object dibuat
    def __init__(self, nama, umur):
        # Atribut instance (berbeda per object)
        self.nama = nama
        self.umur = umur
    
    # Method
    def sapa(self):
        print(f"Halo, saya {self.nama}")

# Membuat object
m1 = Mahasiswa("Andi", 20)
m2 = Mahasiswa("Budi", 22)

print(m1.nama)    # Andi
print(m1.jurusan) # Informatika
m1.sapa()         # Halo, saya Andi

dari kode di atas, Mahasiswa itu class, sedangkan m1 dan m2 itu object. satu class bisa bikin banyak object, dan tiap object pegang datanya sendiri.

self itu apa?

self itu cara object merujuk ke dirinya sendiri. waktu m1.sapa() dipanggil, python di balik layar ngerubahnya jadi Mahasiswa.sapa(m1), jadi self itu ya m1. itu kenapa semua method di dalam class harus punya parameter pertama self, bukan aturan asal-asalan, tapi biar object tahu dirinya yang mana.

3. Constructor init

__init__ itu method khusus yang otomatis dipanggil pas object dibuat. fungsinya buat ngasih nilai awal ke atribut.

class Buku:
    def __init__(self, judul, penulis, tahun):
        self.judul = judul
        self.penulis = penulis
        self.tahun = tahun
        self.dipinjam = False
    
    def info(self):
        status = "dipinjam" if self.dipinjam else "tersedia"
        return f"{self.judul} ({self.tahun}) - {status}"

buku = Buku("Python 101", "Andi", 2026)
print(buku.info())  # Python 101 (2026) - tersedia

perhatikan dipinjam di dalam __init__, dia tidak dikirim dari luar, tapi langsung diisi False. itu cara kasih nilai awal yang rapi, object langsung dalam kondisi benar begitu lahir.

4. Encapsulation, Public, Protected, Private

encapsulation itu aturan “data sensitif jangan diakses sembarangan”. python pakai konvensi penamaan, bukan keyword khusus:

• public → self.nama, bisa diakses dari mana pun
• protected → self._nama, satu underscore, kode etik “sebaiknya jangan disentuh dari luar”
• private → self.__nama, dua underscore, python nyamarin namanya (name mangling) biar susah diakses

class Rekening:
    def __init__(self, pemilik, saldo):
        self.pemilik = pemilik      # public
        self._bank = "BCA"          # protected
        self.__saldo = saldo        # private
    
    def lihat_saldo(self):
        return f"Rp{self.__saldo:,}"
    
    def setor(self, jumlah):
        if jumlah > 0:
            self.__saldo += jumlah

r = Rekening("Andi", 1000000)
print(r.pemilik)        # Andi ✅
print(r._bank)          # BCA ✅ (tapi sebaiknya tidak)
# print(r.__saldo)      # ❌ AttributeError!
print(r.lihat_saldo())  # Rp1,000,000 ✅

catatan jujur: di python, r._Rekening__saldo sebenarnya masih bisa diakses kalau nekat. underscore itu lebih ke kesepakatan antar programmer, bukan kunci gembok. intinya, kalau ada underscore, jangan disentuh, akses lewat method yang disediakan.

5. Inheritance, Pewarisan

inheritance (pewarisan) bikin class anak bisa mewarisi atribut dan method dari class induk. ini yang bikin oop hemat banget, fitur yang sama tidak perlu ditulis dua kali.

# Parent class
class Hewan:
    def __init__(self, nama):
        self.nama = nama
    
    def bersuara(self):
        return "..."
    
    def info(self):
        return f"Hewan: {self.nama}"

# Child class
class Kucing(Hewan):
    def __init__(self, nama, warna):
        super().__init__(nama)  # Panggil constructor parent
        self.warna = warna
    
    def bersuara(self):  # Override method
        return "Meow!"
    
    def info(self):
        return f"Kucing: {self.nama} ({self.warna})"

class Anjing(Hewan):
    def bersuara(self):
        return "Guk guk!"

# Demo
kucing = Kucing("Mimi", "Oren")
anjing = Anjing("Doggy")

print(kucing.bersuara())  # Meow!
print(anjing.bersuara())  # Guk guk!
print(kucing.info())      # Kucing: Mimi (Oren)

dua hal penting di sini. pertama, super().__init__(nama) itu cara class anak manggil constructor induknya, jadi self.nama tetap keisi tanpa nulis ulang. kedua, bersuara() ditulis lagi di Kucing dan Anjing, ini namanya method overriding, perilaku induk diganti versi anak.

6. Polymorphism, Banyak Bentuk

polymorphism artinya “banyak bentuk”. method dengan nama sama bisa berperilaku beda di class berbeda, dan kode yang manggil tidak perlu tahu object-nya tipe apa.

class Persegi:
    def __init__(self, sisi):
        self.sisi = sisi
    def luas(self):
        return self.sisi ** 2

class Lingkaran:
    def __init__(self, r):
        self.r = r
    def luas(self):
        return 3.14 * self.r ** 2

# Polymorphism, satu fungsi untuk banyak bentuk
def cetak_luas(bangun):
    print(f"Luas: {bangun.luas()}")

cetak_luas(Persegi(5))     # Luas: 25
cetak_luas(Lingkaran(7))  # Luas: 153.86

fungsi cetak_luas cuma butuh object yang punya method luas(), mau itu persegi, lingkaran, atau nanti segitiga. ini yang bikin kode gampang dikembangin, tinggal tambah class baru, fungsi yang lama tidak usah diubah.

7. Method Khusus (Magic Methods)

method yang diawali dan diakhiri dua underscore punya peran spesial, python otomatis manggil dia di momen tertentu. kalian sebenarnya sudah kenalan sama __init__, sekarang lihat yang lain.

class Vektor:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):          # String representation
        return f"V({self.x}, {self.y})"
    
    def __add__(self, other):    # Operator +
        return Vektor(self.x + other.x, self.y + other.y)
    
    def __eq__(self, other):     # Operator ==
        return self.x == other.x and self.y == other.y

v1 = Vektor(2, 3)
v2 = Vektor(4, 5)

print(v1)           # V(2, 3), via __str__
print(v1 + v2)      # V(6, 8), via __add__
print(v1 == Vektor(2, 3))  # True, via __eq__

dengan magic method, object kalian langsung terasa kayak tipe bawaan python. print(v1) jadi rapi, v1 + v2 jalan, dan == membandingkan isi, bukan alamat memory. masih banyak lagi kayak __len__, __getitem__, __iter__, tapi tiga di atas yang paling sering kepake di awal.

8. Property, Getter dan Setter

kadang atribut butuh validasi, misal suhu tidak boleh di bawah nol mutlak. daripada bikin method get_suhu() dan set_suhu() yang ribet, python kasih decorator @property.

class Suhu:
    def __init__(self, celcius=0):
        self._celcius = celcius
    
    @property
    def celcius(self):
        return self._celcius
    
    @celcius.setter
    def celcius(self, nilai):
        if nilai < -273.15:
            raise ValueError("Suhu tidak bisa di bawah -273.15°C")
        self._celcius = nilai
    
    @property
    def fahrenheit(self):
        return (self._celcius * 9/5) + 32

s = Suhu(25)
print(s.celcius)     # 25
print(s.fahrenheit)  # 77.0
s.celcius = 30
print(s.fahrenheit)  # 86.0
# s.celcius = -300   # ValueError!

dari luar, s.celcius keliatan kayak atribut biasa, padahal di belakangnya ada validasi. ini kombinasi encapsulation dan kenyamanan baca kode.

9. Studi Kasus: Sistem Perpustakaan

biar semua konsep nyambung, kita bikin sistem peminjaman perpustakaan mini. ItemPerpustakaan jadi class induk, Buku dan DVD jadi class anak.

class ItemPerpustakaan:
    def __init__(self, judul, tahun):
        self.judul = judul
        self.tahun = tahun
        self.dipinjam = False
    
    def pinjam(self):
        if self.dipinjam:
            return f"'{self.judul}' sedang dipinjam"
        self.dipinjam = True
        return f"'{self.judul}' berhasil dipinjam"
    
    def kembalikan(self):
        self.dipinjam = False
        return f"'{self.judul}' dikembalikan"

class Buku(ItemPerpustakaan):
    def __init__(self, judul, tahun, penulis):
        super().__init__(judul, tahun)
        self.penulis = penulis
    
    def info(self):
        return f"Buku: {self.judul} - {self.penulis} ({self.tahun})"

class DVD(ItemPerpustakaan):
    def __init__(self, judul, tahun, durasi):
        super().__init__(judul, tahun)
        self.durasi = durasi
    
    def info(self):
        return f"DVD: {self.judul} ({self.durasi} menit)"

# Demo
buku = Buku("Python 101", 2026, "Andi")
dvd = DVD("Tutorial Git", 2026, 120)

print(buku.info())
print(buku.pinjam())
print(buku.pinjam())  # sedang dipinjam
print(buku.kembalikan())

semua konsep kepake di sini: inheritance (Buku dan DVD mewarisi ItemPerpustakaan), super().__init__ buat manggil constructor induk, override method info(), sama encapsulation lewat method pinjam() dan kembalikan() yang ngatur status dipinjam dengan aturan, buku tidak bisa dipinjam dua kali.

kalau studi kasus ini sudah kebayang, oop di python artinya sudah masuk. langkah berikutnya yang paling masuk akal itu belajar module dan package Python, biar class-class kalian tertata rapi di file terpisah.

Kesimpulan

intinya begini:

• class itu cetakan, object itu hasil cetakannya
• __init__ otomatis jalan pas object dibuat, buat ngisi nilai awal
• self itu rujukan object ke dirinya sendiri
• encapsulation ngatur akses lewat underscore, _protected dan __private
• inheritance mewariskan atribut dan method lewat super()
• polymorphism bikin satu fungsi bisa ngolah banyak bentuk object
• magic method bikin operator dan print jalan natural di object kalian
• property bikin getter dan setter dengan validasi tetap enak dibaca

Baca Juga Mengenai :

• belajar python function dan lambda
• belajar python module dan package
• belajar python tipe data dan variabel
• belajar python list tuple set dictionary