🔥CHỌN LỌC TOP NHỮNG KHOÁ HỌC LẬP TRÌNH ONLINE NHIỀU NGƯỜI THEO HOC TẠI ĐÂY🔥

Nạp chồng (hàm) toán tử (Operator Overloading) có nghĩa là đưa ra những ý nghĩa đã được mở rộng hơn, vượt ra ngoài ý nghĩa được xác định ban đầu về mặt vận hành của một (hàm) toán tử. Ví dụ, toán tử + được sử dụng để cộng hai số nguyên, để nối hai chuỗi lại với nhau, và hợp nhất hai danh sách. Sở dĩ có thể đạt được điều này là do toán tử ‘+’ đã được nạp chồng bởi class int và class str. Bạn có thể đã nhận ra rằng, mặc dù cùng là một toán tử hoặc một hàm đã được tích hợp sẵn, nhưng chúng sẽ có những chức năng khác nhau dành cho các đối tượng thuộc các kiểu class khác nhau, điều này được gọi là nạp chồng toán tử (Operator Overloading).

# Đoạn chương trình Python mô tả cách sử dụng


# Python program to show use of 
# + operator for different purposes. 
  
print(1 + 2) 
  
# concatenate two strings 
print("Cafedevn"+"For")  
  
# Product two numbers 
print(3 * 4) 
  
# Repeat the String 
print("Cafe"*4)

Kết quả in ra là:

3
CafedevnFor
12
CafeCafeCafeCafe

1. Làm thế nào để nạp chồng các toán tử trong ngôn ngữ Python?

Giả sử chúng ta có hai đối tượng thuộc một kiểu class do người dùng tự định nghĩa và chúng ta phải động hai đối tượng này bằng toán tử ‘+’, nếu chúng ta cứ thế mà làm thì chắc chắn trình biên dịch sẽ đưa ra một thông báo lỗi, bởi vì trình biên dịch không biết được cách để cộng hai đối tượng này. Vì vậy, chúng ta sẽ phải tự định nghĩa một phương thức (method) dành cho một toán tử cụ thể, để có thể thu được toán tử hoạt động theo ý mình, quá trình này được gọi là nạp chồng toán tử. Chúng ta có thể nạp chồng tất cả các toán tử hiện có, nhưng không thể tạo ra toán tử mới. Để thực hiện nạp chồng toán tử, Python cung cấp một số hàm đặc biệt hoặc hàm ma thuật (magic function), có khả năng tự động được gọi khi nó được liên kết (associated) với một toán tử cụ thể nào đó. Trong ví dụ dưới đây, khi chúng ta sử dụng toán tử + để cộng hai đối tượng kiểu chuỗi (không phải kiểu int), phương thức ma thuật (magic method) __add__ sẽ tự động được gọi:

Ví dụ 1:

# Đoạn chương trình Python Program minh họacách để nạp chồng một hàm toán tử + hai ngôi  


# Python Program illustrate how  
# to overload an binary + operator 
  
class A: 
    def __init__(self, a): 
        self.a = a 
  
    # adding two objects  
    def __add__(self, o): 
        return self.a + o.a  
ob1 = A(1) 
ob2 = A(2) 
ob3 = A("Cafedevn") 
ob4 = A("For") 
  
print(ob1 + ob2) 
print(ob3 + ob4)

Kết quả in ra là:

3
CafedevnFor

Qua ví dụ 1, bạn có thể thấy rằng, thông qua việc thay đổi phần code bên trong hàm ma thuật, chúng ta có thể cải tiến được chức năng của hàm toán tử + theo ý của mình (một cách hợp lý).

Ví dụ 2:

# -----------------------------------------------------------
#Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
#@author cafedevn
#Contact: cafedevn@gmail.com
#Fanpage: https://www.facebook.com/cafedevn
#Group: https://www.facebook.com/groups/cafedev.vn/
#Instagram: https://instagram.com/cafedevn
#Twitter: https://twitter.com/CafedeVn
#Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
#Pinterest: https://www.pinterest.com/cafedevvn/
#YouTube: https://www.youtube.com/channel/UCE7zpY_SlHGEgo67pHxqIoA/
# -----------------------------------------------------------

