為什么 Python 沒有函數(shù)重載？如何用裝飾器實(shí)現(xiàn)函數(shù)重載？

英文：https://arpitbhayani.me/blogs/function-overloading

函數(shù)重載指的是有多個(gè)同名的函數(shù)，但是它們的簽名或?qū)崿F(xiàn)卻不同。當(dāng)調(diào)用一個(gè)重載函數(shù) fn 時(shí)，程序會檢驗(yàn)傳遞給函數(shù)的實(shí)參/形參，并據(jù)此而調(diào)用相應(yīng)的實(shí)現(xiàn)。

int area(int length, int breadth) {
  return length * breadth;
}

float area(int radius) {
  return 3.14 * radius * radius;
}

在以上例子中（用 c++ 編寫），函數(shù) area 被重載了兩個(gè)實(shí)現(xiàn)。第一個(gè)函數(shù)接收兩個(gè)參數(shù)（都是整數(shù)），表示矩形的長度和寬度，并返回矩形的面積。另一個(gè)函數(shù)只接收一個(gè)整型參數(shù)，表示圓的半徑。

當(dāng)我們像 area(7) 這樣調(diào)用函數(shù) area 時(shí)，它會調(diào)用第二個(gè)函數(shù)，而 area(3,4) 則會調(diào)用第一個(gè)函數(shù)。

為什么 Python 中沒有函數(shù)重載？

Python 不支持函數(shù)重載。當(dāng)我們定義了多個(gè)同名的函數(shù)時(shí)，后面的函數(shù)總是會覆蓋前面的函數(shù)，因此，在一個(gè)命名空間中，每個(gè)函數(shù)名僅會有一個(gè)登記項(xiàng)（entry）。

Python貓注：這里說 Python 不支持函數(shù)重載，指的是在不用語法糖的情況下。使用 functools 庫的 singledispatch 裝飾器，Python 也可以實(shí)現(xiàn)函數(shù)重載。原文作者在文末的注釋中專門提到了這一點(diǎn)。

通過調(diào)用 locals() 和 globals() 函數(shù)，我們可以看到 Python 的命名空間中有什么，它們分別返回局部和全局命名空間。

def area(radius):
  return 3.14 * radius ** 2

>>> locals()
{
  ...
  'area': <function area at 0x10476a440>,
  ...
}

在定義一個(gè)函數(shù)后，接著調(diào)用 locals() 函數(shù)，我們會看到它返回了一個(gè)字典，包含了定義在局部命名空間中的所有變量。字典的鍵是變量的名稱，值是該變量的引用/值。

當(dāng)程序在運(yùn)行時(shí)，若遇到另一個(gè)同名函數(shù)，它就會更新局部命名空間中的登記項(xiàng)，從而消除兩個(gè)函數(shù)共存的可能性。因此 Python 不支持函數(shù)重載。這是在創(chuàng)造語言時(shí)做出的設(shè)計(jì)決策，但這并不妨礙我們實(shí)現(xiàn)它，所以，讓我們來重載一些函數(shù)吧。

在Python中實(shí)現(xiàn)函數(shù)重載

我們已經(jīng)知道 Python 是如何管理命名空間的，如果想要實(shí)現(xiàn)函數(shù)重載，就需要這樣做：

• 維護(hù)一個(gè)虛擬的命名空間，在其中管理函數(shù)定義
• 根據(jù)每次傳遞的參數(shù)，設(shè)法調(diào)用適當(dāng)?shù)暮瘮?shù)

為了簡單起見，我們在實(shí)現(xiàn)函數(shù)重載時(shí)，通過不同的參數(shù)數(shù)量來區(qū)分同名函數(shù)。

把函數(shù)封裝起來

我們創(chuàng)建了一個(gè)名為Function的類，它可以封裝任何函數(shù)，并通過重寫的__call__方法來調(diào)用該函數(shù)，還提供了一個(gè)名為key的方法，該方法返回一個(gè)元組，使該函數(shù)在整個(gè)代碼庫中是唯一的。

