Maneiras elegantes de oferecer suporte à equivalência ("igualdade") nas classes Python

Ao escrever classes personalizadas, geralmente é importante permitir equivalência por meio dos operadores ==e !=. No Python, isso é possível implementando os métodos especiais __eq__e __ne__, respectivamente. A maneira mais fácil de encontrar isso é o seguinte método:

class Foo:
    def __init__(self, item):
        self.item = item

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.__dict__ == other.__dict__
        else:
            return False

    def __ne__(self, other):
        return not self.__eq__(other)

Você conhece meios mais elegantes de fazer isso? Você conhece alguma desvantagem específica em usar o método acima para comparar __dict__s?

Nota : Um pouco de esclarecimento - quando __eq__e __ne__não definido, você encontrará este comportamento:

>>> a = Foo(1)
>>> b = Foo(1)
>>> a is b
False
>>> a == b
False

Ou seja, a == bavalia Falsecomo realmente executa a is b, um teste de identidade (ou seja, "É ao mesmo objeto que b?").

Quando __eq__e __ne__estiver definido, você encontrará esse comportamento (que é o que procuramos):

>>> a = Foo(1)
>>> b = Foo(1)
>>> a is b
False
>>> a == b
True

Considere este problema simples:

class Number:

    def __init__(self, number):
        self.number = number


n1 = Number(1)
n2 = Number(1)

n1 == n2 # False -- oops

Portanto, o Python, por padrão, usa os identificadores de objeto para operações de comparação:

id(n1) # 140400634555856
id(n2) # 140400634555920

A substituição da __eq__função parece resolver o problema:

def __eq__(self, other):
    """Overrides the default implementation"""
    if isinstance(other, Number):
        return self.number == other.number
    return False


n1 == n2 # True
n1 != n2 # True in Python 2 -- oops, False in Python 3

No Python 2 , lembre-se sempre de substituir a __ne__função também, conforme a documentação declara:

Não há relacionamentos implícitos entre os operadores de comparação. A verdade de x==ynão implica que isso x!=yseja falso. Assim, ao definir __eq__(), deve-se definir também __ne__()para que os operadores se comportem conforme o esperado.

def __ne__(self, other):
    """Overrides the default implementation (unnecessary in Python 3)"""
    return not self.__eq__(other)


n1 == n2 # True
n1 != n2 # False

No Python 3 , isso não é mais necessário, pois a documentação declara:

Por padrão, __ne__()delega __eq__()e inverte o resultado, a menos que seja NotImplemented. Não há outras relações implícitas entre os operadores de comparação, por exemplo, a verdade de (x<y or x==y)não implica x<=y.

Mas isso não resolve todos os nossos problemas. Vamos adicionar uma subclasse:

class SubNumber(Number):
    pass


n3 = SubNumber(1)

n1 == n3 # False for classic-style classes -- oops, True for new-style classes
n3 == n1 # True
n1 != n3 # True for classic-style classes -- oops, False for new-style classes
n3 != n1 # False

Nota: Python 2 possui dois tipos de classes:

• de estilo clássico (ou de estilo antigo ) classes, que não herdamobjecte que são declarados comoclass A:,class A():ouclass A(B):ondeBé uma classe de estilo clássico;

• classes de novo estilo , que herdamobjecte são declaradas comoclass A(object)ouclass A(B):ondeBé uma classe de novo estilo. O Python 3 possui apenas classes de novo estilo que são declaradas comoclass A:,class A(object):ouclass A(B):.

Para classes de estilo clássico, uma operação de comparação sempre chama o método do primeiro operando, enquanto para classes de novo estilo, sempre chama o método do operando da subclasse, independentemente da ordem dos operandos .

Então, aqui, se Numberé uma classe de estilo clássico:

• n1 == n3chamadas n1.__eq__;
• n3 == n1chamadas n3.__eq__;
• n1 != n3chamadas n1.__ne__;
• n3 != n1chamadas n3.__ne__.

E se Numberé uma classe de novo estilo:

• ambos n1 == n3e n3 == n1ligar n3.__eq__;
• ambos n1 != n3e n3 != n1ligue n3.__ne__.

Para corrigir o problema de não comutatividade dos operadores ==e !=para as classes de estilo clássico do Python 2, os métodos __eq__e __ne__devem retornar o NotImplementedvalor quando um tipo de operando não for suportado. A documentação define o NotImplementedvalor como:

Métodos numéricos e métodos de comparação avançados podem retornar esse valor se eles não implementarem a operação para os operandos fornecidos. (O intérprete tentará a operação refletida ou algum outro fallback, dependendo do operador.) Seu valor verdadeiro é verdadeiro.

Nesse caso, o operador delega a operação de comparação para o método refletido do outro operando. A documentação define métodos refletidos como:

Não há versões de argumento trocado desses métodos (a serem usadas quando o argumento esquerdo não suporta a operação, mas o argumento correto); sim, __lt__()e __gt__()são reflexo um do outro, __le__()e __ge__()são reflexo um do outro, e __eq__()e __ne__()são a sua própria reflexão.

O resultado fica assim:

def __eq__(self, other):
    """Overrides the default implementation"""
    if isinstance(other, Number):
        return self.number == other.number
    return NotImplemented

def __ne__(self, other):
    """Overrides the default implementation (unnecessary in Python 3)"""
    x = self.__eq__(other)
    if x is NotImplemented:
        return NotImplemented
    return not x

Retornar o NotImplementedvalor em vez de Falseé a coisa certa a fazer, mesmo para as classes de novo estilo, se a comutatividade dos operadores ==e !=for desejada quando os operandos forem de tipos não relacionados (sem herança).

Já estamos lá? Nem tanto. Quantos números únicos temos?

len(set([n1, n2, n3])) # 3 -- oops

Os conjuntos usam os hashes dos objetos e, por padrão, o Python retorna o hash do identificador do objeto. Vamos tentar substituí-lo:

def __hash__(self):
    """Overrides the default implementation"""
    return hash(tuple(sorted(self.__dict__.items())))

len(set([n1, n2, n3])) # 1

O resultado final é semelhante a este (adicionei algumas afirmações no final para validação):

class Number:

    def __init__(self, number):
        self.number = number

    def __eq__(self, other):
        """Overrides the default implementation"""
        if isinstance(other, Number):
            return self.number == other.number
        return NotImplemented

    def __ne__(self, other):
        """Overrides the default implementation (unnecessary in Python 3)"""
        x = self.__eq__(other)
        if x is not NotImplemented:
            return not x
        return NotImplemented

    def __hash__(self):
        """Overrides the default implementation"""
        return hash(tuple(sorted(self.__dict__.items())))


class SubNumber(Number):
    pass


n1 = Number(1)
n2 = Number(1)
n3 = SubNumber(1)
n4 = SubNumber(4)

assert n1 == n2
assert n2 == n1
assert not n1 != n2
assert not n2 != n1

assert n1 == n3
assert n3 == n1
assert not n1 != n3
assert not n3 != n1

assert not n1 == n4
assert not n4 == n1
assert n1 != n4
assert n4 != n1

assert len(set([n1, n2, n3, ])) == 1
assert len(set([n1, n2, n3, n4])) == 2

Você precisa ter cuidado com a herança:

>>> class Foo:
    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.__dict__ == other.__dict__
        else:
            return False

>>> class Bar(Foo):pass

>>> b = Bar()
>>> f = Foo()
>>> f == b
True
>>> b == f
False

Verifique os tipos com mais rigor, assim:

def __eq__(self, other):
    if type(other) is type(self):
        return self.__dict__ == other.__dict__
    return False

Além disso, sua abordagem funcionará bem, é para isso que existem métodos especiais.

O jeito que você descreve é ​​o que eu sempre fiz. Como é totalmente genérico, você sempre pode dividir essa funcionalidade em uma classe mixin e herdá-la nas classes em que deseja essa funcionalidade.

