__eq__ Python中的订单强制执行

Question

一个稍微长一点的问题，可以充分解释背景

假设有一个内置的class A:

class A:
def __init__(self, a=None):
self.a = a
def __eq__(self, other):
return self.a == other.a

预计将以这种方式进行比较：

a1, a2 = A(1), A(2)
a1 == a2  # False

出于某种原因，该团队在其上面引入了一个包装器(代码示例实际上并没有包装a以简化代码复杂性。(

class WrapperA:
def __init__(self, a=None):
self.pa = a
def __eq__(self, other):
return self.pa == other.pa

同样，预计将以这种方式进行比较：

wa1, wa2 = WrapperA(1), WrapperA(2)
wa1 == wa2  # False

尽管预期使用A或WrapperA，但问题是一些代码库同时包含这两种用法，因此以下比较失败：

a, wa = A(), WrapperA()
wa == a  # AttributeError
a == wa  # AttributeError

一个已知的解决方案是修改__eq__:

对于wa == a:

class WrapperA:
def __init__(self, a=None):
self.pa = a
def __eq__(self, other):
if isinstance(other, A):
return self.pa == other.a
return self.pa == other.pa

对于a == wa:

class A:
def __init__(self, a=None):
self.a = a
def __eq__(self, other):
if isinstance(other, WrapperA):
return self.a == other.pa
return self.a == other.a

需要修改WrapperA。对于A，由于它是一个内置的东西，有两种解决方案：

1. 使用setattr扩展A以支持WrapperA

setattr(A, '__eq__', eq_that_supports_WrapperA)

2. 强制开发人员只比较wa == a(然后不关心a == wa(

第一个选项对于重复的实现来说显然是丑陋的，而第二个选项给开发人员带来了不必要的"惊喜"；。所以我的问题是，有没有一种优雅的方法可以在内部用Python实现来替换a == wa到wa == a的任何用法？

Answer 1

引用MisterMiyagi在以下问题下的评论：

请注意，==通常适用于所有类型。A.__eq__要求其他人成为A实际上是一个应该修复的错误。当它不能做出决策时，它至少应该返回NotImplemented

这很重要，而不仅仅是风格问题。事实上，根据文件：

当二进制(或就地(方法返回NotImplemented时，解释器将尝试对另一个类型执行反射操作

因此，如果你只应用MisterMiyagi的评论并修复__eq__的逻辑，你就会看到你的代码已经很好了：

class A:
def __init__(self, a=None):
self.a = a
def __eq__(self, other):
if isinstance(other, A):
return self.a == other.a
return NotImplemented

class WrapperA:
def __init__(self, a=None):
self.pa = a
def __eq__(self, other):
if isinstance(other, A):
return self.pa == other.a
elif isinstance(other, WrapperA):
return self.pa == other.pa
return NotImplemented
# Trying it
a = A(5)
wrap_a = WrapperA(5)
print(a == wrap_a)
print(wrap_a == a)
wrap_a.pa = 7
print(a == wrap_a)
print(wrap_a == a)
print(f'{wrap_a.pa=}')

收益率：

True
True
False
False
wrap_a.pa=7

在引擎盖下，a == wrap_a首先调用A.__eq__，后者返回NotImplemented。然后Python自动尝试WrapperA.__eq__。

Answer 2

我真的不喜欢这整件事，因为我认为包装一个内建并使用不同的属性名称会导致意想不到的事情，但无论如何，这对你来说都是有效的

import inspect

class A:
def __init__(self, a=None):
self.a = a
def __eq__(self, other):
return self.a == other.a

class WrapperA:
def __init__(self, a=None):
self.pa = a
def __eq__(self, other):
if isinstance(other, A):
return self.pa == other.a
return self.pa == other.pa
def __getattribute__(self, item):
# Figure out who tried to get the attribute
# If the item requested was 'a', check if A's __eq__ method called us,
# in that case return pa instead
caller = inspect.stack()[1]
if item == 'a' and getattr(caller, 'function') == '__eq__' and isinstance(caller.frame.f_locals.get('self'), A):
return super(WrapperA, self).__getattribute__('pa')
return super(WrapperA, self).__getattribute__(item)
a = A(5)
wrap_a = WrapperA(5)
print(a == wrap_a)
print(wrap_a == a)
wrap_a.pa = 7
print(a == wrap_a)
print(wrap_a == a)
print(f'{wrap_a.pa=}')

输出：

True
True
False
False
wrap_a.pa=7

Answer 3

类似于Ron Serruyas的答案：

这使用__getattr__而不是__getattribute__，其中只有当第二个引发AttributeError或显式调用它(ref(时，才会调用第一个。这意味着，如果包装器不实现__eq__，并且等式应该仅对底层数据结构(存储在类A的对象中(执行，则工作示例如下：

class A(object):
def __init__(self, internal_data=None):
self._internal_data = internal_data
def __eq__(self, other):
return self._internal_data == other._internal_data
class WrapperA(object):
def __init__(self, a_object: A):
self._a = a_object
def __getattr__(self, attribute):
if attribute != '_a':  # This is neccessary to prevent recursive calls
return getattr(self._a, attribute)
a1 = A(internal_data=1)
a2 = A(internal_data=2)
wa1 = WrapperA(a1)
wa2 = WrapperA(a2)    
print(
a1 == a1,
a1 == a2,
wa1 == wa1,
a1 == wa1,
a2 == wa2,
wa1 == a1)
>>> True False True True True True