from inspect import getfullargspec

class Function(object):
  """Function類是對標(biāo)準(zhǔn)的Python函數(shù)的封裝"""
  def __init__(self, fn):
    self.fn = fn
    
  def __call__(self, *args, **kwargs):
    """當(dāng)像函數(shù)一樣被調(diào)用時(shí)，它就會調(diào)用被封裝的函數(shù)，并返回該函數(shù)的返回值"""
    return self.fn(*args, **kwargs)

  def key(self, args=None):
    """返回一個(gè)key，能唯一標(biāo)識出一個(gè)函數(shù)（即便是被重載的）"""
    # 如果不指定args，則從函數(shù)的定義中提取參數(shù)
    if args is None:
      args = getfullargspec(self.fn).args
    
    return tuple([
      self.fn.__module__,
      self.fn.__class__,
      self.fn.__name__,
      len(args or []),
    ])

在上面的代碼片段中，key函數(shù)返回一個(gè)元組，該元組唯一標(biāo)識了代碼庫中的函數(shù)，并且記錄了：

• 函數(shù)所屬的模塊
• 函數(shù)所屬的類
• 函數(shù)名
• 函數(shù)接收的參數(shù)量

被重寫的__call__方法會調(diào)用被封裝的函數(shù)，并返回計(jì)算的值（這沒有啥特別的）。這使得Function的實(shí)例可以像函數(shù)一樣被調(diào)用，并且它的行為與被封裝的函數(shù)完全一樣。

def area(l, b):
  return l * b

>>> func = Function(area)
>>> func.key()
('__main__', <class 'function'>, 'area', 2)
>>> func(3, 4)
12

在上面的例子中，函數(shù)area被封裝在Function中，并被實(shí)例化成func。key() 返回一個(gè)元組，其第一個(gè)元素是模塊名__main__，第二個(gè)是類<class 'function'>，第三個(gè)是函數(shù)名area，而第四個(gè)則是該函數(shù)接收的參數(shù)數(shù)量，即 2。

這個(gè)示例還顯示出，我們可以像調(diào)用普通的 area函數(shù)一樣，去調(diào)用實(shí)例 func，當(dāng)傳入?yún)?shù) 3 和 4時(shí)，得到的結(jié)果是 12，這正是調(diào)用 area(3,4) 時(shí)會得到的結(jié)果。當(dāng)我們接下來運(yùn)用裝飾器時(shí)，這種行為將會派上用場。

構(gòu)建虛擬的命名空間

我們要?jiǎng)?chuàng)建一個(gè)虛擬的命名空間，用于存儲在定義階段收集的所有函數(shù)。

由于只有一個(gè)命名空間/注冊表，我們創(chuàng)建了一個(gè)單例類，并把函數(shù)保存在字典中。該字典的鍵不是函數(shù)名，而是我們從 key 函數(shù)中得到的元組，該元組包含的元素能唯一標(biāo)識出一個(gè)函數(shù)。

通過這樣，我們就能在注冊表中保存所有的函數(shù)，即使它們有相同的名稱（但不同的參數(shù)），從而實(shí)現(xiàn)函數(shù)重載。

class Namespace(object):
  """Namespace是一個(gè)單例類，負(fù)責(zé)保存所有的函數(shù)"""
  __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):
    """在虛擬的命名空間中注冊函數(shù)，并返回Function類的可調(diào)用實(shí)例"""
    func = Function(fn)
    self.function_map[func.key()] = fn
    return func

Namespace類有一個(gè)register方法，該方法將函數(shù) fn 作為參數(shù)，為其創(chuàng)建一個(gè)唯一的鍵，并將函數(shù)存儲在字典中，最后返回封裝了 fn 的Function的實(shí)例。這意味著 register 函數(shù)的返回值也是可調(diào)用的，并且（到目前為止）它的行為與被封裝的函數(shù) fn 完全相同。