# Python Program to perform addition  
# of two complex numbers using binary  
# + operator overloading. 
  
class complex: 
    def __init__(self, a, b): 
        self.a = a 
        self.b = b 
  
     # adding two objects  
    def __add__(self, other): 
        return self.a + other.a, self.b + other.b 
  
    def __str__(self): 
        return self.a, self.b 
  
Ob1 = complex(1, 2) 
Ob2 = complex(2, 3) 
Ob3 = Ob1 + Ob2 
print(Ob3)

Kết quả in ra là:

(3, 5)

Ví dụ 3: Nạp chồng các toán tử so sánh trong Python


# Python program to overload 
# a comparison operators  
  
class A: 
    def __init__(self, a): 
        self.a = a 
    def __gt__(self, other): 
        if(self.a>other.a): 
            return True
        else: 
            return False
ob1 = A(2) 
ob2 = A(3) 
if(ob1>ob2): 
    print("ob1 is greater than ob2") 
else: 
    print("ob2 is greater than ob1")

Kết quả in ra là:

ob2 is greater than ob1

Ví dụ 4: Nạp chồng toán tử bằng và toán tử nhỏ hơn:

# -----------------------------------------------------------
#Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
#@author cafedevn
#Contact: cafedevn@gmail.com
#Fanpage: https://www.facebook.com/cafedevn
#Group: https://www.facebook.com/groups/cafedev.vn/
#Instagram: https://instagram.com/cafedevn
#Twitter: https://twitter.com/CafedeVn
#Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
#Pinterest: https://www.pinterest.com/cafedevvn/
#YouTube: https://www.youtube.com/channel/UCE7zpY_SlHGEgo67pHxqIoA/
# -----------------------------------------------------------

# Python program to overload equality 
# and less than operators 
  
class A: 
    def __init__(self, a): 
        self.a = a 
    def __lt__(self, other): 
        if(self.a<other.a): 
            return "ob1 is lessthan ob2"
        else: 
            return "ob2 is less than ob1"
    def __eq__(self, other): 
        if(self.a == other.a): 
            return "Both are equal"
        else: 
            return "Not equal"
                  
ob1 = A(2) 
ob2 = A(3) 
print(ob1 < ob2) 
  
ob3 = A(4) 
ob4 = A(4) 
print(ob1 == ob2)

Kết quả in ra là:

ob1 is lessthan ob2
Not equal

2. Danh sách các phương thức ma thuật hoặc hàm đặc biệt dành cho nạp chồng toán tử trong Python:

– Các toán tử hai ngôi (Binary Operators):

Toán tửPhương thức ma thuật (magic method)
+__add__(self, other)
–__sub__(self, other)
*__mul__(self, other)
/__truediv__(self, other)
//__floordiv__(self, other)
%__mod__(self, other)
**__pow__(self, other)

– Các toán tử so sánh:

Toán tửPhương thức ma thuật (magic method)
<__lt__(self, other)
>__gt__(self, other)
<=__le__(self, other)
>=__ge__(self, other)
==__eq__(self, other)
!=__ne__(self, other)

– Các toán tử gán:

Toán tửPhương thức ma thuật (magic method)
-=__isub__(self, other)
+=__iadd__(self, other)
*=__imul__(self, other)
/=__idiv__(self, other)
//=__ifloordiv__(self, other)
%=__imod__(self, other)
**=__ipow__(self, other)

– Các toán tử ba ngôi (Unary Operators):

Toán tửPhương thức ma thuật (magic method)
–__neg__(self, other)
+__pos__(self, other)
~__invert__(self, other)

Nếu bạn thấy hay và hữu ích, bạn có thể tham gia các kênh sau của cafedev để nhận được nhiều hơn nữa:

Chào thân ái và quyết thắng!

Đăng ký kênh youtube để ủng hộ Cafedev nha các bạn, Thanks you!

BÀI VIẾT LIÊN QUANXEM THÊM