class CommonEqualityMixin(object):

    def __eq__(self, other):
        return (isinstance(other, self.__class__)
            and self.__dict__ == other.__dict__)

    def __ne__(self, other):
        return not self.__eq__(other)

class Foo(CommonEqualityMixin):

    def __init__(self, item):
        self.item = item

Não é uma resposta direta, mas parecia relevante o suficiente para ser abordada, pois economiza um pouco de tédio detalhado na ocasião. Corte direto dos documentos ...

functools.total_ordering (cls)

Dada uma classe que define um ou mais métodos avançados de pedido de comparação, esse decorador de classes fornece o restante. Isso simplifica o esforço envolvido na especificação de todas as operações possíveis de comparação rica:

A classe deve definir um dos __lt__(), __le__(), __gt__(), ou __ge__(). Além disso, a classe deve fornecer um __eq__()método.

Novo na versão 2.7

@total_ordering
class Student:
    def __eq__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) ==
                (other.lastname.lower(), other.firstname.lower()))
    def __lt__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) <
                (other.lastname.lower(), other.firstname.lower()))

Você não precisa substituir os dois __eq__e __ne__pode substituir apenas, __cmp__mas isso implicará no resultado de ==,! ==, <,> e assim por diante.

istestes para identidade de objeto. Isso significa que a isb ocorrerá Truequando aeb tiverem a referência ao mesmo objeto. No python, você sempre mantém uma referência a um objeto em uma variável e não no objeto real; portanto, essencialmente para a ser b, os objetos neles devem estar localizados no mesmo local da memória. Como e mais importante, por que você substitui esse comportamento?

Edit: Eu não sabia que __cmp__foi removido do python 3, para evitá-lo.

A partir desta resposta: https://stackoverflow.com/a/30676267/541136 Eu demonstrei que, embora seja correto definir __ne__em termos __eq__- em vez de

def __ne__(self, other):
    return not self.__eq__(other)

você deveria usar:

def __ne__(self, other):
    return not self == other

Eu acho que os dois termos que você procura são igualdade (==) e identidade (é). Por exemplo:

>>> a = [1,2,3]
>>> b = [1,2,3]
>>> a == b
True       <-- a and b have values which are equal
>>> a is b
False      <-- a and b are not the same list object

O teste 'is' testará a identidade usando a função 'id ()' incorporada, que basicamente retorna o endereço de memória do objeto e, portanto, não pode ser sobrecarregado.

No entanto, no caso de testar a igualdade de uma classe, você provavelmente deseja ser um pouco mais rigoroso sobre seus testes e comparar apenas os atributos de dados em sua classe:

import types

class ComparesNicely(object):

    def __eq__(self, other):
        for key, value in self.__dict__.iteritems():
            if (isinstance(value, types.FunctionType) or 
                    key.startswith("__")):
                continue

            if key not in other.__dict__:
                return False

            if other.__dict__[key] != value:
                return False

         return True

Este código compara apenas membros de dados não funcionais da sua classe, além de ignorar qualquer coisa particular que geralmente seja o que você deseja. No caso de Plain Old Python Objects, tenho uma classe base que implementa __init__, __str__, __repr__ e __eq__, para que meus objetos POPO não carreguem o fardo de toda essa lógica extra (e na maioria dos casos idêntica).

Em vez de usar subclasses / mixins, eu gosto de usar um decorador de classe genérico

def comparable(cls):
    """ Class decorator providing generic comparison functionality """

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not self.__eq__(other)

    cls.__eq__ = __eq__
    cls.__ne__ = __ne__
    return cls

Uso:

@comparable
class Number(object):
    def __init__(self, x):
        self.x = x

a = Number(1)
b = Number(1)
assert a == b

Isso incorpora os comentários na resposta de Algorias e compara objetos por um único atributo, porque eu não ligo para o ditado inteiro. hasattr(other, "id")deve ser verdade, mas eu sei que é porque eu o defini no construtor.

def __eq__(self, other):
    if other is self:
        return True

    if type(other) is not type(self):
        # delegate to superclass
        return NotImplemented

    return other.id == self.id