def area(l, b):
  return l * b

>>> namespace = Namespace.get_instance()
>>> func = namespace.register(area)
>>> func(3, 4)
12

使用裝飾器作為鉤子

既然已經(jīng)定義了一個(gè)能夠注冊函數(shù)的虛擬命名空間，那么，我們還需要一個(gè)鉤子來在函數(shù)定義期間調(diào)用它。在這里，我們會使用 Python 裝飾器。

在 Python 中，裝飾器用于封裝一個(gè)函數(shù)，并允許我們在不修改該函數(shù)的結(jié)構(gòu)的情況下，向其添加新功能。裝飾器把被裝飾的函數(shù) fn 作為參數(shù)，并返回一個(gè)新的函數(shù)，用于實(shí)際的調(diào)用。新的函數(shù)會接收原始函數(shù)的 args 和 kwargs，并返回最終的值。

以下是一個(gè)裝飾器的示例，演示了如何給函數(shù)添加計(jì)時(shí)功能。

import time

def my_decorator(fn):
  """這是一個(gè)自定義的函數(shù)，可以裝飾任何函數(shù)，并打印其執(zhí)行過程的耗時(shí)"""
  def wrapper_function(*args, **kwargs):
    start_time = time.time()
    # 調(diào)用被裝飾的函數(shù)，并獲取其返回值
    value = fn(*args, **kwargs)
    print("the function execution took:", time.time() - start_time, "seconds")
    # 返回被裝飾的函數(shù)的調(diào)用結(jié)果
    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

在上面的例子中，我們定義了一個(gè)名為 my_decorator 的裝飾器，它封裝了函數(shù) area，并在標(biāo)準(zhǔn)輸出上打印出執(zhí)行 area 所需的時(shí)間。

每當(dāng)解釋器遇到一個(gè)函數(shù)定義時(shí)，就會調(diào)用裝飾器函數(shù) my_decorator（用它封裝被裝飾的函數(shù)，并將封裝后的函數(shù)存儲在 Python 的局部或全局命名空間中），對于我們來說，它是在虛擬命名空間中注冊函數(shù)的理想鉤子。

因此，我們創(chuàng)建了名為overload的裝飾器，它能在虛擬命名空間中注冊函數(shù)，并返回一個(gè)可調(diào)用對象。

def overload(fn):
  """用于封裝函數(shù)，并返回Function類的一個(gè)可調(diào)用對象"""
  return Namespace.get_instance().register(fn)

overload裝飾器借助命名空間的 .register() 函數(shù)，返回 Function 的一個(gè)實(shí)例。現(xiàn)在，無論何時(shí)調(diào)用函數(shù)（被 overload 裝飾的），它都會調(diào)用由 .register() 函數(shù)所返回的函數(shù)——Function 的一個(gè)實(shí)例，其__call__方法會在調(diào)用期間使用指定的 args 和 kwargs 執(zhí)行。

現(xiàn)在剩下的就是在 Function 類中實(shí)現(xiàn)__call__方法，使得它能根據(jù)調(diào)用期間傳入的參數(shù)而調(diào)用相應(yīng)的函數(shù)。

從命名空間中找到正確的函數(shù)

想要區(qū)別出不同的函數(shù)，除了通常的模塊、類和函數(shù)名以外，還可以依據(jù)函數(shù)的參數(shù)數(shù)量，因此，我們在虛擬的命名空間中定義了一個(gè) get 方法，它會從 Python 的命名空間中讀取待區(qū)分的函數(shù)以及實(shí)參，最后依據(jù)參數(shù)的不同，返回出正確的函數(shù)。我們沒有更改 Python 的默認(rèn)行為，因此在原生的命名空間中，同名的函數(shù)只有一個(gè)。

