时间戳

首页 > 解决方案 > 在 Python 中，是否有一种方便的方法来重载 C++ 中的方法？

python - 在 Python 中，是否有一种方便的方法来重载 C++ 中的方法？

问题描述

例如，假设我们有一个实现矩阵的 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")

但我经常读到类型检查不是“pythonic”，还有什么呢？

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

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

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

我们还假设：

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

感谢大家对这个话题的兴趣。

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

根据我从此处和链接主题的答案中了解到的情况，当我们要处理不同数量的 arguments时，我们可以使用关键字 arguments。这是一个例子（我们称之为技术#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++ 使用@overload装饰器重载的 API。请参阅PEP3124。它看起来确实很方便（这就是技术#5）！

标签： pythonpython-3.xoperator-overloadingoverloading

解决方案

在 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并且它的行为至少会符合预期。如果我尝试将 a 添加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)

现在我可以接受任何类似 a 的对象Vector（即任何具有x和y属性的对象）或ints、floats 或任何可以合理添加到属性的对象，因此如果有人尝试添加Decimal.

在实际的实现中，你应该做更多的异常捕获以生成清晰的错误消息，并且还应该实现__radd__方法等。

推荐阅读