我刚刚遇到了重载.py (Python 3的函数重载)，有兴趣的同学可以去看看。

从链接库的README文件:

overloading is a module that provides function dispatching based on the types and number of runtime arguments. When an overloaded function is invoked, the dispatcher compares the supplied arguments to available function signatures and calls the implementation that provides the most accurate match. Features Function validation upon registration and detailed resolution rules guarantee a unique, well-defined outcome at runtime. Implements function resolution caching for great performance. Supports optional parameters (default values) in function signatures. Evaluates both positional and keyword arguments when resolving the best match. Supports fallback functions and execution of shared code. Supports argument polymorphism. Supports classes and inheritance, including classmethods and staticmethods.

Python在PEP-3124中添加了@overload装饰器，为通过类型检查进行重载提供语法糖——而不仅仅是使用重写。

关于通过PEP-3124中的@overload重载的代码示例

from overloading import overload
from collections import Iterable

def flatten(ob):
    """Flatten an object to its component iterables"""
    yield ob

@overload
def flatten(ob: Iterable):
    for o in ob:
        for ob in flatten(o):
            yield ob

@overload
def flatten(ob: basestring):
    yield ob

由@overload-decorator转换为:

def flatten(ob):
    if isinstance(ob, basestring) or not isinstance(ob, Iterable):
        yield ob
    else:
        for o in ob:
            for ob in flatten(o):
                yield ob

我想你想说的是"超载"Python中没有任何方法重载。但是，您可以使用默认参数，如下所示。

def stackoverflow(self, i=None):
    if i != None:
        print 'second method', i
    else:
        print 'first method'

当您向它传递一个参数时，它将遵循第一个条件的逻辑并执行第一个print语句。当你不给它传递参数时，它将进入else条件并执行第二个print语句。

我用Python 3.2.1写了我的答案。

def overload(*functions):
    return lambda *args, **kwargs: functions[len(args)](*args, **kwargs)

工作原理:

Overload接受任意数量的可调用对象，并将它们存储在元组函数中，然后返回lambda。 接受任意数量的参数， 然后返回存储在函数[number_of_unnamed_args_passed]中的调用函数的结果，并将参数传递给lambda。

用法:

class A:
    stackoverflow=overload(                    \
        None, \ 
        #there is always a self argument, so this should never get called
        lambda self: print('First method'),      \
        lambda self, i: print('Second method', i) \
    )

在MathMethod.py文件中:

from multipledispatch import dispatch
@dispatch(int, int)
def Add(a, b):
   return a + b 
@dispatch(int, int, int)  
def Add(a, b, c):
   return a + b + c 
@dispatch(int, int, int, int)    
def Add(a, b, c, d):
   return a + b + c + d

在Main.py文件

import MathMethod as MM 
print(MM.Add(200, 1000, 1000, 200))

我们可以使用multipledispatch重载该方法。

你不能，永远不需要，也不想这么做。

在Python中，所有东西都是对象。类是事物，所以它们是对象。方法也是如此。

有一个对象叫做A，它是一个类。它有一个名为stackoverflow的属性。它只能有一个这样的属性。

当你写def stackoverflow(…):…，所发生的是你创建一个对象，它是方法，并将它赋值给a的stackoverflow属性。如果你写了两个定义，第二个会替换第一个，这与赋值的行为相同。

此外，您也不希望编写的代码执行重载有时会用到的那种过分的操作。语言不是这样的。

与其尝试为可能给定的每种类型的东西定义一个单独的函数(这没什么意义，因为你没有为函数参数指定类型)，不如停止担心这些东西是什么，开始思考它们能做什么。

您不仅不能单独编写一个来处理元组和列表，而且也不想或不需要这样做。

你所要做的就是利用它们都是可迭代的这一事实，例如，你可以写for element in container:)。(他们之间没有直接的遗传关系，这一点无关紧要。)