Python sınıflarında denkliği (“eşitlik”) desteklemenin zarif yolları

Özel sınıflar yazarken ==ve !=operatörleri aracılığıyla denkliğe izin vermek genellikle önemlidir . Python'da bu , sırasıyla __eq__ve __ne__özel yöntemlerin uygulanmasıyla mümkün olur . Bunu yapmanın en kolay yolu aşağıdaki yöntemdir:

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)

Bunu yapmanın daha zarif yollarını biliyor musunuz? Yukarıdaki karşılaştırma yöntemini kullanmanın herhangi bir dezavantajı biliyor musunuz __dict__?

Not : Biraz açıklama - ne zaman __eq__ve ne zaman __ne__tanımsızsanız, bu davranışı bulacaksınız:

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

Yani, gerçekten çalıştığı a == biçin değerlendirir , bir kimlik testi (yani, " Aynı nesne mi?").Falsea is bab

Ne zaman __eq__ve __ne__tanımlandığından, (bir Peşinde olduğumuz olan) bu davranışı bulabilirsiniz:

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

Bu basit sorunu düşünün:

class Number:

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


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

n1 == n2 # False -- oops

Bu nedenle, Python varsayılan olarak karşılaştırma işlemleri için nesne tanımlayıcılarını kullanır:

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

Fonksiyonu geçersiz __eq__kılmak sorunu çözüyor gibi görünüyor:

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

In Python 2 , her zaman geçersiz kılmak için hatırlamak __ne__gibi, hem de işlevi belgeleri devletler:

Karşılaştırma işleçleri arasında herhangi bir zımni ilişki yoktur. Gerçek, bunun yanlış olduğu x==yanlamına gelmez x!=y. Buna göre, tanımlarken __eq__(), __ne__()operatörlerin beklendiği gibi davranması için de tanımlanmalıdır .

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


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

In Python 3 , bu gibi artık gerekli değildir belgeleri devletler:

Varsayılan olarak, sonuca __ne__()yetki __eq__()verilmez ve sonuç ters çevrilir NotImplemented. Karşılaştırma operatörleri arasında başka hiçbir zımni ilişki yoktur, örneğin, gerçeği (x<y or x==y)ima etmez x<=y.

Ancak bu tüm sorunlarımızı çözmez. Bir alt sınıf ekleyelim:

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

Not: Python 2'de iki tür sınıf vardır:

• Klasik tarzdaki (veya eski tarz do) sınıfları, değil devralmakobjectve ilan edilirclass A:,class A():ya daclass A(B):neredeBbir klasik tarzda sınıftır;

• Yeni tarzı devralan do sınıfları,objectolarak, beyanclass A(object)veyaclass A(B):neredeByeni tarzı sınıftır. Python 3 olarak ilan edilmiştir yalnızca yeni tarzı sınıfları vardırclass A:,class A(object):ya daclass A(B):.

Klasik stil sınıfları için, karşılaştırma işlemi her zaman ilk işlenenin yöntemini çağırırken, yeni stil sınıfları için, işlenenlerin sırasından bağımsız olarak her zaman alt sınıf işleneninin yöntemini çağırır .

Burada Numberklasik tarzda bir sınıf varsa:

• n1 == n3çağrılar n1.__eq__;
• n3 == n1çağrılar n3.__eq__;
• n1 != n3çağrılar n1.__ne__;
• n3 != n1çağrıları n3.__ne__.

Ve eğer Numberyeni bir sınıf ise:

• her ikisi de n1 == n3ve n3 == n1çağrı n3.__eq__;
• hem n1 != n3ve n3 != n1çağrı n3.__ne__.

Python 2 klasik tarzı sınıfların ==ve !=işleçlerinin değişmezlik sorununu gidermek için , işlenen türü desteklenmediğinde __eq__ve __ne__yöntemlerinin NotImplementeddeğeri döndürmesi gerekir . Belgeler tanımlar NotImplementeddeğeri olarak:

Sayısal yöntemler ve zengin karşılaştırma yöntemleri, sağlanan işlenenler için işlemi uygulamazlarsa bu değeri döndürebilir. (Daha sonra yorumlayıcı, operatöre bağlı olarak yansıtılan işlemi veya başka bir geri dönüşü dener.) Gerçek değeri doğrudur.

Bu durumda, operatör delegelerinin karşılaştırma işlemi yöntemi yansıyan ait diğer işlenen. Belgeler tanımlar yöntemleri olarak yansıtılır:

Bu yöntemlerin takas argümanı sürümleri yoktur (sol argüman işlemi desteklemiyor, ancak sağ argüman destekliyorsa kullanılır); daha doğrusu, __lt__()ve __gt__()birbirlerinin yansımasıdır, __le__()ve __ge__()birbirlerinin yansımasıdır ve __eq__()ve __ne__()kendi yansımasıdır.

Sonuç şuna benzer:

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

Geri dönen NotImplementedyerine değerini Falseeğer yeni tarzı sınıflar için bile yapılacak doğru şey olduğunu Yerdeğiştirme ait ==ve !=işlenenler ilgisiz türleri (hiçbir miras) ait olduğunda operatörleri arzu edilir.

Henüz varmadık mı? Pek değil. Kaç tane benzersiz numaramız var?

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

Kümeler nesnelerin karmasını kullanır ve varsayılan olarak Python nesne tanımlayıcısının karmasını döndürür. Geçersiz kılmaya çalışalım:

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

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

Sonuç şu şekilde görünüyor (Doğrulama için bazı iddialar ekledim):

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

Kalıtım konusunda dikkatli olmalısınız:

>>> 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

Tipleri daha sıkı kontrol edin, şöyle:

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

Bunun yanı sıra, yaklaşımınız iyi çalışacaktır, özel yöntemler budur.

Tarif ettiğiniz şekilde her zaman yaptığım yöntemdir. Tamamen genel olduğundan, bu işlevselliği her zaman bir mixin sınıfına ayırabilir ve bu işlevselliği istediğiniz sınıflarda devralabilirsiniz.

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

Doğrudan bir cevap değil, ama zaman zaman biraz ayrıntılı kurtarır kaydetti gibi tacked için uygun görünüyordu. Doğrudan dokümanlardan kesin ...

functools.total_ordering (CLS)

Bir veya daha fazla zengin karşılaştırma siparişi yöntemini tanımlayan bir sınıf verildiğinde, bu sınıf dekoratörü geri kalanını sağlar.Bu, olası zengin karşılaştırma işlemlerinin tümünü belirleme çabalarını basitleştirir:

Sınıf biri tanımlamalıdır __lt__(), __le__(), __gt__()ya da__ge__() . Ayrıca, sınıf bir __eq__()yöntem sağlamalıdır .

2.7 sürümündeki yenilikler

@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()))

Her ikisini de geçersiz kılmak zorunda değilsiniz __eq__ve __ne__yalnızca geçersiz kılabilirsiniz__cmp__ ancak bu ==,! ==, <,> vb. Sonucuna etki eder.

isnesne kimliği testleri. Bu, bir isb'ninTrue , a ve b'nin her ikisinin de aynı nesneye referansı tutması durumunda . Python'da her zaman asıl nesne değil, bir değişken içindeki bir nesneye başvuruda bulunursunuz, bu nedenle esas olarak a b'nin doğru olması için içindeki nesnelerin aynı bellek konumunda bulunması gerekir. Nasıl ve en önemlisi bu davranışı geçersiz kılmayı tercih edersiniz?

Düzenleme: __cmp__Python 3 kaldırıldı bilmiyordum bu yüzden kaçının.

Bu yanıttan: https://stackoverflow.com/a/30676267/541136 Bunu __ne__, terimlerle tanımlamak doğru olsa da __eq__-

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

kullanmalısın:

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

Aradığınız iki terimin eşitlik (==) ve kimlik (is) olduğunu düşünüyorum. Örneğin:

>>> 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

'İs' testi, temelde nesnenin bellek adresini döndüren ve dolayısıyla yüklenemeyen yerleşik 'id ()' işlevini kullanarak kimliği test eder.

Bununla birlikte, bir sınıfın eşitliğini test etmeniz durumunda, muhtemelen testleriniz hakkında biraz daha katı olmak ve sadece sınıfınızdaki veri özelliklerini karşılaştırmak istersiniz:

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

Bu kod, yalnızca sınıfınızın işlev dışı veri üyelerini karşılaştıracak ve genellikle istediğiniz şey olan özel bir şeyi atlayacaktır. Düz Eski Python Nesneleri durumunda, __init__, __str__, __repr__ ve __eq__'yi uygulayan bir temel sınıfım var, böylece POPO nesnelerim tüm bu ekstra (ve çoğu durumda aynı) mantığın yükünü taşımıyor.

Alt sınıf / mixins kullanmak yerine, genel bir sınıf dekoratör kullanmak istiyorum

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

Kullanımı:

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

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

Bu, Algorias'ın cevabı hakkındaki yorumları içerir ve nesneleri tek bir özellikle karşılaştırır, çünkü tüm dikdörtgeni umursamıyorum. hasattr(other, "id")doğru olmalı, ama yapıcıya koyduğum için biliyorum.

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