Operator Overloading dalam Python

Operator merupakan simbol yang digunakan untuk melakukan operasi terhadap data. Dalam Python, beberapa operator yang sudah dikenal antara lain `+`, `-`, `*`, `/`, `==`, `<`, dan `>`.

Sebelum lebih lanjut mempelajari materi tentang Operator Overloading dalam Python, terlebih dahulu pelajari materi tentang: Inheritance atau Pewarisan dalam Python, Multiple Inheritance dalam Python, dan Polimorfisme dalam Python.

Pada penggunaan biasa, operator tersebut bekerja terhadap tipe data seperti bilangan, teks, atau daftar. Namun, Python juga memungkinkan perilaku operator diatur agar dapat digunakan pada objek yang dibuat melalui class. Kemampuan tersebut disebut operator overloading.

Pengertian Operator Overloading

Operator overloading adalah kemampuan untuk menentukan perilaku operator ketika digunakan pada objek dari suatu class. Sebagai contoh, operator `+` biasanya digunakan untuk menjumlahkan bilangan.
hasil = 10 + 20
print(hasil)

Hasil:
30

Operator `+` juga dapat digunakan untuk menggabungkan teks.
hasil = "Halo " + "Python"
print(hasil)

Hasil:
Halo Python

Perilaku operator dapat dibuat sendiri untuk objek tertentu dengan menggunakan metode khusus.

Alasan Penggunaan Operator Overloading

Operator overloading dapat digunakan untuk:

• Membuat objek dapat menggunakan operator tertentu.
• Membuat kode lebih mudah dibaca.
• Menentukan perilaku operasi antarobjek.
• Menyesuaikan operator dengan kebutuhan class.
• Membuat objek dapat berinteraksi secara lebih alami.
• Menerapkan konsep polimorfisme pada operator.

Metode Khusus dalam Python

Operator overloading dilakukan menggunakan metode khusus atau sering disebut metode khusus Python. Metode tersebut biasanya memiliki dua garis bawah pada awal dan akhir nama.

Contoh:
__add__()

Metode tersebut berkaitan dengan operator `+`. Beberapa metode khusus yang sering digunakan:

Operator	Metode Khusus	Kegunaan
+	__add__()	Penjumlahan atau penggabungan
-	__sub__()	Pengurangan
*	__mul__()	Perkalian
/	__truediv__()	Pembagian
//	__floordiv__()	Pembagian bulat
%	__mod__()	Sisa pembagian
**	__pow__()	Perpangkatan
==	__eq__()	Perbandingan kesamaan
!=	__ne__()	Perbandingan ketidaksamaan
<	__lt__()	Lebih kecil
>	__gt__()	Lebih besar
<=	__le__()	Lebih kecil atau sama
>=	__ge__()	Lebih besar atau sama

Operator `+` dengan `__add__()`

Contoh paling sederhana adalah mengatur operator `+`.
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __add__(self, objek):
  return self.nilai + objek.nilai

Kemudian buat dua objek:
angka1 = Angka(10)
angka2 = Angka(20)
print(angka1 + angka2)

Hasil:
30

Ketika Python menemukan:
angka1 + angka2

Python dapat menjalankan:
angka1.__add__(angka2)

Operator `-` dengan `__sub__()`

Operator pengurangan dapat diatur menggunakan `__sub__()`.
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __sub__(self, objek):
  return self.nilai - objek.nilai

Penggunaan:
angka1 = Angka(30)
angka2 = Angka(10)
print(angka1 - angka2)

Hasil:
20

Operator `*` dengan `__mul__()`

Operator perkalian menggunakan `__mul__()`.
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __mul__(self, objek):
  return self.nilai * objek.nilai

Penggunaan:
angka1 = Angka(5)
angka2 = Angka(4)
print(angka1 * angka2)

Hasil:
20

Operator `/` dengan `__truediv__()`

Pembagian dapat ditentukan menggunakan `__truediv__()`.
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __truediv__(self, objek):
  return self.nilai / objek.nilai

Penggunaan:
angka1 = Angka(20)
angka2 = Angka(5)
print(angka1 / angka2)

Hasil:
4.0

Operator `//` dengan `__floordiv__()`

Pembagian bulat dapat ditentukan melalui `__floordiv__()`.
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __floordiv__(self, objek):
  return self.nilai // objek.nilai

