Question

我知道编写关注参数类型的函数并不是Pythonic，但有些情况下，根本不可能忽略类型，因为它们的处理方式不同。

在你的函数中进行一堆isinstance检查只是丑陋;是否有任何函数装饰器可以启用函数重载？像这样：

@overload(str)
def func(val):
    print('This is a string')

@overload(int)
def func(val):
    print('This is an int')

更新

以下是我留在David Zaslavsky's answer上的一些评论：

通过一些修改[s]，这很适合我的目的。我在实现中注意到的另一个限制是，由于您使用func.__name__作为字典键，因此您很容易在模块之间命名冲突，这并不总是令人满意的。 [续]

[续]例如，如果我有一个模块重载func，另一个完全不相关的模块也重载func，这些重载将发生冲突，因为函数dispatch dict是全局的。不知何故，该dict应该在模块的本地。不仅如此，它还应该支持某种“继承”。 [续]

[续]通过'继承'我的意思是：说我有一个模块first有一些重载。然后又有两个不相关的模块，但每个模块都导入first;这两个模块都为刚刚导入的现有模块添加了新的重载。这两个模块应该能够使用first中的重载，但是它们刚刚添加的新模块不应该在模块之间相互冲突。（这实际上很难做到，现在我考虑一下。）

有些问题可以通过稍微更改装饰器语法来解决：

first.py

@overload(str, str)
def concatenate(a, b):
    return a + b

@concatenate.overload(int, int)
def concatenate(a, b):
    return str(a) + str(b)

second.py

from first import concatenate

@concatenate.overload(float, str)
def concatenate(a, b):
    return str(a) + b

Answer 1

快速回答： PyPI上有一个overload package，它比我下面描述的更强大，但使用的语法略有不同。它被声明只适用于Python 3，但看起来只需稍微修改（如果有的话，我没有尝试过）就可以使它与Python 2一起工作。

长答案：在可以重载函数的语言中，函数的名称（字面上或有效地）通过有关其类型签名的信息进行扩充，无论是在定义函数时还是在函数时叫做。当编译器或解释器查找函数定义时，它使用声明的名称和参数类型来解析要访问的函数。因此，在Python中实现重载的逻辑方法是实现一个包装器，它使用声明的名称和参数类型来解析函数。

这是一个简单的实现：

from collections import defaultdict

def determine_types(args, kwargs):
    return tuple([type(a) for a in args]), \
           tuple([(k, type(v)) for k,v in kwargs.iteritems()])

function_table = defaultdict(dict)
def overload(arg_types=(), kwarg_types=()):
    def wrap(func):
        named_func = function_table[func.__name__]
        named_func[arg_types, kwarg_types] = func
        def call_function_by_signature(*args, **kwargs):
            return named_func[determine_types(args, kwargs)](*args, **kwargs)
        return call_function_by_signature
    return wrap

应使用两个可选参数调用

overload，一个表示所有位置参数类型的元组和一个表示所有关键字参数的名称类型映射的元组元组。这是一个用法示例：

>>> @overload((str, int))
... def f(a, b):
...     return a * b

>>> @overload((int, int))
... def f(a, b):
...     return a + b

>>> print f('a', 2)
aa
>>> print f(4, 2)
6

>>> @overload((str,), (('foo', int), ('bar', float)))
... def g(a, foo, bar):
...     return foo*a + str(bar)

>>> @overload((str,), (('foo', float), ('bar', float)))
... def g(a, foo, bar):
...     return a + str(foo*bar)

>>> print g('a', foo=7, bar=4.4)
aaaaaaa4.4
>>> print g('b', foo=7., bar=4.4)
b30.8

缺点包括

它实际上并没有检查装饰器应用的功能是否与赋予装饰器的参数兼容。你可以写
```
@overload((str, int))
def h():
    return 0
```
并且在调用该函数时会出现错误。
它没有优雅地处理不存在与传递的参数类型相对应的重载版本的情况（这将有助于引发更具描述性的错误）
它区分了命名和位置参数，所以类似
```
g('a', 7, bar=4.4)
```
不起作用。
使用此功能涉及许多嵌套括号，如g的定义。
如评论中所述，这不涉及在不同模块中具有相同名称的函数。

我想，所有这些都可以通过足够的摆弄来弥补。特别是，通过将调度表存储为从装饰器返回的函数的属性，可以轻松解决名称冲突的问题。但正如我所说，这只是一个简单的例子来展示如何做到的基础知识。

Answer 2

从Python 3.4开始，functools模块现在支持@singledispatch装饰器。在您的情况下，它看起来像：

from functools import singledispatch


@singledispatch
def func(val):
    raise NotImplementedError


@func.register
def _(val: str):
    print('This is a string')


@func.register
def _(val: int):
    print('This is an int')

用法

func("test") --> "This is a string"
func(1) --> "This is an int"
func(None) --> NotImplementedError

Answer 3

这并没有直接回答你的问题，但如果你真的想要有一些行为类似于不同类型的重载函数，并且（非常正确）不想使用isinstance那么我会建议像：< / p>

def func(int_val=None, str_val=None):
    if sum(x != None for x in (int_val, str_val)) != 1:
        #raise exception - exactly one value should be passed in
    if int_val is not None:
        print('This is an int')
    if str_val is not None:
        print('This is a string')

在使用中，意图是显而易见的，它甚至不需要不同的选项来拥有不同的类型：

func(int_val=3)
func(str_val="squirrel")

用于在Python中重载的装饰器

3 个答案: