__Hash __ () 'yi uygulamanın doğru ve iyi yolu nedir?

Uygulamanın doğru ve iyi bir yolu __hash__()nedir?

Daha sonra hashtables aka sözlükler içine nesneler eklemek için kullanılan bir hashcode döndüren işlevi hakkında konuşuyorum.

Olarak __hash__()bir geri tamsayı değerleri eşit ortak veri dağıtılmalıdır varsayalım döner bir tamsayı ve hashtables içine "gruplama" nesneler için kullanılan (çarpışmasını en aza indirmek için). Bu değerleri elde etmek için iyi bir uygulama nedir? Çarpışmalar bir sorun mu var? Benim durumumda, bazı ints, bazı şamandıralar ve bir dize tutan bir konteyner sınıfı gibi davranan küçük bir sınıfım var.

Uygulamanın kolay ve doğru bir yolu, __hash__()bir anahtar grubu kullanmaktır. Özel bir karma kadar hızlı olmayacaktır, ancak buna ihtiyacınız varsa, türü muhtemelen C'de uygulamalısınız.

İşte karma ve eşitlik için bir anahtar kullanma örneği:

class A:
    def __key(self):
        return (self.attr_a, self.attr_b, self.attr_c)

    def __hash__(self):
        return hash(self.__key())

    def __eq__(self, other):
        if isinstance(other, A):
            return self.__key() == other.__key()
        return NotImplemented

Ayrıca, dokümantasyonunda__hash__ bazı özel durumlarda değerli olabilecek daha fazla bilgi vardır.

John Millikin buna benzer bir çözüm önerdi:

