Các kiểu dữ liệu trong C ( int - float - double - char ...) 
Thuật toán tìm ước chung lớn nhất trong C/C++ 
Cấu trúc lệnh switch case trong C++ (có bài tập thực hành) 
ComboBox - ListBox trong lập trình C# winforms 
Random trong Python: Tạo số random ngẫu nhiên 
Lệnh cin và cout trong C++ 
Cách khai báo biến trong PHP, các loại biến thường gặp 
Download và cài đặt Vertrigo Server 
Thẻ li trong HTML 
Thẻ article trong HTML5 
Cấu trúc HTML5: Cách tạo template HTML5 đầu tiên 
Cách dùng thẻ img trong HTML và các thuộc tính của img 
Thẻ a trong HTML và các thuộc tính của thẻ a thường dùng Thông báo: Download 4 khóa học Python từ cơ bản đến nâng cao tại đây.
Tìm hiểu về nạp chồng toán tử trong Python
Trong Python, nạp chồng toán tử (operator overloading) là một kỹ thuật cao cho phép bạn mở rộng các toán tử mặc định như +, -, *, += để chúng hoạt động với các đối tượng do bạn định nghĩa. Điều này giúp mã nguồn trở nên ngắn gọn, trực quan và dễ hiểu hơn khi xử lý các đối tượng phức tạp. Trong bài viết này, bạn sẽ tìm hiểu cách nạp chồng toán tử để đối tượng của bạn có thể tương tác với các toán tử có sẵn một cách tự nhiên và linh hoạt.
Giới thiệu về nạp chồng toán tử trong Python
Giả sử bạn có một lớp Point2D biểu diễn tọa độ x và y của một điểm trong không gian 2D như sau:
class Point2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f'({self.x},{self.y})'
Để cộng hai đối tượng Point2D, bạn có thể định nghĩa một phương thức add() như sau:
class Point2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f'({self.x},{self.y})'
def add(self, point):
if not isinstance(point, Point2D):
raise ValueError('Đối tượng được cộng phải là một instance của Point2D')
return Point2D(self.x + point.x, self.y + point.y)
Phương thức add() này sẽ kiểm tra xem đối tượng truyền vào có phải là một instance của lớp Point2D hay không. Nếu đúng, nó sẽ trả về một đối tượng Point2D mới với các giá trị x và y là tổng của hai điểm.
Bài viết này được đăng tại [free tuts .net]
Dưới đây là ví dụ sử dụng phương thức add() để cộng hai điểm:
a = Point2D(10, 20) b = Point2D(15, 25) c = a.add(b) print(c) # Output: (25,45)
Mặc dù cách này hoạt động tốt, nhưng Python cung cấp một cách tốt hơn là sử dụng toán tử +. Bạn có thể nạp chồng toán tử + để thay thế cho phương thức add():
c = a + b
Khi bạn sử dụng toán tử + trên đối tượng Point2D, Python sẽ gọi phương thức đặc biệt __add__() trên đối tượng đó. Hai cách gọi sau đây là tương đương:
c = a + b c = a.__add__(b)
Phương thức __add__() phải trả về một instance mới của đối tượng Point2D.
Khả năng sử dụng các toán tử có sẵn trên các kiểu dữ liệu tùy chỉnh được gọi là nạp chồng toán tử.
Dưới đây là cách nạp chồng toán tử + trong lớp Point2D:
class Point2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f'({self.x},{self.y})'
def __add__(self, point):
if not isinstance(point, Point2D):
raise ValueError('Đối tượng được cộng phải là một instance của Point2D')
return Point2D(self.x + point.x, self.y + point.y)
if __name__ == '__main__':
a = Point2D(10, 20)
b = Point2D(15, 25)
c = a + b
print(c) # Output: (25,45)
Các phương thức đặc biệt cho nạp chồng toán tử trong Python
Dưới đây là bảng liệt kê các toán tử và phương thức đặc biệt tương ứng:
| Toán tử | Phương thức đặc biệt |
|---|---|
| + | __add__(self, other) |
| – | __sub__(self, other) |
| * | __mul__(self, other) |
| / | __truediv__(self, other) |
| // | __floordiv__(self, other) |
| % | __mod__(self, other) |
| ** | __pow__(self, other) |
| >> | __rshift__(self, other) |
| << | __lshift__(self, other) |
| & | __and__(self, other) |
| | | __or__(self, other) |
| ^ | __xor__(self, other) |
Ví dụ, để hỗ trợ phép trừ giữa hai điểm, bạn có thể định nghĩa phương thức __sub__() như sau:
class Point2D:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f'({self.x},{self.y})'
def __add__(self, point):
if not isinstance(point, Point2D):
raise ValueError('Đối tượng phải là instance của Point2D')
return Point2D(self.x + point.x, self.y + point.y)
def __sub__(self, other):
if not isinstance(other, Point2D):
raise ValueError('Đối tượng phải là instance của Point2D')
return Point2D(self.x - other.x, self.y - other.y)
if __name__ == '__main__':
a = Point2D(10, 20)
b = Point2D(15, 25)
c = b - a
print(c) # Output: (5,5)
Nạp chồng toán tử nội tại trong Python
Một số toán tử có phiên bản nội tại, ví dụ, phiên bản nội tại của + là +=.
- Đối với các kiểu dữ liệu bất biến (immutable) như tuple, string, số, các toán tử nội tại thực hiện phép tính và không gán lại kết quả cho đối tượng ban đầu.
- Đối với các kiểu dữ liệu có thể thay đổi (mutable), toán tử nội tại cập nhật trực tiếp trên đối tượng ban đầu mà không cần gán lại.
Python cũng cung cấp danh sách các phương thức đặc biệt để nạp chồng toán tử nội tại:
| Toán tử | Phương thức đặc biệt |
|---|---|
| += | __iadd__(self, other) |
| -= | __isub__(self, other) |
| *= | __imul__(self, other) |
| /= | __itruediv__(self, other) |
| //= | __ifloordiv__(self, other) |
| %= | __imod__(self, other) |
| **= | __ipow__(self, other) |
| >>= | __irshift__(self, other) |
| <<= | __ilshift__(self, other) |
| &= | __iand__(self, other) |
| |= | __ior__(self, other) |
| ^= | __ixor__(self, other) |
Ví dụ, để nạp chồng toán tử +=, giả sử bạn có một giỏ hàng (Cart) và muốn thêm sản phẩm vào giỏ hàng như sau:
cart += item
Để hỗ trợ toán tử +=, bạn cần định nghĩa phương thức đặc biệt __iadd__() trong lớp Cart.
Đầu tiên, định nghĩa lớp Item với các thuộc tính name, qty (số lượng), và price. Lớp này có một thuộc tính amount trả về thành tiền của sản phẩm:
class Item:
def __init__(self, name, qty, price):
self.name = name
self.qty = qty
self.price = price
@property
def amount(self):
return self.qty * self.price
def __str__(self):
return f'{self.name} {self.qty} ${self.price} ${self.amount}'
Tiếp theo, định nghĩa lớp Cart và triển khai phương thức __iadd__():
class Cart:
def __init__(self):
self.items = []
def __iadd__(self, item):
if not isinstance(item, Item):
raise ValueError('Sản phẩm phải là một instance của Item')
self.items.append(item)
return self
@property
def total(self):
return sum([item.amount for item in self.items])
def __str__(self):
if not self.items:
return 'Giỏ hàng rỗng'
return '\n'.join([str(item) for item in self.items])
Cuối cùng, sử dụng toán tử += để thêm sản phẩm vào giỏ hàng:
if __name__ == '__main__':
cart = Cart()
cart += Item('Táo', 5, 2)
cart += Item('Chuối', 20, 1)
cart += Item('Cam', 10, 1.5)
print(cart)
print('-' * 30)
print('Tổng cộng: $', cart.total)
Kết quả đầu ra:
Táo 5 $2 $10 Chuối 20 $1 $20 Cam 10 $1.5 $15.0 ------------------------------ Tổng cộng: $ 45.0
