Anda boleh mengubah makna pengendali di Python bergantung pada operasi yang digunakan. Dalam tutorial ini, anda akan belajar bagaimana menggunakan overloading operator dalam Python Object Oriented Programming.
Lebihan Operator Python
Pengendali Python bekerja untuk kelas terbina dalam. Tetapi pengendali yang sama berkelakuan berbeza dengan pelbagai jenis. Sebagai contoh, +pengendali akan melakukan penambahan aritmetik pada dua nombor, menggabungkan dua senarai, atau menggabungkan dua rentetan.
Ciri ini di Python yang membolehkan pengendali yang sama mempunyai makna yang berbeza sesuai dengan konteks yang disebut operator overloading.
Jadi apa yang berlaku apabila kita menggunakannya dengan objek kelas yang ditentukan pengguna? Mari kita pertimbangkan kelas berikut, yang cuba 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)
Pengeluaran
Traceback (panggilan terakhir terakhir): File "", baris 9, dalam bentuk cetak (p1 + p2) TypeError: jenis operan yang tidak disokong untuk +: 'Point' dan 'Point'
Di sini, kita dapat melihat bahawa TypeErroritu dibangkitkan, kerana Python tidak tahu bagaimana menambah dua Pointobjek bersama-sama.
Walau bagaimanapun, kita dapat mencapai tugas ini di Python melalui pembebanan operator yang berlebihan. Tetapi pertama, mari kita fahami tentang fungsi khas.
Fungsi Khas Python
Fungsi kelas yang bermula dengan garis bawah ganda __disebut fungsi khas di Python.
Fungsi-fungsi ini bukan fungsi khas yang kita tentukan untuk kelas. Yang __init__()fungsi kita yang ditakrifkan di atas adalah salah satu daripada mereka. Ia dipanggil setiap kali kita membuat objek baru kelas itu.
Terdapat banyak fungsi khas lain di Python. Lawati Fungsi Khas Python untuk mengetahui lebih lanjut mengenainya.
Dengan menggunakan fungsi khas, kita dapat menjadikan kelas kita serasi dengan fungsi terbina dalam.
>>> p1 = Point(2,3) >>> print(p1)
Katakan kita mahu print()fungsi mencetak koordinat Pointobjek dan bukannya apa yang kita dapat. Kami dapat menentukan __str__()kaedah di kelas kami yang mengawal bagaimana objek dicetak. Mari lihat bagaimana kita dapat mencapainya:
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 kita cuba 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)
Pengeluaran
(2, 3)
Itu lebih baik. Ternyata, kaedah yang sama ini digunakan ketika kita menggunakan fungsi bawaan str()atau format().
>>> str(p1) '(2,3)' >>> format(p1) '(2,3)'
Oleh itu, semasa anda menggunakan str(p1)atau format(p1), Python secara dalaman memanggil p1.__str__()kaedah tersebut. Oleh itu namanya, fungsi khas.
Sekarang mari kita kembali kepada pembebanan operator yang berlebihan.
Membebani Operator +
Untuk membebani +operator, kita perlu melaksanakan __add__()fungsi di kelas. Dengan kekuatan yang besar datang tanggungjawab yang besar. Kita boleh melakukan apa sahaja yang kita mahu, di dalam fungsi ini. Tetapi lebih masuk akal untuk mengembalikan Pointobjek dari 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 cuba operasi penambahan sekali 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)
Pengeluaran
(3,5)
Apa yang sebenarnya berlaku ialah, apabila anda menggunakan p1 + p2, panggilan Python p1.__add__(p2)yang seterusnya adalah Point.__add__(p1,p2). Selepas ini, operasi penambahan dijalankan seperti yang kita tentukan.
Begitu juga, kita juga boleh membebani operator lain Fungsi khas yang perlu kita laksanakan dibentangkan di bawah.
| Pengendali | Ungkapan | Secara dalaman |
|---|---|---|
| Penambahan | p1 + p2 | p1.__add__(p2) |
| Penolakan | p1 - p2 | p1.__sub__(p2) |
| Pendaraban | p1 * p2 | p1.__mul__(p2) |
| Kuasa | p1 ** p2 | p1.__pow__(p2) |
| Bahagian | p1 / p2 | p1.__truediv__(p2) |
| Bahagian Lantai | p1 // p2 | p1.__floordiv__(p2) |
| Kekal (modulo) | p1 % p2 | p1.__mod__(p2) |
| Anjakan Kiri Bitwise | p1 << p2 | p1.__lshift__(p2) |
| Pergeseran Kanan Bitwise | p1>> p2 | p1.__rshift__(p2) |
| Sedikit demi sedikit DAN | p1 & p2 | p1.__and__(p2) |
| Sedikit demi sedikit ATAU | p1 | p2 | p1.__or__(p2) |
| Bitwise XOR | p1 p2 | p1.__xor__(p2) |
| Sedikit demi sedikit TIDAK | ~p1 | p1.__invert__() |
Pengendali Perbandingan Berlebihan
Python tidak mengehadkan beban operator yang berlebihan kepada pengendali aritmetik sahaja. Kami juga boleh membebani operator perbandingan.
Katakan kita mahu menerapkan simbol <simbol yang kurang daripada di Pointkelas kita .
Mari kita bandingkan besarnya titik-titik ini dari asal dan mengembalikan hasilnya untuk tujuan ini. Ia dapat dilaksanakan seperti 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)
