在Python中，重载不是一个应用概念。然而，如果你试图创建这样的情况，例如，你想要在传入类型为foo的参数时执行一个初始化式，而在传入类型为bar的参数时执行另一个初始化式，那么，由于Python中的所有内容都是作为对象处理的，你可以检查传入对象的类类型的名称，并基于此编写条件处理。

class A:
   def __init__(self, arg)
      # Get the Argument's class type as a String
      argClass = arg.__class__.__name__

      if argClass == 'foo':
         print 'Arg is of type "foo"'
         ...
      elif argClass == 'bar':
         print 'Arg is of type "bar"'
         ...
      else
         print 'Arg is of a different type'
         ...

这个概念可以根据需要通过不同的方法应用到多个不同的场景中。

这是方法重载，而不是方法重写。在Python中，你可以在一个函数中完成所有工作:

class A:
    def stackoverflow(self, i='some_default_value'):
        print('only method')

ob=A()
ob.stackoverflow(2)
ob.stackoverflow()

请参阅Python教程的默认实参值部分。请参阅“Least surprise”和可变默认参数，以了解需要避免的常见错误。

有关Python 3.4中添加的单个分派泛型函数的信息，请参阅PEP 443:

>>> from functools import singledispatch
>>> @singledispatch
... def fun(arg, verbose=False):
...     if verbose:
...         print("Let me just say,", end=" ")
...     print(arg)
>>> @fun.register(int)
... def _(arg, verbose=False):
...     if verbose:
...         print("Strength in numbers, eh?", end=" ")
...     print(arg)
...
>>> @fun.register(list)
... def _(arg, verbose=False):
...     if verbose:
...         print("Enumerate this:")
...     for i, elem in enumerate(arg):
...         print(i, elem)

你也可以使用pythonlangutil:

from pythonlangutil.overload import Overload, signature

class A:
    @Overload
    @signature()
    def stackoverflow(self):    
        print('first method')
    
    @stackoverflow.overload
    @signature("int")
    def stackoverflow(self, i):
        print('second method', i)

Python不像Java或c++那样支持方法重载。我们可以重载方法，但只能使用最新定义的方法。

# First sum method.
# Takes two argument and print their sum
def sum(a, b):
    s = a + b
    print(s)

# Second sum method
# Takes three argument and print their sum
def sum(a, b, c):
    s = a + b + c
    print(s)

# Uncommenting the below line shows an error
# sum(4, 5)

# This line will call the second sum method
sum(4, 5, 5)

我们需要提供可选参数或*args，以便在调用时提供不同数量的参数。

方法重载

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

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

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

Python 3.5增加了类型模块。这包括一个重载装饰器。

这个装饰器的目的是帮助类型检查器。功能上它只是鸭子打字。

from typing import Optional, overload


@overload
def foo(index: int) -> str:
    ...


@overload
def foo(name: str) -> str:
    ...


@overload
def foo(name: str, index: int) -> str:
    ...


def foo(name: Optional[str] = None, index: Optional[int] = None) -> str:
    return f"name: {name}, index: {index}"


foo(1)
foo("bar", 1)
foo("bar", None)

这将导致vs code中的以下类型信息:

虽然这可能有所帮助，但请注意，这添加了许多“奇怪的”新语法。它的目的——纯粹的类型提示——不是很明显。

使用类型的联合通常是更好的选择。