Seiring berkembangnya skrip, Anda akhirnya meneruskan kelompok variabel yang sama antar fungsi, dan menjadi sulit untuk membedakan data mana yang termasuk dalam logika mana. Kelas dan objek Python menyelesaikan masalah ini dengan menggabungkan data dan perilaku ke dalam satu unit.

Dalam tutorial ini kita membuat rekening bank kecil selangkah demi selangkah, dan menambahkan setiap ide OOP hanya jika ide tersebut memecahkan masalah. Kami menjalankan setiap contoh di Python 3.13, dan output yang ditampilkan berasal dari proses tersebut. Jika Anda baru mengenal bahasa ini, baca tutorial Python untuk pemula kami terlebih dahulu.

Apa itu kelas dan objek?

Sebuah kelas menjelaskan apa itu sesuatu dan apa yang dapat dilakukannya. Sebuah objek, juga disebut sebuah instance, adalah objek spesifik yang dibuat dari deskripsi tersebut. “Akun” adalah sebuah kelas, sedangkan akun Asha dan akun Ben adalah dua objek.

Anda telah menggunakan objek selama ini. Dalam Python, string, daftar, dan bahkan fungsi adalah objek, itulah sebabnya Anda dapat menulis "hello".upper().

Kelas pertamamu

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

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ berjalan secara otomatis setiap kali Anda membuat objek, dan ini menetapkan status awal. Menyetorkan ke a tidak menyentuh b, karena setiap objek memiliki datanya masing-masing. Perhatikan bahwa metode ini juga melindungi saldo dari nilai buruk. Panduan kami untuk penanganan pengecualian Python menjelaskan raise secara lebih mendalam.

Apa itu diri?

self hanyalah objek yang sedang dikerjakan suatu metode. Saat Anda menulis a.deposit(50), Python secara efektif memanggil Account.deposit(a, 50), meneruskan objek sebagai argumen pertama. Begitulah cara satu definisi metode dapat melayani setiap objek.

Nama self lebih merupakan konvensi yang kuat daripada kata kunci, tetapi selalu gunakan itu. Melupakannya dalam definisi metode adalah kesalahan pemula yang paling umum, dan menghasilkan pesan yang membingungkan tentang jumlah argumen.

Atribut kelas vs atribut instan

Atribut yang ditetapkan secara langsung di badan kelas digunakan bersama oleh semua objek. Satu set pada self hanya dimiliki oleh objek tersebut. Contoh ini menunjukkan bagaimana perilaku pencarian:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Kalimat terakhir itu mengejutkan banyak orang. Menugaskan melalui a tidak mengubah nilai bersama. Itu menciptakan atribut instance baru pada a yang menyembunyikan kelas satu. Python melihat objeknya terlebih dahulu, lalu kelasnya.

Metode khusus (dunder).

Metode dengan garis bawah ganda memungkinkan objek Anda bekerja dengan fitur bawaan Python. Tanpa mereka, pencetakan akun menunjukkan alamat memori yang tidak berguna. Menambahkan dua memberinya bentuk yang dapat dibaca:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

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

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Warisan

Warisan memungkinkan kelas baru menggunakan kembali kelas yang sudah ada dan hanya mengubah yang berbeda. Di sini, Savings adalah Account dengan pengaturan tambahan:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() memanggil versi induk, sehingga logika pengaturan tidak terulang. deposit diwarisi sebagaimana adanya, dan __str__ diganti untuk menambahkan label. Hanya gunakan warisan untuk hubungan “adalah” yang nyata. Jika suatu kelas hanya membutuhkan sesuatu, seperti mobil yang membutuhkan mesin, berikan objek tersebut sebagai atribut. Ini dikenal sebagai komposisi, dan biasanya lebih fleksibel dibandingkan rantai pewarisan dalam.

Polimorfisme

Polimorfisme berarti objek yang berbeda dapat merespons pemanggilan metode yang sama dengan caranya sendiri. Kode panggilan tidak perlu mengetahui jenis pastinya:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Kedua kelas ini bahkan tidak memiliki orang tua yang sama. Python hanya peduli bahwa objek tersebut memiliki metode area, sebuah pendekatan yang dikenal sebagai pengetikan bebek. Menambahkan Triangle nanti tidak memerlukan perubahan pada loop.

Enkapsulasi dan properti

Python tidak memiliki atribut yang benar-benar privat, dan ia bergantung pada konvensi. Satu garis bawah, seperti pada_price, memberitahu pengembang lain “ini internal, tolong jangan sentuh”. Untuk memeriksa nilai ketika ditetapkan, gunakan aproperti, yang terlihat seperti atribut biasa dari luar:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Ini berarti Anda dapat memulai dengan atribut biasa dan menambahkan validasi nanti tanpa mengubah kode apa pun yang menggunakan kelas tersebut. Jadi jangan menulis metode get_price() dan set_price() karena kebiasaan, seperti yang mungkin Anda lakukan di Java. Sintaks @ di sini adalah dekorator, yang kami jelaskan di penjelasan dekorator Python.

Metode kelas dan metode statis

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Kelas data

Ketika sebagian besar kelas menyimpan data, menulis __init__, __repr__ dan __eq__ dengan tangan akan membosankan. @dataclass menghasilkannya dari anotasi tipe:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Kesalahan umum

Menggunakan atribut kelas yang bisa berubah

Ini adalah bug klasik. Daftar ini ditentukan di kelas, sehingga semua kereta membagikannya:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Buat di __init__ dengan self.items = [], sehingga setiap objek mendapatkan daftarnya sendiri.

Kesalahan umum lainnya

• Lupa self. Tulis self.balance, bukan balance, di dalam metode.
• Lupa super().__init__(). Anak kemudian melewatkan atribut yang disiapkan oleh induk.
• Membangun kelas yang besar. Kelas yang melakukan segalanya sulit untuk diuji. Bagilah berdasarkan tanggung jawab.
• Warisan mendalam. Dua level biasanya banyak, dan komposisinya sering kali lebih jelas.
• Tidak menulis tes. Kelas dengan aturan mudah untuk diuji, seperti yang tutorial pytest kami tunjukkan menggunakan kereta kecil.

Penutup

Python berorientasi objek mengelompokkan data dengan perilaku yang melindunginya. Mulailah dengan __init__, metode, dan __str__, lalu tambahkan warisan dan properti saat Anda menemukan masalah yang dipecahkannya. Sebagai langkah selanjutnya, ambil skrip yang meneruskan beberapa variabel yang sama ke mana saja dan ubah menjadi satu kelas kecil.

Pertanyaan yang sering diajukan

Teruslah belajar