Menguasai Operator Overloading di Python: Panduan Praktis

Python Operator Overloading

Temukan cara mendefinisikan ulang perilaku operator di Python menggunakan metode khusus seperti __add__, __lt__, dan lainnya, meningkatkan desain OOP Anda.

Python Operator Overloading

Operator bawaan Python bekerja berbeda tergantung pada tipe operand. Operator +, misalnya, menambahkan angka, menggabungkan string, atau menggabungkan list. Fleksibilitas ini dicapai melalui operator overloading—fitur yang memungkinkan Anda menetapkan arti yang spesifik untuk konteks operator untuk kelas Anda sendiri.

Pertimbangkan kelas Point sederhana yang merepresentasikan koordinat di bidang 2-D. Tanpa metode khusus, mencoba menambahkan dua titik akan menghasilkan TypeError:

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1+p2)

Output

Traceback (most recent call last): File "<string>", line 9, in <module> print(p1+p2) TypeError: unsupported operand type(s) for +: 'Point' and 'Point'

Karena Python tidak memiliki pengetahuan bawaan tentang cara menggabungkan dua instance Point, ia melempar exception. Operator overloading memungkinkan kita untuk menentukan perilaku itu sendiri.

---

Python Special Methods

Metode yang dikelilingi oleh garis bawah ganda—__init__, __str__, __add__, dan lain-lain—disebut special methods atau metode "dunder". Mereka dipanggil secara implisit oleh runtime Python dan menjadi titik kait untuk operator overloading, container protocols, dan lainnya.

Misalnya, metode __str__ mengontrol cara objek dikonversi ke string yang dapat dibaca manusia. Secara default, mencetak objek menampilkan alamat memori, yang seringkali tidak berguna. Mengganti __str__ dapat membuat debugging dan logging jauh lebih jelas:

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return '({0}, {1})'.format(self.x, self.y)

Sekarang, saat kita mencetak Point, kita mendapatkan:

p1 = Point(2, 3)
print(p1)

Output

(2, 3)

Representasi yang sama digunakan oleh str(p1) dan format(p1) karena Python secara internal memanggil p1.__str__().

---

Overloading Operator +

Untuk menyesuaikan penambahan untuk objek Point, terapkan __add__:

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return '({0}, {1})'.format(self.x, self.y)
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

Menguji perilaku baru:

p1 = Point(1, 2)
p2 = Point(2, 3)
print(p1 + p2)

Output

(3, 5)

Di balik layar, Python mengeksekusi p1.__add__(p2), yang mengembalikan Point baru dengan koordinat yang dijumlahkan.

Di bawah ini adalah referensi cepat untuk operator aritmetika lainnya dan metode khusus yang perlu Anda terapkan:

Operator	Expression	Special Method
Addition	p1 + p2	__add__(self, other)
Subtraction	p1 - p2	__sub__(self, other)
Multiplication	p1 * p2	__mul__(self, other)
Power	p1 ** p2	__pow__(self, other)
Division	p1 / p2	__truediv__(self, other)
Floor Division	p1 // p2	__floordiv__(self, other)
Modulo	p1 % p2	__mod__(self, other)
Left Shift	p1 << p2	__lshift__(self, other)
Right Shift	p1 >> p2	__rshift__(self, other)
Bitwise AND	p1 & p2	__and__(self, other)
Bitwise OR	p1 | p2	__or__(self, other)
Bitwise XOR	p1 ^ p2	__xor__(self, other)
Bitwise NOT	~p1	__invert__(self)

---

Overloading Comparison Operators

Operator overloading tidak terbatas pada aritmetika. Operator perbandingan juga dapat disesuaikan. Misalnya, untuk membandingkan titik berdasarkan jaraknya dari titik asal, ganti __lt__:

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return '({0}, {1})'.format(self.x, self.y)
    def __lt__(self, other):
        self_mag = self.x**2 + self.y**2
        other_mag = other.x**2 + other.y**2
        return self_mag < other_mag

Penggunaan:

p1 = Point(1, 1)
p2 = Point(-2, -3)
p3 = Point(1, -1)
print(p1 < p2) # True
print(p2 < p3) # False
print(p1 < p3) # False

Metode perbandingan lainnya mengikuti pola yang serupa:

Operator	Expression	Special Method
Less Than	p1 < p2	__lt__(self, other)
Less Than or Equal	p1 <= p2	__le__(self, other)
Equal	p1 == p2	__eq__(self, other)
Not Equal	p1 != p2	__ne__(self, other)
Greater Than	p1 > p2	__gt__(self, other)
Greater Than or Equal	p1 >= p2	__ge__(self, other)

Dengan menentukan metode ini dengan hati-hati, Anda dapat membuat objek kustom berpartisipasi secara alami dalam konteks aritmetika dan perbandingan, sehingga meningkatkan keterbacaan dan kemudahan pemeliharaan kode.