Penggunaan:
angka1 = Angka(17)
angka2 = Angka(5)
print(angka1 // angka2)

Hasil:
3

Operator `%` dengan `__mod__()`

Operator sisa pembagian dapat menggunakan `__mod__()`.
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __mod__(self, objek):
  return self.nilai % objek.nilai

Penggunaan:
angka1 = Angka(17)
angka2 = Angka(5)
print(angka1 % angka2)

Hasil:
2

Operator `**` dengan `__pow__()`

Operator perpangkatan menggunakan `__pow__()`.
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __pow__(self, objek):
  return self.nilai ** objek.nilai

Penggunaan:
angka1 = Angka(2)
angka2 = Angka(3)
print(angka1 ** angka2)

Hasil:
8

Operator Perbandingan

Operator overloading juga dapat digunakan untuk operator perbandingan.

Misalnya:
==

dapat diatur menggunakan:
__eq__()

Contoh:
class Siswa:
 def __init__(self, nilai):
  self.nilai = nilai
 def __eq__(self, siswa):
  return self.nilai == siswa.nilai

Penggunaan:
siswa1 = Siswa(80)
siswa2 = Siswa(80)
print(siswa1 == siswa2)

Hasil:
True

Operator Lebih Besar

Operator `>` dapat diatur menggunakan `__gt__()`.
class Nilai:
 def __init__(self, nilai):
  self.nilai = nilai
 def __gt__(self, objek):
  return self.nilai > objek.nilai

Penggunaan:
nilai1 = Nilai(90)
nilai2 = Nilai(80)
print(nilai1 > nilai2)

Hasil:
True

Operator Lebih Kecil

Operator `<` menggunakan `__lt__()`.
class Nilai:
 def __init__(self, nilai):
  self.nilai = nilai
 def __lt__(self, objek):
  return self.nilai < objek.nilai

Penggunaan:
nilai1 = Nilai(70)
nilai2 = Nilai(80)
print(nilai1 < nilai2)

Hasil:
True

Operator `==` dan `!=`

Dua operator perbandingan dapat diatur melalui metode khusus.
class Produk:
 def __init__(self, harga):
  self.harga = harga
 def __eq__(self, produk):
  return self.harga == produk.harga
 def __ne__(self, produk):
  return self.harga != produk.harga

Penggunaan:
produk1 = Produk(10000)
produk2 = Produk(10000)
print(produk1 == produk2)
print(produk1 != produk2)

Hasil:
True
False

Operator `>=` dan `<=`

Operator lebih besar atau sama menggunakan:
__ge__()

Operator lebih kecil atau sama menggunakan:
__le__()

Contoh:
class Nilai:
 def __init__(self, nilai):
  self.nilai = nilai
 def __ge__(self, objek):
  return self.nilai >= objek.nilai
 def __le__(self, objek):
  return self.nilai <= objek.nilai

Operator `__str__()`

Selain operator matematika dan perbandingan, metode khusus juga dapat digunakan untuk menentukan bentuk teks suatu objek. Metode yang sering digunakan adalah:
__str__()

Contoh:
class Siswa:
 def __init__(self, nama, nilai):
  self.nama = nama
  self.nilai = nilai
 def __str__(self):
  return f"{self.nama} memiliki nilai {self.nilai}"

Penggunaan:
siswa = Siswa("Budi", 85)
print(siswa)

Hasil:
Budi memiliki nilai 85

Tanpa `__str__()`, hasil ketika objek dicetak biasanya berupa informasi objek yang tidak langsung menjelaskan isi objek.

Operator `__len__()`

Metode `__len__()` dapat digunakan untuk menentukan hasil ketika objek digunakan bersama fungsi `len()`.

Contoh:
class DaftarNilai:
 def __init__(self, nilai):
  self.nilai = nilai
 def __len__(self):
  return len(self.nilai)

Penggunaan:
data = DaftarNilai([80, 75, 90, 85])
print(len(data))

Hasil:
4

Contoh Operator Overloading pada Titik

Operator overloading dapat digunakan pada objek titik koordinat.
class Titik:
 def __init__(self, x, y):
  self.x = x
  self.y = y
 def __add__(self, titik):
  return Titik(
   self.x + titik.x,
   self.y + titik.y)
 def __str__(self):
  return f"({self.x}, {self.y})"

Penggunaan:
titik1 = Titik(2, 3)
titik2 = Titik(4, 5)
hasil = titik1 + titik2
print(hasil)

Hasil:
(6, 8)

Operator `+` sekarang memiliki makna khusus untuk objek `Titik`.

Contoh Operator Overloading pada Pecahan

Operator overloading juga dapat digunakan untuk membuat class bilangan pecahan.
class Pecahan:
 def __init__(self, pembilang, penyebut):
  self.pembilang = pembilang
  self.penyebut = penyebut
 def __add__(self, pecahan):
  pembilang = (
  self.pembilang * pecahan.penyebut
  + pecahan.pembilang * self.penyebut)

penyebut = self.penyebut * pecahan.penyebut
return Pecahan(pembilang, penyebut)

 def __str__(self):
  return f"{self.pembilang}/{self.penyebut}"

Penggunaan:
pecahan1 = Pecahan(1, 2)
pecahan2 = Pecahan(1, 3)
hasil = pecahan1 + pecahan2
print(hasil)

Hasil:
5/6

Contoh tersebut menunjukkan bahwa operator `+` dapat diberi perilaku khusus sesuai kebutuhan class.

Operator Overloading dan Polimorfisme

Operator overloading memiliki hubungan dengan polimorfisme. Polimorfisme memungkinkan bentuk operasi yang sama digunakan pada objek berbeda dengan perilaku yang berbeda.

Contohnya operator `+`:
print(10 + 20)
print("Halo " + "Python")

Operator yang sama memiliki perilaku berbeda berdasarkan jenis data. Pada class buatan sendiri, perilaku tersebut dapat ditentukan melalui metode khusus seperti `__add__()`.

Operator Overloading dan Inheritance

Operator overloading juga dapat diwariskan.

Contoh:
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __add__(self, objek):
  return self.nilai + objek.nilai

class AngkaKhusus(Angka):
 pass

Class `AngkaKhusus` dapat menggunakan `__add__()` yang berasal dari parent class.

Mengganti Perilaku Operator pada Child Class

Child class dapat mengganti metode operator.
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __add__(self, objek):
  return self.nilai + objek.nilai

class AngkaKhusus(Angka):
 def __add__(self, objek):
  return self.nilai + objek.nilai + 100

Penggunaan:
a = AngkaKhusus(10)
b = AngkaKhusus(20)
print(a + b)

Hasil:
130

Operator Unary

Python juga menyediakan operator unary, yaitu operator yang digunakan terhadap satu objek.

Contohnya:
-a

Metode khusus untuk operator tersebut adalah:
__neg__()

Contoh:
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __neg__(self):
  return -self.nilai

Penggunaan:
angka = Angka(10)
print((-angka).nilai)

Hasil:
-10

Operator `+` Unary

Operator `+` juga dapat digunakan sebagai operator unary.

Metode khususnya:
__pos__()

Contoh:
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __pos__(self):
  return self.nilai

Operator `~`

Operator `~` dapat diatur menggunakan:
__invert__()

Contoh:
class Angka:
 def __init__(self, nilai):
  self.nilai = nilai
 def __invert__(self):
  return ~self.nilai

Operator `[]`

Operator indeks juga dapat disesuaikan melalui metode khusus seperti `__getitem__()`.

Contoh:
class Data:
 def __init__(self, nilai):
  self.nilai = nilai
 def __getitem__(self, indeks):
  return self.nilai[indeks]

Penggunaan:
data = Data([10, 20, 30])
print(data[1])

Hasil:
20

Tabel Operator dan Metode Khusus

Operator	Metode Khusus	Kegunaan
+	__add__()	Penjumlahan
-	__sub__()	Pengurangan
*	__mul__()	Perkalian
/	__truediv__()	Pembagian
//	__floordiv__()	Pembagian bulat
%	__mod__()	Sisa pembagian
**	__pow__()	Perpangkatan
==	__eq__()	Sama dengan
!=	__ne__()	Tidak sama dengan
>	__gt__()	Lebih besar
<	__lt__()	Lebih kecil
>=	__ge__()	Lebih besar atau sama
<=	__le__()	Lebih kecil atau sama
-objek	__neg__()	Nilai negatif
+objek	__pos__()	Nilai positif
~objek	__invert__()	Operasi pembalikan
objek[indeks]	__getitem__()	Mengakses indeks
str(objek)	__str__()	Menghasilkan teks objek
len(objek)	__len__()	Menentukan panjang objek

Kesalahan yang Perlu Dihindari

Berikut beberapa contoh kesalahan yang perlu dihindari dalam penggunaan Operator Overloading pada Python.

Salah Menulis Nama Metode

Nama metode khusus harus ditulis dengan benar.

Benar:
def __add__(self, objek):

Bukan:
def add(self, objek):

Keduanya merupakan metode berbeda. Python hanya mengenali metode khusus sesuai nama yang telah ditentukan.

Tidak Mengembalikan Nilai yang Sesuai

Berikut diberikan contoh tidak mengembalikan nilai yang sesuai.

Contoh:
def __add__(self, objek):
print(self.nilai + objek.nilai)

Metode tersebut hanya menampilkan hasil dan tidak mengembalikan nilai. Jika hasil operasi akan digunakan kembali, dapat digunakan:
def __add__(self, objek):
return self.nilai + objek.nilai

Tidak Memeriksa Jenis Objek

Operator dapat dipanggil dengan objek yang tidak sesuai.

Contoh:
angka1 + "Python"

Jika class hanya dirancang untuk menerima objek tertentu, program perlu menangani kondisi tersebut dengan baik.

Waktu Penggunaan Operator Overloading

Operator overloading dapat digunakan ketika operator bawaan memiliki makna yang masuk akal untuk objek yang dibuat.

Contohnya:

• `+` untuk menjumlahkan objek koordinat.
• `-` untuk menghitung selisih objek.
• `*` untuk operasi tertentu pada objek.
• `==` untuk membandingkan isi dua objek.
• `<` dan `>` untuk membandingkan nilai objek.
• `[]` untuk mengakses data internal.
• `str()` untuk menampilkan informasi objek.

Penggunaan operator overloading sebaiknya tetap mengikuti makna yang mudah dipahami.

Keuntungan Operator Overloading

Beberapa keuntungan operator overloading:

• Kode menjadi lebih ringkas.
• Penggunaan objek menjadi lebih alami.
• Operasi antarobjek lebih mudah dibaca.
• Perilaku operator dapat disesuaikan.
• Mendukung konsep polimorfisme.
• Dapat membantu membuat class lebih fleksibel.

Kekurangan Operator Overloading

Operator overloading juga memiliki beberapa kekurangan:

• Kode dapat membingungkan jika perilaku operator tidak lazim.
• Terlalu banyak metode khusus dapat membuat class sulit dipahami.
• Kesalahan implementasi dapat menghasilkan perilaku yang tidak diharapkan.
• Pembaca program perlu memahami perilaku operator yang dibuat.

Karena itu, operator overloading sebaiknya digunakan untuk operasi yang memiliki hubungan jelas dengan objek.

Langkah Mempelajari Operator Overloading

Urutan pembelajaran yang dapat digunakan:

1. Pahami class dan objek.
2. Pelajari metode dan atribut.
3. Pahami `__init__()`.
4. Pelajari metode khusus.
5. Pelajari `__str__()`.
6. Pelajari `__add__()`.
7. Pelajari operator pengurangan, perkalian, dan pembagian.
8. Pelajari operator perbandingan.
9. Pelajari operator indeks.
10. Latih penerapan operator pada class buatan sendiri.

Latihan

Berikut diberikan beberapa contoh latihan yang dapat langsung dipraktikkan oleh pengembang.

Latihan 1

Buat class `Angka` yang dapat menggunakan operator `+`.

Latihan 2

Buat class `Titik` yang dapat menjumlahkan dua koordinat menggunakan operator `+`.

Latihan 3

Buat class `Nilai` yang dapat dibandingkan menggunakan `>` dan `<`.

Latihan 4

Buat class `Produk` yang dapat membandingkan dua objek menggunakan `==`.

Latihan 5

Buat class `Data` yang dapat menggunakan operator indeks `[]`.

Latihan 6

Buat class `Panjang` yang dapat dijumlahkan menggunakan operator `+`.

Latihan 7

Buat class `Pecahan` yang dapat menjumlahkan dua bilangan pecahan.

Latihan 8

Buat class yang memiliki `__str__()` sehingga objek dapat ditampilkan dalam bentuk teks yang mudah dibaca.

Kesimpulan

Operator overloading merupakan kemampuan Python untuk menentukan perilaku operator ketika digunakan pada objek dari class tertentu. Konsep ini memungkinkan operator seperti `+`, `-`, `*`, `/`, `==`, `<`, dan `>` digunakan pada objek dengan perilaku yang sesuai kebutuhan program.

Penerapannya dilakukan melalui metode khusus seperti `__add__()`, `__sub__()`, `__mul__()`, `__truediv__()`, dan `__eq__()`. Setiap metode memiliki hubungan dengan operator tertentu.

Operator overloading sangat berguna dalam pemrograman berorientasi objek karena membuat objek dapat digunakan dengan cara yang lebih alami. Sebagai contoh, dua objek `Titik` dapat dijumlahkan menggunakan operator `+`, sedangkan dua objek `Pecahan` dapat dibandingkan atau dijumlahkan berdasarkan aturan yang dibuat pada class.

Penggunaan operator overloading perlu dilakukan secara tepat. Perilaku operator sebaiknya mudah dipahami dan tetap memiliki hubungan yang masuk akal dengan objek. Dengan memahami class, metode khusus, operator, inheritance, dan polimorfisme, operator overloading dapat digunakan untuk membuat program Python yang lebih fleksibel dan terstruktur.

Artikel ini akan dibaca oleh: Fadlan Wahyu Saputra, Fahra Amelia, Fajar Rizky Saputra, Farah Husna Pramesti, dan Farid Putra Setiawan.

Location: Kota Semarang, Jawa Tengah, Indonesia

Berbagi :