這個(gè) get 函數(shù)決定了會調(diào)用函數(shù)的哪個(gè)實(shí)現(xiàn)（如果重載了的話）。找到正確的函數(shù)的過程非常簡單——先使用 key 方法，它利用函數(shù)和參數(shù)來創(chuàng)建出唯一的鍵（正如注冊時(shí)所做的那樣），接著查找這個(gè)鍵是否存在于函數(shù)注冊表中；如果存在，則獲取其映射的實(shí)現(xiàn)。

def get(self, fn, *args):
  """從虛擬命名空間中返回匹配到的函數(shù)，如果沒找到匹配，則返回None"""
  func = Function(fn)
  return self.function_map.get(func.key(args=args))

get 函數(shù)創(chuàng)建了 Function 類的一個(gè)實(shí)例，這樣就可以復(fù)用類的 key 函數(shù)來獲得一個(gè)唯一的鍵，而不用再寫創(chuàng)建鍵的邏輯。然后，這個(gè)鍵將用于從函數(shù)注冊表中獲取正確的函數(shù)。

實(shí)現(xiàn)函數(shù)的調(diào)用

前面說過，每次調(diào)用被 overload 裝飾的函數(shù)時(shí)，都會調(diào)用 Function 類中的__call__方法。我們需要讓__call__方法從命名空間的 get 函數(shù)中，獲取出正確的函數(shù)，并調(diào)用之。

__call__方法的實(shí)現(xiàn)如下：

def __call__(self, *args, **kwargs):
  """重寫能讓類的實(shí)例變可調(diào)用對象的__call__方法"""
  # 依據(jù)參數(shù)，從虛擬命名空間中獲取將要調(diào)用的函數(shù)
  fn = Namespace.get_instance().get(self.fn, *args)
  if not fn:
    raise Exception("no matching function found.")
  # 調(diào)用被封裝的函數(shù)，并返回調(diào)用的結(jié)果
  return fn(*args, **kwargs)

該方法從虛擬命名空間中獲取正確的函數(shù)，如果沒有找到任何函數(shù)，它就拋出一個(gè) Exception，如果找到了，就會調(diào)用該函數(shù)，并返回調(diào)用的結(jié)果。

運(yùn)用函數(shù)重載

準(zhǔn)備好所有代碼后，我們定義了兩個(gè)名為 area 的函數(shù)：一個(gè)計(jì)算矩形的面積，另一個(gè)計(jì)算圓的面積。下面定義了兩個(gè)函數(shù)，并使用overload裝飾器進(jìn)行裝飾。

@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

當(dāng)我們用一個(gè)參數(shù)調(diào)用 area 時(shí)，它返回了一個(gè)圓的面積，當(dāng)我們傳遞兩個(gè)參數(shù)時(shí)，它會調(diào)用計(jì)算矩形面積的函數(shù)，從而實(shí)現(xiàn)了函數(shù) area 的重載。

原作者注：從 Python 3.4 開始，Python 的 functools.singledispatch 支持函數(shù)重載。從 Python 3.8 開始，functools.singledispatchmethod 支持重載類和實(shí)例方法。感謝 Harry Percival 的指正。

總結(jié)

Python 不支持函數(shù)重載，但是通過使用它的基本結(jié)構(gòu)，我們搗鼓了一個(gè)解決方案。

我們使用裝飾器和虛擬的命名空間來重載函數(shù)，并使用參數(shù)的數(shù)量作為區(qū)別函數(shù)的因素。我們還可以根據(jù)參數(shù)的類型（在裝飾器中定義）來區(qū)別函數(shù)——即重載那些參數(shù)數(shù)量相同但參數(shù)類型不同的函數(shù)。

重載能做到什么程度，這僅僅受限于getfullargspec函數(shù)和我們的想象。使用前文的思路，你可能會實(shí)現(xiàn)出一個(gè)更整潔、更干凈、更高效的方法，所以，請嘗試實(shí)現(xiàn)一下吧。

正文到此結(jié)束。以下附上完整的代碼：

# 模塊：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)}")