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': function area at 0x10476a440>,
  ...
}

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 []),
    ])

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

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

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

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

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

import time

def my_decorator(fn):
  """這是一個自定義的函數，可以裝飾任何函數，并打印其執行過程的耗時"""
  def wrapper_function(*args, **kwargs):
    start_time = time.time()
    # 調用被裝飾的函數，并獲取其返回值
    value = 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

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

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

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)

@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

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