英文：https://arpitbhayani.me/blogs/function-overloading
作者：arprit
譯者：豌豆花下貓（“Python貓”公眾號作者）
宣告：本翻譯是出于交流學習的目的，基于 CC BY-NC-SA 4.0 授權協議，為便于閱讀，內容略有改動，
函式多載指的是有多個同名的函式，但是它們的簽名或實作卻不同，當呼叫一個多載函式 fn 時，程式會檢驗傳遞給函式的實參/形參，并據此而呼叫相應的實作，
int area(int length, int breadth) {
return length * breadth;
}
float area(int radius) {
return 3.14 * radius * radius;
}
在以上例子中（用 c++ 撰寫），函式 area 被多載了兩個實作，第一個函式接收兩個引數（都是整數），表示矩形的長度和寬度，并回傳矩形的面積，另一個函式只接收一個整型引數，表示圓的半徑，
當我們像 area(7) 這樣呼叫函式 area 時，它會呼叫第二個函式，而 area(3,4) 則會呼叫第一個函式，
為什么 Python 中沒有函式多載？
Python 不支持函式多載，當我們定義了多個同名的函式時，后面的函式總是會覆寫前面的函式，因此，在一個命名空間中，每個函式名僅會有一個登記項（entry），
Python貓注：這里說 Python 不支持函式多載，指的是在不用語法糖的情況下，使用 functools 庫的 singledispatch 裝飾器，Python 也可以實作函式多載，原文作者在文末的注釋中專門提到了這一點，
通過呼叫 locals() 和 globals() 函式，我們可以看到 Python 的命名空間中有什么，它們分別回傳區域和全域命名空間，
def area(radius):
return 3.14 * radius ** 2
>>> locals()
{
...
'area': <function area at 0x10476a440>,
...
}
在定義一個函式后，接著呼叫 locals() 函式，我們會看到它回傳了一個字典，包含了定義在區域命名空間中的所有變數，字典的鍵是變數的名稱，值是該變數的參考/值，
當程式在運行時，若遇到另一個同名函式，它就會更新區域命名空間中的登記項，從而消除兩個函式共存的可能性，因此 Python 不支持函式多載，這是在創造語言時做出的設計決策，但這并不妨礙我們實作它，所以，讓我們來多載一些函式吧，
在 Python 中實作函式多載
我們已經知道 Python 是如何管理命名空間的，如果想要實作函式多載，就需要這樣做：
- 維護一個虛擬的命名空間，在其中管理函式定義
- 根據每次傳遞的引數，設法呼叫適當的函式
為了簡單起見，我們在實作函式多載時，通過不同的引數數量來區分同名函式，
把函式封裝起來
我們創建了一個名為Function的類，它可以封裝任何函式，并通過重寫的__call__方法來呼叫該函式，還提供了一個名為key的方法，該方法回傳一個元組，使該函式在整個代碼庫中是唯一的，
from inspect import getfullargspec
class Function(object):
"""Function類是對標準的Python函式的封裝"""
def __init__(self, fn):
self.fn = fn
def __call__(self, *args, **kwargs):
"""當像函式一樣被呼叫時，它就會呼叫被封裝的函式，并回傳該函式的回傳值"""
return self.fn(*args, **kwargs)
def key(self, args=None):
"""回傳一個key，能唯一標識出一個函式（即便是被多載的）"""
# 如果不指定args，則從函式的定義中提取引數
if args is None:
args = getfullargspec(self.fn).args
return tuple([
self.fn.__module__,
self.fn.__class__,
self.fn.__name__,
len(args or []),
])
在上面的代碼片段中，key函式回傳一個元組，該元組唯一標識了代碼庫中的函式，并且記錄了：
- 函式所屬的模塊
- 函式所屬的類
- 函式名
- 函式接收的引數量
被重寫的__call__方法會呼叫被封裝的函式，并回傳計算的值（這沒有啥特別的），這使得Function的實體可以像函式一樣被呼叫，并且它的行為與被封裝的函式完全一樣，
def area(l, b):
return l * b
>>> func = Function(area)
>>> func.key()
('__main__', <class 'function'>, 'area', 2)
>>> func(3, 4)
12
在上面的例子中，函式area被封裝在Function中，并被實體化成func，key() 回傳一個元組，其第一個元素是模塊名__main__，第二個是類<class 'function'>，第三個是函式名area，而第四個則是該函式接收的引數數量，即 2，
這個示例還顯示出，我們可以像呼叫普通的 area函式一樣，去呼叫實體 func，當傳入引數 3 和 4時，得到的結果是 12，這正是呼叫 area(3,4) 時會得到的結果，當我們接下來運用裝飾器時，這種行為將會派上用場，
構建虛擬的命名空間
我們要創建一個虛擬的命名空間，用于存盤在定義階段收集的所有函式，
由于只有一個命名空間/注冊表，我們創建了一個單例類，并把函式保存在字典中，該字典的鍵不是函式名，而是我們從 key 函式中得到的元組，該元組包含的元素能唯一標識出一個函式，
通過這樣，我們就能在注冊表中保存所有的函式，即使它們有相同的名稱（但不同的引數），從而實作函式多載，
class Namespace(object):
"""Namespace是一個單例類，負責保存所有的函式"""
__instance = None
def __init__(self):
if self.__instance is None:
self.function_map = dict()
Namespace.__instance = self
else:
raise Exception("cannot instantiate a virtual Namespace again")
@staticmethod
def get_instance():
if Namespace.__instance is None:
Namespace()
return Namespace.__instance
def register(self, fn):
"""在虛擬的命名空間中注冊函式，并回傳Function類的可呼叫實體"""
func = Function(fn)
self.function_map[func.key()] = fn
return func
Namespace類有一個register方法，該方法將函式 fn 作為引數，為其創建一個唯一的鍵，并將函式存盤在字典中，最后回傳封裝了 fn 的Function的實體，這意味著 register 函式的回傳值也是可呼叫的，并且（到目前為止）它的行為與被封裝的函式 fn 完全相同，
def area(l, b):
return l * b
>>> namespace = Namespace.get_instance()
>>> func = namespace.register(area)
>>> func(3, 4)
12
使用裝飾器作為鉤子
既然已經定義了一個能夠注冊函式的虛擬命名空間，那么，我們還需要一個鉤子來在函式定義期間呼叫它，在這里，我們會使用 Python 裝飾器，
在 Python 中，裝飾器用于封裝一個函式，并允許我們在不修改該函式的結構的情況下，向其添加新功能，裝飾器把被裝飾的函式 fn 作為引數，并回傳一個新的函式，用于實際的呼叫，新的函式會接收原始函式的 args 和 kwargs，并回傳最終的值，
以下是一個裝飾器的示例，演示了如何給函式添加計時功能，
import time
def my_decorator(fn):
"""這是一個自定義的函式，可以裝飾任何函式，并列印其執行程序的耗時"""
def wrapper_function(*args, **kwargs):
start_time = time.time()
# 呼叫被裝飾的函式，并獲取其回傳值
value = https://www.cnblogs.com/pythonista/archive/2021/06/27/fn(*args, **kwargs)
print("the function execution took:", time.time() - start_time, "seconds")
# 回傳被裝飾的函式的呼叫結果
return value
return wrapper_function
@my_decorator
def area(l, b):
return l * b
>>> area(3, 4)
the function execution took: 9.5367431640625e-07 seconds
12
在上面的例子中，我們定義了一個名為 my_decorator 的裝飾器，它封裝了函式 area，并在標準輸出上列印出執行 area 所需的時間，
每當解釋器遇到一個函式定義時，就會呼叫裝飾器函式 my_decorator（用它封裝被裝飾的函式，并將封裝后的函式存盤在 Python 的區域或全域命名空間中），對于我們來說，它是在虛擬命名空間中注冊函式的理想鉤子，
因此，我們創建了名為overload的裝飾器，它能在虛擬命名空間中注冊函式，并回傳一個可呼叫物件，
def overload(fn):
"""用于封裝函式，并回傳Function類的一個可呼叫物件"""
return Namespace.get_instance().register(fn)
overload裝飾器借助命名空間的 .register() 函式，回傳 Function 的一個實體，現在，無論何時呼叫函式（被 overload 裝飾的），它都會呼叫由 .register() 函式所回傳的函式——Function 的一個實體，其 call 方法會在呼叫期間使用指定的 args 和 kwargs 執行，
現在剩下的就是在 Function 類中實作__call__方法，使得它能根據呼叫期間傳入的引數而呼叫相應的函式，
從命名空間中找到正確的函式
想要區別出不同的函式，除了通常的模塊、類和函式名以外，還可以依據函式的引數數量，因此，我們在虛擬的命名空間中定義了一個 get 方法，它會從 Python 的命名空間中讀取待區分的函式以及實參，最后依據引數的不同，回傳出正確的函式，我們沒有更改 Python 的默認行為，因此在原生的命名空間中，同名的函式只有一個，
這個 get 函式決定了會呼叫函式的哪個實作（如果多載了的話），找到正確的函式的程序非常簡單——先使用 key 方法，它利用函式和引數來創建出唯一的鍵（正如注冊時所做的那樣），接著查找這個鍵是否存在于函式注冊表中；如果存在，則獲取其映射的實作，
def get(self, fn, *args):
"""從虛擬命名空間中回傳匹配到的函式，如果沒找到匹配，則回傳None"""
func = Function(fn)
return self.function_map.get(func.key(args=args))
get 函式創建了 Function 類的一個實體，這樣就可以復用類的 key 函式來獲得一個唯一的鍵，而不用再寫創建鍵的邏輯，然后，這個鍵將用于從函式注冊表中獲取正確的函式，
實作函式的呼叫
前面說過，每次呼叫被 overload 裝飾的函式時，都會呼叫 Function 類中的__call__方法，我們需要讓__call__方法從命名空間的 get 函式中，獲取出正確的函式，并呼叫之，
__call__方法的實作如下：
def __call__(self, *args, **kwargs):
"""重寫能讓類的實體變可呼叫物件的__call__方法"""
# 依據引數，從虛擬命名空間中獲取將要呼叫的函式
fn = Namespace.get_instance().get(self.fn, *args)
if not fn:
raise Exception("no matching function found.")
# 呼叫被封裝的函式，并回傳呼叫的結果
return fn(*args, **kwargs)
該方法從虛擬命名空間中獲取正確的函式，如果沒有找到任何函式，它就拋出一個 Exception，如果找到了，就會呼叫該函式，并回傳呼叫的結果，
運用函式多載
準備好所有代碼后，我們定義了兩個名為 area 的函式：一個計算矩形的面積，另一個計算圓的面積，下面定義了兩個函式，并使用overload裝飾器進行裝飾，
@overload
def area(l, b):
return l * b
@overload
def area(r):
import math
return math.pi * r ** 2
>>> area(3, 4)
12
>>> area(7)
153.93804002589985
當我們用一個引數呼叫 area 時，它回傳了一個圓的面積，當我們傳遞兩個引數時，它會呼叫計算矩形面積的函式，從而實作了函式 area 的多載，
原作者注：從 Python 3.4 開始，Python 的 functools.singledispatch 支持函式多載，從 Python 3.8 開始，functools.singledispatchmethod 支持多載類和實體方法，感謝 Harry Percival 的指正，
總結
Python 不支持函式多載，但是通過使用它的基本結構，我們搗鼓了一個解決方案，
我們使用裝飾器和虛擬的命名空間來多載函式，并使用引數的數量作為區別函式的因素，我們還可以根據引數的型別（在裝飾器中定義）來區別函式——即多載那些引數數量相同但引數型別不同的函式，
多載能做到什么程度，這僅僅受限于getfullargspec函式和我們的想象，使用前文的思路，你可能會實作出一個更整潔、更干凈、更高效的方法，所以，請嘗試實作一下吧，
正文到此結束，以下附上完整的代碼：
# 模塊：overload.py
from inspect import getfullargspec
class Function(object):
"""Function is a wrap over standard python function
An instance of this Function class is also callable
just like the python function that it wrapped.
When the instance is "called" like a function it fetches
the function to be invoked from the virtual namespace and then
invokes the same.
"""
def __init__(self, fn):
self.fn = fn
def __call__(self, *args, **kwargs):
"""Overriding the __call__ function which makes the
instance callable.
"""
# fetching the function to be invoked from the virtual namespace
# through the arguments.
fn = Namespace.get_instance().get(self.fn, *args)
if not fn:
raise Exception("no matching function found.")
# invoking the wrapped function and returning the value.
return fn(*args, **kwargs)
def key(self, args=None):
"""Returns the key that will uniquely identifies
a function (even when it is overloaded).
"""
if args is None:
args = getfullargspec(self.fn).args
return tuple([
self.fn.__module__,
self.fn.__class__,
self.fn.__name__,
len(args or []),
])
class Namespace(object):
"""Namespace is the singleton class that is responsible
for holding all the functions.
"""
__instance = None
def __init__(self):
if self.__instance is None:
self.function_map = dict()
Namespace.__instance = self
else:
raise Exception("cannot instantiate Namespace again.")
@staticmethod
def get_instance():
if Namespace.__instance is None:
Namespace()
return Namespace.__instance
def register(self, fn):
"""registers the function in the virtual namespace and returns
an instance of callable Function that wraps the function fn.
"""
func = Function(fn)
specs = getfullargspec(fn)
self.function_map[func.key()] = fn
return func
def get(self, fn, *args):
"""get returns the matching function from the virtual namespace.
return None if it did not fund any matching function.
"""
func = Function(fn)
return self.function_map.get(func.key(args=args))
def overload(fn):
"""overload is the decorator that wraps the function
and returns a callable object of type Function.
"""
return Namespace.get_instance().register(fn)
最后，演示代碼如下：
from overload import overload
@overload
def area(length, breadth):
return length * breadth
@overload
def area(radius):
import math
return math.pi * radius ** 2
@overload
def area(length, breadth, height):
return 2 * (length * breadth + breadth * height + height * length)
@overload
def volume(length, breadth, height):
return length * breadth * height
@overload
def area(length, breadth, height):
return length + breadth + height
@overload
def area():
return 0
print(f"area of cuboid with dimension (4, 3, 6) is: {area(4, 3, 6)}")
print(f"area of rectangle with dimension (7, 2) is: {area(7, 2)}")
print(f"area of circle with radius 7 is: {area(7)}")
print(f"area of nothing is: {area()}")
print(f"volume of cuboid with dimension (4, 3, 6) is: {volume(4, 3, 6)}")
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/288561.html
標籤：其他
上一篇：Netty 框架學習 —— 基于 Netty 的 HTTP/HTTPS 應用程式
下一篇：串列訪問匯總（上）