在 Python 中，是否有一种方便的方法来重载 C++ 中的方法？ [复制]

Question

例如，假设我们有一个实现矩阵的 Matrix 类。

我们希望能够使用“+”运算符来添加 2 个矩阵，或者将 1 个矩阵与 1 个数字相加（这实际上将被定义为将数字添加到矩阵的每个元素中）。

在 C++ 中，我们可以做到（用 '...' 跳过细节）：

class Matrix
{
    ...

    Matrix operator + (Matrix A, Matrix B)
    {
        ... // process in some way
    }

    Matrix operator + (Matrix A, double x)
    {
        ... // process in some other way
    }
}

但据我所知，在 Python 中，多个定义会覆盖之前的定义。

class Matrix:

    ...

    def __add__(A, B):
        ... # process in some way

    def __add__(A, x):
        ... # process in some other way

这不起作用：只有最后一个方法定义处于活动状态。

所以我能想到的第一个解决方案是只定义一个方法并解析参数（根据它们的类型、数量或关键字）。

例如，通过类型检查，我们可以做类似的事情（我们称之为技术#1）：

class Matrix:
    
    ...

    def __add__(A, X):
        if isinstance(X, Matrix)
            ... # process in some way
        elif isinstance(X, (int, float, complex))
            ... # process in some other way
        else:
            raise TypeError("unsupported type for right operand")

但我经常读到 type-checking 不是“pythonic”，还有什么？

此外，在这种情况下，总是有两个参数，但更一般地说，如果我们希望能够处理不同数量的参数？

为了清楚起见，假设我们有一个名为“mymethod”的方法，我们希望能够调用，比如：

mymethod(type1_arg1)
mymethod(type2_arg1)
mymethod(type3_arg1, type4_arg2)

我们也假设：

• 每个版本都处理同一个对象，所以它必须是一个唯一的方法，
• 每个处理都不同，参数类型很重要。

----------------------------------- - - - - - - 编辑 - - - - - - - - - - - - - - - - - - - --------------------

感谢大家对此话题的关注。

@thegreatemu 在下面提出了一个很好的类型检查替代方案（我们称之为技术#2）。它使用 duck-typing 范例和 exception 处理。但据我所知，它仅在所有情况下的参数数量相同时才有效。

根据我从此处和链接主题的答案中了解到的情况，当我们想要处理不同数量的参数时，我们可以使用关键字参数。这是一个例子（我们称之为技术#3）。

class Duration:
    """Durations in H:M:S format."""

    def __init__(hours, mins=None, secs=None):
        """Works with decimal hours or H:M:S format."""
        
        if mins and secs: # direct H:M:S
            ... # checks
            self.hours = hours
            self.mins = mins
            self.secs = secs

        else: # decimal
           ... # checks
           ... # convert decimal hours to H:M:S

或者我们也可以使用可变长度参数 *args（或**kwargs）。这是带有 *args 和 长度检查 的替代版本（我们称之为技术 #4）。

class Duration:
    """Durations in H:M:S format."""

    def __init__(*args): # direct H:M:S
        """Works with decimal hours or H:M:S format."""
        
        if len(args) == 3 # direct H:M:S format
            ... # checks
            self.hours = args[0]
            self.mins = args[1]
            self.secs = args[2]

        elif len(args) == 1: # decimal
           ... # checks
           ... # convert decimal hours to H:M:S
           
        else:
            raise TypeError("expected 1 or 3 arguments")

在这种情况下，技术#3 和#4 之间的最佳选择是什么？可能是口味问题。

但正如我在原帖中含糊提到的，也可以使用装饰器。特别是，链接的主题提到了重载模块，它提供了一个类似于 C++ 重载的 API，带有 @overload 装饰器。见PEP3124。 它看起来确实很方便（这就是技巧 #5）！​​

Answer 1

在 python 中类型检查的替代方法是“duck typing”。 “鸭子打字”一词的由来是“如果它看起来像鸭子，走路像鸭子，叫起来像鸭子，那它可能就是鸭子”。

所以如果我有一个Vector 类，代表一个二维欧几里得向量：

class Vector(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x+other.x, self.y+other.y)

现在，如果我有一个Coordinate 对象，该对象也具有x 和y 属性，我可以将它添加到我的Vector 中，它的行为至少会与预期的一样。如果我尝试将Vector 添加到浮点数，我会得到AttributeError，在这种情况下，这就是我想要的，因为将标量添加到向量在数学上没有意义。但是假设我想做一些类似 numpy 的广播的事情，所以向向量添加一个标量会将它添加到 x 和 y。那么__add__ 方法会变成：

    def __add__(self, other):
        try:
            x, y = self.x + other.x, self.y + other.y
        except AttributeError:
            x, y = self.x + other, self.y + other
        return Vector(x, y)

现在我可以接受任何像Vector 一样嘎嘎作响的对象（即任何具有x 和y 属性的对象）或ints、floats 或任何可以明智的对象添加到属性中，因此如果有人尝试添加Decimal，它将“正常工作”。

在实际的实现中，你应该多做一些异常捕获来生成清晰的错误信息，还应该实现__radd__方法等。

Answer 2

不，如果您在同一范围内多次声明一个方法，则使用最后一个定义。即使您有不同数量的参数和相同的函数定义，也只会使用最后一个。

这由函数名决定。