python - __eq__ 应该比较两种不同类型的对象吗？

Question

在我正在处理的问题中，数据标识符的形式为 scope:name，既是 scope 又是 name 字符串. name 由点分隔的不同部分，如 part1.part2.part3.part4.part5。在很多情况下，但并非总是如此，scope 等于 name 的 part1。我正在编写的代码必须与提供或需要不同模式标识符的不同系统一起使用。有时他们只需要完整的字符串表示形式，如 scope:name，在其他一些情况下调用有两个不同的参数 scope 和 name。当从其他系统接收信息时，有时返回完整的字符串 scope:name，有时 scope 被省略，应该从 name 推断，有时返回包含 scope 和 name 的字典。

为了简化这些标识符的使用，我创建了一个类来在内部管理它们，这样我就不必一遍又一遍地编写相同的转换、拆分和格式。类(class)很简单。它只有两个属性(scope 和name，一个将字符串解析为类对象的方法，以及一些表示对象的魔术方法特别是，__str__( self) 以 scope:name 形式返回对象，它是标识符的完全限定名 (fqn):

class DID(object):
    """Represent a data identifier."""

    def __init__(self, scope, name):
        self.scope = scope
        self.name = name

    @classmethod
    def parse(cls, s, auto_scope=False):
        """Create a DID object given its string representation.

        Parameters
        ----------
        s : str
            The string, i.e. 'scope:name', or 'name' if auto_scope is True.

        auto_scope : bool, optional
            If True, and when no scope is provided, the scope will be set to
            the projectname. Default False.

        Returns
        -------
        DID
            The DID object that represents the given fully qualified name.

        """
        if isinstance(s, basestring):
            arr = s.split(':', 2)
        else:
            raise TypeError('string expected.')

        if len(arr) == 1:
            if auto_scope:
                return cls(s.split('.', 1)[0], s)
            else:
                raise ValueError(
                    "Expecting 'scope:name' when auto_scope is False"
                )
        elif len(arr) == 2:
            return cls(*arr)
        else:
            raise ValueError("Too many ':'")

    def __repr__(self):
        return "DID(scope='{0.scope}', name='{0.name}')".format(self)

    def __str__(self):
        return u'{0.scope}:{0.name}'.format(self)

正如我所说，代码必须执行与字符串的比较并使用某些方法的字符串表示。我很想编写 __eq__ 魔术方法及其对应的 __ne__。以下是 __eq__ 的实现:

    # APPROACH 1:
    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.scope == other.scope and self.name == other.name
        elif isinstance(other, basestring):
            return str(self) == other
        else:
            return False

如您所见，它以一种可以相互比较的方式定义了 DID 和字符串之间的相等性比较。 我的问题是这是否是一种好的做法:

一方面，当 other 是一个字符串时，该方法将 self 转换为一个字符串，我一直在思考显式优于隐式 em>。您最终可能会认为您正在使用两个字符串，而 self 不是这种情况。

另一方面，从意义的角度来看，DID 代表 fqn scope:name 并且与字符串比较是否相等是有意义的，因为它在比较 int 和 float 或比较从 basetring 派生的任何两个对象时执行。

我也考虑过在实现中不包括 basestring 的情况，但对我来说这更糟并且容易出错:

    # APPROACH 2:
    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.scope == other.scope and self.name == other.name
        else:
            return False

在方法 2 中，比较 DID 对象和字符串之间的相等性，两者都表示相同的标识符，返回 False。对我来说，这更容易出错。

在这种情况下，最佳做法是什么？是否应该像方法 1 中那样实现 DID 和字符串之间的比较，即使来自不同类型的对象可能被认为是相等的？即使 s != DID.parse(s) 我也应该使用方法 2 吗？我不应该实现 __eq__ 和 __ne__ 以便永远不会被误解吗？

Answer 1

Python 中的几个类(但我想不出标准库中的任何东西)定义了一个处理 RHS 上多种类型的相等运算符。一个支持这一点的通用库是 NumPy，其中:

import numpy as np

np.array(1) == 1

评估为 True。总的来说，我认为我不鼓励这种事情，因为在很多极端情况下，这种行为可能会变得棘手。例如。请参阅 Python 3 中的文章 __hash__方法(类似的东西存在于 Python 2 中，但它已经过时了)。在我编写过类似代码的情况下，我往往会得到更接近于以下内容的代码:

def __eq__(self, other):
    if isinstance(other, str):
        try:
            other = self.parse(str)
        except ValueError:
            return NotImplemented

    if isinstance(other, DID):
        return self.scope == other.scope and self.name == other.name

    return NotImplemented

除此之外，我建议将此类对象设置为不可变对象(immutable对象)，您可以通过多种方式实现。 Python 3 有不错的 dataclasses ，但鉴于您似乎被困在 Python 2 下，您可能会使用 namedtuple，例如:

from collections import namedtuple

class DID(namedtuple('DID', ('scope', 'name'))):
    __slots__ = ()

    @classmethod
    def parse(cls, s, auto_scope=False):
       return cls('foo', 'bar')

    def __eq__(self, other):
        if isinstance(other, str):
            try:
                other = self.parse(str)
            except ValueError:
                return NotImplemented

        return super(DID, self).__eq__(other)

它免费为您提供不变性和 repr 方法，但您可能希望保留自己的 str 方法。 __slots__ 属性意味着意外分配给 obj.scopes 会失败，但您可能希望允许这种行为。