class A(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    def __eq__(self, othr):
        return (isinstance(othr, type(self))
                and (self._a, self._b, self._c) ==
                    (othr._a, othr._b, othr._c))

    def __hash__(self):
        return hash((self._a, self._b, self._c))

Bu çözüm ile ilgili sorun hash(A(a, b, c)) == hash((a, b, c)). Başka bir deyişle, karma, anahtar üyelerinin demetininki ile çarpışır. Belki bu pratikte çok önemli değil?

Güncelleme: Python belgeleri şimdi yukarıdaki örnekte olduğu gibi bir demet kullanılmasını önermektedir. Belgelerin belirttiği gibi

Gereken tek özellik, eşitliği karşılaştıran nesnelerin aynı karma değerine sahip olmasıdır

Bunun tersinin doğru olmadığını unutmayın. Eşit karşılaştırılmayan nesneler aynı karma değerine sahip olabilir . Böyle bir karma çarpışma, dikte anahtarı veya set öğesi olarak kullanıldığında, nesneler de eşit olmadığı sürece bir nesnenin diğerinin yerini almasına neden olmaz .

Eski / kötü çözüm

Python belgelerine__hash__ XOR gibi bir şey kullanarak alt bileşenlerinin karmaları birleştirmek için önermektedir bu bizi veren:

class B(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    def __eq__(self, othr):
        if isinstance(othr, type(self)):
            return ((self._a, self._b, self._c) ==
                    (othr._a, othr._b, othr._c))
        return NotImplemented

    def __hash__(self):
        return (hash(self._a) ^ hash(self._b) ^ hash(self._c) ^
                hash((self._a, self._b, self._c)))

Güncelleme: Blckknght'ın işaret ettiği gibi, a, b ve c sırasını değiştirmek sorunlara neden olabilir. ^ hash((self._a, self._b, self._c))Karma olan değerlerin sırasını yakalamak için bir ek ekledim . Bu final ^ hash(...), birleştirilen değerler yeniden düzenlenemezse kaldırılabilir (örneğin, farklı türleri varsa ve bu nedenle değeri _ahiçbir zaman _bveya _c, vb.'ye atanmayacaksa ).

Microsoft Research'ten Paul Larson, çok çeşitli karma işlevleri inceledi. O bana şöyle söyledi

for c in some_string:
    hash = 101 * hash  +  ord(c)

çok çeşitli dizeler için şaşırtıcı derecede iyi çalıştı. Benzer polinom tekniklerinin, farklı alt alanların bir karmasını hesaplamak için iyi çalıştığını buldum.

Sorunuzun ikinci kısmını cevaplamaya çalışabilirim.

Çarpışmalar muhtemelen karma kodun kendisinden değil, karma kodun bir koleksiyondaki bir dizine eşlenmesinden kaynaklanır. Örneğin, hash fonksiyonunuz 1'den 10000'e rastgele değerler döndürebilir, ancak hash tablonuzda sadece 32 giriş varsa ekleme sırasında çarpışmalar elde edersiniz.

Ayrıca, çarpışmaların koleksiyon tarafından dahili olarak çözüleceğini ve çarpışmaları çözmek için birçok yöntem olduğunu düşünüyorum. En basit (ve en kötü), indeks i'ye eklenecek bir giriş verildiğinde, boş bir nokta bulana ve buraya ekleyene kadar 1'e i ekleyin. Daha sonra alma aynı şekilde çalışır. Bu, bazı koleksiyonlar için verimsiz alımlara neden olur, çünkü bulmak için tüm koleksiyonun geçişini gerektiren bir girişe sahip olabilirsiniz!

Diğer çarpışma çözümleme yöntemleri, işleri dağıtmak için bir öğe eklendiğinde karma tablodaki girişleri taşıyarak alma süresini azaltır. Bu, ekleme süresini artırır ancak eklediğinizden daha fazla okuduğunuzu varsayar. Farklı çarpışma girişlerini belirli bir noktada kümelemek için farklı çarpışma girişlerini denemeye ve dallamaya yönelik yöntemler de vardır.

Ayrıca, koleksiyonu yeniden boyutlandırmanız gerekiyorsa, her şeyi yeniden oluşturmanız veya dinamik bir karma yöntemi kullanmanız gerekir.

Kısacası, karma kodunu ne kullandığınıza bağlı olarak kendi çarpışma çözümleme yönteminizi uygulamak zorunda kalabilirsiniz. Bunları bir koleksiyonda saklamıyorsanız, muhtemelen çok geniş bir aralıkta karma kodları üreten bir karma işleviyle kurtulabilirsiniz. Öyleyse, bellek endişelerinize bağlı olarak kabınızın olması gerekenden daha büyük olduğundan (elbette daha büyük daha iyi) emin olabilirsiniz.

Daha fazla ilgilendiğiniz bazı bağlantılar şunlardır:

wikipedia üzerinde birleşmiş karma

Wikipedia ayrıca çeşitli çarpışma çözümü yöntemlerinin bir özetine sahiptir :

Ayrıca, Tharp tarafından " Dosya Düzenleme ve İşleme " çok sayıda çarpışma çözümleme yöntemini kapsamlı bir şekilde kapsamaktadır. IMO, karma algoritmalar için harika bir referans.

Programın web sitesinde__hash__ işlevin ne zaman ve nasıl uygulanacağına dair çok iyi bir açıklama :

Genel bir bakış sağlamak için sadece bir ekran görüntüsü: (Retrieved 2019-12-13)

Yöntemin kişisel bir uygulamasına gelince, yukarıda belirtilen site millerdev'in cevabına uyan bir örnek sunmaktadır .

class Person:
def __init__(self, age, name):
    self.age = age
    self.name = name

def __eq__(self, other):
    return self.age == other.age and self.name == other.name

def __hash__(self):
    print('The hash is:')
    return hash((self.age, self.name))

person = Person(23, 'Adam')
print(hash(person))

Döndürdüğünüz karma değerinin boyutuna bağlıdır. Basit bir mantık, dört bitlik 32 bitlik karmaya dayalı bir 32 bit int döndürmeniz gerekirse, çarpışmalar elde edeceğinizdir.

Biraz operasyonları tercih ederim. Mesela, aşağıdaki C sözde kodu:

int a;
int b;
int c;
int d;
int hash = (a & 0xF000F000) | (b & 0x0F000F00) | (c & 0x00F000F0 | (d & 0x000F000F);

Böyle bir sistem şamandıralar için de işe yarayabilir, eğer onları gerçekte bir kayan nokta değerini temsil etmek yerine bit değeri olarak aldıysanız, belki daha iyi olabilir.

Teller için, hiçbir fikrim yok.