Kelebihan Operator Python

Operator Python Kelebihan Beban

Anda dapat mengubah arti operator di Python tergantung pada operan yang digunakan. Dalam tutorial ini, Anda akan belajar bagaimana menggunakan operator overloading di Python Object Oriented Programming.

Kelebihan Beban 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 yang memungkinkan operator yang sama memiliki arti yang berbeda sesuai dengan konteksnya disebut operator overloading.

Jadi apa yang terjadi ketika kita menggunakannya dengan objek dari kelas yang ditentukan pengguna? Mari kita perhatikan kelas berikut, yang mencoba mensimulasikan sebuah 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 (most recent call last):
  File "<string>", line 9, in <module>
    print(p1+p2)
TypeError: unsupported operand type(s) for +: 'Point' and 'Point'

Di sini, kita dapat melihat bahwa TypeError dibesarkan, karena Python tidak tahu cara menambahkan dua Point objek bersama-sama.

Namun, kita dapat mencapai tugas ini dengan Python melalui kelebihan beban operator. Tapi pertama-tama, mari kita pahami tentang fungsi khusus.

---

Fungsi Khusus Python

Fungsi kelas yang dimulai dengan garis bawah ganda __ disebut fungsi khusus dalam Python.

Fungsi-fungsi ini bukanlah fungsi tipikal yang kita definisikan untuk sebuah kelas. __init__() fungsi yang kami definisikan 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 mempelajari lebih lanjut tentangnya.

Dengan menggunakan fungsi khusus, kita dapat membuat kelas kita kompatibel dengan fungsi bawaan.

>>> p1 = Point(2,3)
>>> print(p1)
<__main__.Point object at 0x00000000031F8CC0>

Misalkan kita menginginkan print() berfungsi untuk mencetak koordinat Point objek alih-alih apa yang kita dapatkan. Kita dapat mendefinisikan __str__() metode di kelas kami yang mengontrol bagaimana objek akan dicetak. Mari kita lihat bagaimana kita bisa 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 coba print() berfungsi 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. Karenanya namanya, fungsi khusus.

Sekarang mari kembali ke operator overloading.

---

Membebani + Operator

Untuk membebani + operator, kita perlu mengimplementasikan __add__() fungsi di dalam kelas. Dengan kekuatan besar datang tanggung jawab besar. Kita bisa melakukan apapun yang kita suka, di dalam fungsi ini. Tetapi lebih masuk akal untuk mengembalikan Point objek 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 , Python memanggil p1.__add__(p2) yang selanjutnya adalah Point.__add__(p1,p2) . Setelah ini, operasi penambahan dilakukan dengan cara yang kami tentukan.

Demikian pula, kita juga dapat membebani operator lain. Fungsi khusus yang perlu kita implementasikan ditabulasikan di bawah ini.

Operator	Ekspresi	Secara internal
Penambahan	p1 + p2	p1.__add__(p2)
Pengurangan	p1 - p2	p1.__sub__(p2)
Perkalian	p1 * p2	p1.__mul__(p2)
Kekuatan	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 Sedikit demi sedikit	p1 << p2	p1.__lshift__(p2)
Pergeseran Bitwise Kanan	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)
Sedikit TIDAK	~p1	p1.__invert__()

---

Operator Perbandingan Kelebihan Beban

Python tidak membatasi overloading operator ke operator aritmatika saja. Kami juga dapat membebani operator perbandingan.

Misalkan kita ingin menerapkan kurang dari simbol < simbol di Point . kami kelas.

Mari kita bandingkan besarnya titik-titik ini dari titik asal dan kembalikan hasilnya untuk tujuan ini. Ini 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<p2)
print(p2<p3)
print(p1<p3)

Keluaran

True
False
False

Demikian pula, fungsi khusus yang perlu kita terapkan, untuk membebani operator perbandingan lainnya ditabulasikan di bawah ini.

Operator	Ekspresi	Secara internal
Kurang dari	p1 < p2	p1.__lt__(p2)
Kurang dari atau sama dengan	p1 <= p2	p1.__le__(p2)
Sama dengan	p1 == p2	p1.__eq__(p2)
Tidak sama dengan	p1 != p2	p1.__ne__(p2)
Lebih besar dari	p1 > p2	p1.__gt__(p2)
Lebih besar dari atau sama dengan	p1 >= p2	p1.__ge__(p2)