Bir sözlük karma mı?

Önbellekleme amaçları için, bir sözlükte bulunan GET argümanlarından bir önbellek anahtarı oluşturmam gerekiyor.

Şu anda kullanıyorum sha1(repr(sorted(my_dict.items())))( hashlib'i dahili olarak sha1()kullanan bir kolaylık yöntemidir ) ama daha iyi bir yol olup olmadığını merak ediyorum.

Sözlüğünüz iç içe değilse, diktenin öğeleriyle bir frozenset yapabilir ve kullanabilirsiniz hash():

hash(frozenset(my_dict.items()))

Bu, JSON dizesini veya sözlüğün temsilini oluşturmaktan çok daha az hesaplama gerektirir.

GÜNCELLEME: Bu yaklaşımın neden istikrarlı bir sonuç vermeyebileceğini lütfen aşağıdaki yorumlara bakın.

Kullanmak sorted(d.items())bize istikrarlı bir repr almak için yeterli değildir. Değerlerin bazıları dda sözlük olabilir ve anahtarları yine de keyfi bir sırayla ortaya çıkacaktır. Tüm tuşlar dize olduğu sürece kullanmayı tercih ederim:

json.dumps(d, sort_keys=True)

Bununla birlikte, karmaların farklı makineler veya Python sürümleri arasında kararlı olması gerekiyorsa, bunun kurşun geçirmez olduğundan emin değilim. Kendinizi buradaki varsayılan değişikliklerden korumak için separatorsve ensure_asciibağımsız değişkenlerini eklemek isteyebilirsiniz . Yorumları takdir ediyorum.

DÜZENLEME : Tüm anahtarlarınız dize ise , bu yanıtı okumaya devam etmeden önce, lütfen Jack O'Connor'ın önemli ölçüde daha basit (ve daha hızlı) çözümüne bakın (bu da iç içe sözlükler için de geçerlidir).

Her ne kadar bir cevap kabul edilmiş olsa da, sorunun başlığı "bir python sözlüğünü karıştırmak" tır ve bu başlık ile ilgili cevap eksiktir. (Sorunun içeriği ile ilgili olarak cevap tamamlandı.)

İç İçe Sözlükler

Bir sözlük nasıl karmalaştırılacağı için Stack Overflow ararsa, bu uygun başlıklı soruya rastlayabilir ve iç içe sözlükleri çoğaltmaya çalışıyorsa tatminsiz bırakılabilir. Yukarıdaki cevap bu durumda işe yaramaz ve hash'ı almak için bir çeşit özyinelemeli mekanizma uygulamanız gerekir.

İşte böyle bir mekanizma:

import copy

def make_hash(o):

  """
  Makes a hash from a dictionary, list, tuple or set to any level, that contains
  only other hashable types (including any lists, tuples, sets, and
  dictionaries).
  """

  if isinstance(o, (set, tuple, list)):

    return tuple([make_hash(e) for e in o])    

  elif not isinstance(o, dict):

    return hash(o)

  new_o = copy.deepcopy(o)
  for k, v in new_o.items():
    new_o[k] = make_hash(v)

  return hash(tuple(frozenset(sorted(new_o.items()))))

Bonus: Nesneleri ve Sınıfları Karma

hash()Eğer sınıfları veya örneklerini karma zaman fonksiyonu iyi çalışıyor. Ancak, nesnelerle ilgili olarak karma ile bulduğum bir sorun var:

class Foo(object): pass
foo = Foo()
print (hash(foo)) # 1209812346789
foo.a = 1
print (hash(foo)) # 1209812346789

Çileyi değiştirdikten sonra bile karma aynı. Çünkü foo kimliği değişmedi, bu yüzden karma aynı. Foo'nun mevcut tanımına bağlı olarak farklı şekilde karma yapmasını istiyorsanız, çözüm aslında değişen her şeyi karma etmektir. Bu durumda, __dict__özellik:

class Foo(object): pass
foo = Foo()
print (make_hash(foo.__dict__)) # 1209812346789
foo.a = 1
print (make_hash(foo.__dict__)) # -78956430974785

Ne yazık ki, sınıfın kendisiyle aynı şeyi yapmaya çalıştığınızda:

print (make_hash(Foo.__dict__)) # TypeError: unhashable type: 'dict_proxy'

Class __dict__özelliği normal bir sözlük değildir:

print (type(Foo.__dict__)) # type <'dict_proxy'>

Sınıfları uygun şekilde işleyecek öncekine benzer bir mekanizma:

import copy

DictProxyType = type(object.__dict__)

def make_hash(o):

  """
  Makes a hash from a dictionary, list, tuple or set to any level, that 
  contains only other hashable types (including any lists, tuples, sets, and
  dictionaries). In the case where other kinds of objects (like classes) need 
  to be hashed, pass in a collection of object attributes that are pertinent. 
  For example, a class can be hashed in this fashion:

    make_hash([cls.__dict__, cls.__name__])

  A function can be hashed like so:

    make_hash([fn.__dict__, fn.__code__])
  """

  if type(o) == DictProxyType:
    o2 = {}
    for k, v in o.items():
      if not k.startswith("__"):
        o2[k] = v
    o = o2  

  if isinstance(o, (set, tuple, list)):

    return tuple([make_hash(e) for e in o])    

  elif not isinstance(o, dict):

    return hash(o)

  new_o = copy.deepcopy(o)
  for k, v in new_o.items():
    new_o[k] = make_hash(v)

  return hash(tuple(frozenset(sorted(new_o.items()))))

İstediğiniz birçok öğenin karma grubunu döndürmek için bunu kullanabilirsiniz:

# -7666086133114527897
print (make_hash(func.__code__))

# (-7666086133114527897, 3527539)
print (make_hash([func.__code__, func.__dict__]))

# (-7666086133114527897, 3527539, -509551383349783210)
print (make_hash([func.__code__, func.__dict__, func.__name__]))

NOT: yukarıdaki kodların tümü Python 3.x'i varsayar. make_hash()2.7.2 'de çalışacağını varsaysam da önceki sürümlerde test yapmadım. Uzak örnekler işi yapmak kadar, ben do biliyorum

func.__code__ 

ile değiştirilmelidir

func.func_code

İşte daha net bir çözüm.

def freeze(o):
  if isinstance(o,dict):
    return frozenset({ k:freeze(v) for k,v in o.items()}.items())

  if isinstance(o,list):
    return tuple([freeze(v) for v in o])

  return o


def make_hash(o):
    """
    makes a hash out of anything that contains only list,dict and hashable types including string and numeric types
    """
    return hash(freeze(o))  

Aşağıdaki kod Python hash () işlevini kullanmaktan kaçınır, çünkü Python yeniden başlatmalarında tutarlı olan sağlamalar sağlamaz (Python 3.3'teki karma işlevine bakın oturumlar arasında farklı sonuçlar verir ). make_hashable()nesneyi iç içe tupllere make_hash_sha256()dönüştürür ve ayrıca repr()base64 kodlu SHA256 karmasına dönüştürür .

import hashlib
import base64

def make_hash_sha256(o):
    hasher = hashlib.sha256()
    hasher.update(repr(make_hashable(o)).encode())
    return base64.b64encode(hasher.digest()).decode()

def make_hashable(o):
    if isinstance(o, (tuple, list)):
        return tuple((make_hashable(e) for e in o))

    if isinstance(o, dict):
        return tuple(sorted((k,make_hashable(v)) for k,v in o.items()))

    if isinstance(o, (set, frozenset)):
        return tuple(sorted(make_hashable(e) for e in o))

    return o

o = dict(x=1,b=2,c=[3,4,5],d={6,7})
print(make_hashable(o))
# (('b', 2), ('c', (3, 4, 5)), ('d', (6, 7)), ('x', 1))

print(make_hash_sha256(o))
# fyt/gK6D24H9Ugexw+g3lbqnKZ0JAcgtNW+rXIDeU2Y=

2013 yanıtından güncellendi ...

Yukarıdaki cevapların hiçbiri benim için güvenilir görünmüyor. Nedeni () öğelerinin kullanımıdır. Bildiğim kadarıyla, bu makineye bağlı bir sırayla ortaya çıkıyor.

Buna ne dersin?

import hashlib

def dict_hash(the_dict, *ignore):
    if ignore:  # Sometimes you don't care about some items
        interesting = the_dict.copy()
        for item in ignore:
            if item in interesting:
                interesting.pop(item)
        the_dict = interesting
    result = hashlib.sha1(
        '%s' % sorted(the_dict.items())
    ).hexdigest()
    return result

Anahtar sırasını korumak için, yerine hash(str(dictionary))veya hash(json.dumps(dictionary))hızlı ve kirli çözümü tercih ederim:

from pprint import pformat
h = hash(pformat(dictionary))

DateTimeJSON serileştirilemeyen türler ve daha fazlası için bile çalışır .

Kararınızı dondurmak ve yıkanabilir hale getirmek için üçüncü taraf frozendictmodülünü kullanabilirsiniz.

from frozendict import frozendict
my_dict = frozendict(my_dict)

Yuvalanmış nesneleri işlemek için şunları yapabilirsiniz:

import collections.abc

def make_hashable(x):
    if isinstance(x, collections.abc.Hashable):
        return x
    elif isinstance(x, collections.abc.Sequence):
        return tuple(make_hashable(xi) for xi in x)
    elif isinstance(x, collections.abc.Set):
        return frozenset(make_hashable(xi) for xi in x)
    elif isinstance(x, collections.abc.Mapping):
        return frozendict({k: make_hashable(v) for k, v in x.items()})
    else:
        raise TypeError("Don't know how to make {} objects hashable".format(type(x).__name__))

Daha fazla türü desteklemek istiyorsanız, functools.singledispatch(Python 3.7) kullanın :

@functools.singledispatch
def make_hashable(x):
    raise TypeError("Don't know how to make {} objects hashable".format(type(x).__name__))

@make_hashable.register
def _(x: collections.abc.Hashable):
    return x

@make_hashable.register
def _(x: collections.abc.Sequence):
    return tuple(make_hashable(xi) for xi in x)

@make_hashable.register
def _(x: collections.abc.Set):
    return frozenset(make_hashable(xi) for xi in x)

@make_hashable.register
def _(x: collections.abc.Mapping):
    return frozendict({k: make_hashable(v) for k, v in x.items()})

# add your own types here

Bunu yapmak için haritalar kitaplığını kullanabilirsiniz. Özellikle, haritalar.

import maps
fm = maps.FrozenMap(my_dict)
hash(fm)

Yüklemek mapsiçin şunları yapın:

pip install maps

Yuvalanmış dictkasayı da işler :

import maps
fm = maps.FrozenMap.recurse(my_dict)
hash(fm)

Feragatname: Ben mapskütüphanenin yazarıyım.

Soruna yaklaşmanın bir yolu, sözlük öğelerinin bir demetini yapmaktır:

hash(tuple(my_dict.items()))

Bunu şöyle yaparım:

hash(str(my_dict))