Anda dapat mengubah arti operator dengan Python tergantung pada operan yang digunakan. Dalam tutorial ini, Anda akan belajar bagaimana menggunakan operator overloading dalam Pemrograman Berorientasi Objek Python.
Kelebihan Operator Python
Operator Python bekerja untuk kelas bawaan. Tetapi operator yang sama berperilaku berbeda dengan tipe yang berbeda. Misalnya, +operator akan melakukan penjumlahan aritmatika pada dua angka, menggabungkan dua daftar, atau menggabungkan dua string.
Fitur dalam Python ini yang memungkinkan operator yang sama memiliki arti berbeda sesuai konteksnya disebut operator overloading.
Jadi apa yang terjadi ketika kita menggunakannya dengan objek dari kelas yang ditentukan pengguna? Mari kita pertimbangkan kelas berikut, yang mencoba untuk mensimulasikan titik dalam sistem koordinat 2-D.
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)
Keluaran
Traceback (panggilan terakhir terakhir): File "", baris 9, dicetak (p1 + p2) TypeError: jenis operan tidak didukung untuk +: 'Point' dan 'Point'
Di sini, kita dapat melihat bahwa a TypeErrordimunculkan, karena Python tidak tahu bagaimana menambahkan dua Pointobjek secara bersamaan.
Namun, kami dapat mencapai tugas ini dengan Python melalui operator overloading. Tapi pertama-tama, mari kita lihat tentang fungsi khusus.
Fungsi Khusus Python
Fungsi kelas yang dimulai dengan garis bawah ganda __disebut fungsi khusus dalam Python.
Fungsi-fungsi ini bukanlah fungsi khas yang kami definisikan untuk sebuah kelas. The __init__()fungsi yang kita didefinisikan di atas adalah salah satunya. Itu dipanggil setiap kali kita membuat objek baru dari kelas itu.
Ada banyak fungsi khusus lainnya di Python. Kunjungi Fungsi Khusus Python untuk mempelajarinya lebih lanjut.
Dengan menggunakan fungsi khusus, kita dapat membuat kelas kita kompatibel dengan fungsi bawaan.
>>> p1 = Point(2,3) >>> print(p1)
Misalkan kita ingin print()fungsi mencetak koordinat Pointobjek, bukan apa yang kita dapatkan. Kita dapat mendefinisikan __str__()metode di kelas kita yang mengontrol bagaimana objek dicetak. Mari kita lihat bagaimana kita bisa mencapai ini:
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 mari coba print()fungsinya lagi.
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) p1 = Point(2, 3) print(p1)
Keluaran
(2, 3)
Itu lebih baik. Ternyata, metode yang sama ini dipanggil saat kita menggunakan fungsi bawaan str()atau format().
>>> str(p1) '(2,3)' >>> format(p1) '(2,3)'
Jadi, ketika Anda menggunakan str(p1)atau format(p1), Python secara internal memanggil p1.__str__()metode tersebut. Karena itulah namanya, fungsi khusus.
Sekarang mari kita kembali ke kelebihan beban operator.
Membebani + Operator
Untuk membebani +operator, kita perlu mengimplementasikan __add__()fungsi di kelas. Dengan kekuatan besar datanglah tanggung jawab yang besar. Kita bisa melakukan apapun yang kita suka, di dalam fungsi ini. Tetapi lebih masuk akal untuk mengembalikan Pointobjek jumlah koordinat.
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): x = self.x + other.x y = self.y + other.y return Point(x, y)
Sekarang mari kita coba operasi penjumlahan lagi:
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): x = self.x + other.x y = self.y + other.y return Point(x, y) p1 = Point(1, 2) p2 = Point(2, 3) print(p1+p2)
Keluaran
(3,5)
Apa yang sebenarnya terjadi adalah, ketika Anda menggunakan p1 + p2, panggilan Python p1.__add__(p2)yang pada gilirannya adalah Point.__add__(p1,p2). Setelah ini, operasi penjumlahan dilakukan seperti yang kami tentukan.
Demikian pula, kami juga dapat membebani operator lain. Fungsi khusus yang perlu kita implementasikan ditabulasikan di bawah ini.
| Operator | Ekspresi | Secara internal |
|---|---|---|
| Tambahan | p1 + p2 | p1.__add__(p2) |
| Pengurangan | p1 - p2 | p1.__sub__(p2) |
| Perkalian | p1 * p2 | p1.__mul__(p2) |
| Kekuasaan | p1 ** p2 | p1.__pow__(p2) |
| Divisi | p1 / p2 | p1.__truediv__(p2) |
| Divisi Lantai | p1 // p2 | p1.__floordiv__(p2) |
| Sisa (modulo) | p1 % p2 | p1.__mod__(p2) |
| Pergeseran Kiri Bitwise | p1 << p2 | p1.__lshift__(p2) |
| Pergeseran Kanan Bitwise | p1>> p2 | p1.__rshift__(p2) |
| Bitwise DAN | p1 & p2 | p1.__and__(p2) |
| Bitwise ATAU | p1 | p2 | p1.__or__(p2) |
| Bitwise XOR | p1 p2 | p1.__xor__(p2) |
| Bitwise TIDAK | ~p1 | p1.__invert__() |
Operator Perbandingan Beban Berlebih
Python tidak membatasi kelebihan beban operator hanya pada operator aritmatika. Kami juga dapat membebani operator pembanding.
Misalkan kita ingin menerapkan simbol kurang dari <simbol di Pointkelas kita .
Mari kita bandingkan besarnya titik-titik ini dari asalnya dan kembalikan hasilnya untuk tujuan ini. Itu dapat diimplementasikan sebagai berikut.
# overloading the less than operator 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 p1 = Point(1,1) p2 = Point(-2,-3) p3 = Point(1,-1) # use less than print(p1
Output
True False FalseSimilarly, the special functions that we need to implement, to overload other comparison operators are tabulated below.
Operator Expression Internally
Less than p1 < p2p1.__lt__(p2)
Less than or equal to p1 <= p2p1.__le__(p2)
Equal to p1 == p2p1.__eq__(p2)
Not equal to p1 != p2p1.__ne__(p2)
Greater than p1> p2p1.__gt__(p2)
Greater than or equal to p1>= p2p1.__ge__(p2)
