Từ quá tải có nghĩa là nạp quá nhiều vào hoặc lên một thứ gì đó, chẳng hạn như quá tải điện làm chập mạch. Theo cách tương tự, Quá tải đề cập đến khả năng một đối tượng có thể có nhiều hành vi. Quá tải là một trong những tính năng vượt trội của OOPS
Tại sao chúng ta nên sử dụng Overloading?Quá tải hàm là khả năng có nhiều hàm có cùng tên nhưng có chữ ký/cách triển khai khác nhau. Khi một hàm bị quá tải
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
Trong ví dụ trên [được viết bằng C++], hàm
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Tại sao không có chức năng quá tải trong Python?
Python không hỗ trợ nạp chồng hàm. Khi chúng ta định nghĩa nhiều hàm có cùng tên, hàm sau luôn ghi đè lên hàm trước và do đó, trong không gian tên, sẽ luôn có một mục duy nhất đối với mỗi tên hàm. Chúng tôi thấy những gì tồn tại trong các không gian tên Python bằng cách gọi các hàm
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Gọi hàm
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Chúng tôi biết cách Python quản lý các không gian tên và nếu chúng tôi muốn thực hiện quá tải chức năng, chúng tôi sẽ cần phải
- quản lý các định nghĩa hàm trong một không gian tên ảo được duy trì
- tìm cách gọi hàm thích hợp theo các đối số được truyền cho nó
Để đơn giản, chúng ta sẽ thực hiện nạp chồng hàm trong đó các hàm có cùng tên được phân biệt bằng số đối số mà nó chấp nhận
Bao hàm chức năng
Chúng tôi tạo một lớp có tên là
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
Trong đoạn mã trên, hàm
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
- mô-đun chức năng
- lớp mà hàm thuộc về
- tên của chức năng
- số đối số mà hàm chấp nhận
Phương thức
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
Trong ví dụ trên, hàm
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
Ví dụ này cũng cho thấy cách chúng ta có thể gọi thể hiện
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Xây dựng Namespace ảo
Không gian tên ảo, chúng tôi xây dựng ở đây, sẽ lưu trữ tất cả các chức năng chúng tôi thu thập được trong giai đoạn định nghĩa. Vì chỉ có một không gian tên/cơ quan đăng ký nên chúng tôi tạo một lớp đơn chứa các hàm trong từ điển có khóa không chỉ là tên hàm mà là bộ chúng tôi nhận được từ hàm
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Sử dụng đồ trang trí như một cái móc
Bây giờ chúng ta đã xác định một không gian tên ảo với khả năng đăng ký một hàm, chúng ta cần một hook được gọi trong khi định nghĩa hàm; . Trong Python, một trình trang trí bao bọc một chức năng và cho phép chúng tôi thêm chức năng mới vào chức năng hiện có mà không sửa đổi cấu trúc của nó. Một trình trang trí chấp nhận hàm bao bọc
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Một trình trang trí mẫu có thời gian thực thi một chức năng được trình bày bên dưới
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Trong ví dụ trên, chúng tôi xác định một trình trang trí có tên là
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Hàm trang trí
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Trình trang trí
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Tìm đúng chức năng từ không gian tên
Phạm vi định hướng, ngoài tên và lớp mô-đun thông thường, là số lượng đối số mà hàm chấp nhận và do đó chúng tôi định nghĩa một phương thức có tên là
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Vai trò của hàm
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Hàm
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
Gọi hàm
Như đã nêu ở trên, phương thức
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
int area[int length, int breadth] {
return length * breadth;
}
float area[int radius] {
return 3.14 * radius * radius;
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Phương thức tìm nạp hàm thích hợp từ không gian tên ảo và nếu nó không tìm thấy bất kỳ hàm nào, nó sẽ đưa ra một
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Quá tải chức năng trong hành động
Khi tất cả mã được đặt vào vị trí, chúng tôi xác định hai chức năng có tên là
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Khi chúng ta gọi
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Python không hỗ trợ nạp chồng hàm nhưng bằng cách sử dụng các cấu trúc ngôn ngữ phổ biến, chúng tôi đã hack một giải pháp cho nó. Chúng tôi đã sử dụng các trình trang trí và một không gian tên do người dùng duy trì để quá tải các hàm và sử dụng số lượng đối số làm yếu tố định hướng. Chúng ta cũng có thể sử dụng các kiểu dữ liệu [được xác định trong trình trang trí] của các đối số để định hướng - cho phép các hàm có cùng số lượng đối số nhưng khác kiểu quá tải. Độ chi tiết của tình trạng quá tải chỉ bị giới hạn bởi chức năng
def area[radius]:
return 3.14 * radius ** 2
>>> locals[]
{
...
'area': ,
...
}
Bài viết này ban đầu được xuất bản trên blog của tôi - Hàm quá tải trong Python
Nếu bạn thích những gì bạn đọc, hãy đăng ký nhận bản tin của tôi và nhận bài đăng được gửi trực tiếp vào hộp thư đến của bạn và gửi lời cảm ơn tới tôi @arpit_bhayani
con trăn
Bài báo cáo
Thưởng thức bài viết này?
10
Chia sẻ
Arpit Bhayani
Phần phụ trợ @Unacademy • Dữ liệu @Amazon • Nền tảng @Practo. Viết về Ngôn ngữ bên trong và Toán học trong Khoa học Máy tính
Tôi là một lập trình viên đam mê, đam mê viết mã, thiết kế, khởi nghiệp và công nghệ. Hiện tại tôi đang làm việc tại Amazon với vị trí Kỹ sư phát triển phần mềm 2. Trước Amazon, tôi đang làm việc cho một công ty khởi nghiệp về chăm sóc sức khỏe tên là Practo, nơi tôi độc thân
Theo
Khám phá và đọc thêm các bài viết từ Arpit Bhayani
bắt đầu
Thưởng thức bài viết này?
Để lại một lượt thích và bình luận cho Arpit
10
Gửi đi
yotamolik
một năm trước
có thể nó giống một câu hỏi triết học hơn - nhưng tại sao Python không bị quá tải ngay từ đầu?
Hồi đáp
Daniel Riggs
một năm trước
Kể từ trăn 3. 8, một trình trang trí quá tải có sẵn trong thư viện tiêu chuẩn.
Ngoài ra còn có funcools. singledispatch có thể làm điều tương tự. https. // tài liệu. con trăn. org/3/library/funcools. html
Tôi không chắc liệu chúng có bao gồm mọi thứ bạn viết ở đây hay không, nhưng sẽ rất tuyệt nếu nói về lý do tại sao các tùy chọn thư viện tiêu chuẩn này không đủ [nếu không]