Hashing di un dizionario?

Ai fini della memorizzazione nella cache, è necessario generare una chiave cache dagli argomenti GET presenti in un dict.

Attualmente sto usando sha1(repr(sorted(my_dict.items())))( sha1()è un metodo pratico che utilizza l' hashlib internamente) ma sono curioso di sapere se esiste un modo migliore.

Se il tuo dizionario non è nidificato, puoi creare un frozenset con gli elementi del dict e utilizzare hash():

hash(frozenset(my_dict.items()))

Questo è molto meno intenso dal punto di vista computazionale rispetto alla generazione della stringa JSON o della rappresentazione del dizionario.

AGGIORNAMENTO: vedere i commenti seguenti, perché questo approccio potrebbe non produrre un risultato stabile.

L'utilizzo sorted(d.items())non è sufficiente per farci avere un repr stabile. Alcuni dei valori in dpotrebbero essere anche dizionari e le loro chiavi usciranno comunque in un ordine arbitrario. Finché tutte le chiavi sono stringhe, preferisco usare:

json.dumps(d, sort_keys=True)

Detto questo, se gli hash devono essere stabili su macchine diverse o versioni di Python, non sono sicuro che questo sia a prova di proiettile. Potresti voler aggiungere gli argomenti separatorse ensure_asciiper proteggerti da eventuali modifiche alle impostazioni predefinite lì. Apprezzerei i commenti.

EDIT : Se tutte le tue chiavi sono stringhe , prima di continuare a leggere questa risposta, vedi la soluzione significativamente più semplice (e più veloce) di Jack O'Connor (che funziona anche con i dizionari annidati).

Sebbene sia stata accettata una risposta, il titolo della domanda è "Hashing a Python Dictionary" e la risposta è incompleta per quanto riguarda quel titolo. (Per quanto riguarda il corpo della domanda, la risposta è completa.)

Dizionari nidificati

Se si cerca Stack Overflow su come eseguire l'hashing di un dizionario, si potrebbe inciampare su questa domanda appropriatamente intitolata e rimanere insoddisfatti se si sta tentando di eseguire l'hashing di moltiplicare i dizionari nidificati. La risposta sopra non funzionerà in questo caso e dovrai implementare una sorta di meccanismo ricorsivo per recuperare l'hash.

Ecco uno di questi meccanismi:

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: hash di oggetti e classi

La hash()funzione funziona benissimo quando si eseguono hash di classi o istanze. Tuttavia, ecco un problema che ho riscontrato con l'hash, per quanto riguarda gli oggetti:

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

L'hash è lo stesso, anche dopo che ho modificato foo. Questo perché l'identità di foo non è cambiata, quindi l'hash è lo stesso. Se vuoi che foo abbia l'hash in modo diverso a seconda della sua definizione attuale, la soluzione è quella di eseguire l'hash di tutto ciò che sta realmente cambiando. In questo caso, l' __dict__attributo:

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

Ahimè, quando provi a fare la stessa cosa con la classe stessa:

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

La __dict__proprietà class non è un dizionario normale:

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

Ecco un meccanismo simile al precedente che gestirà le classi in modo appropriato:

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

Puoi usarlo per restituire una tupla di hash di quanti elementi desideri:

# -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__]))

NOTA: tutto il codice sopra riportato presuppone Python 3.x. Non ho testato nelle versioni precedenti, anche se presumo make_hash()funzionerà, diciamo, 2.7.2. Per quanto riguarda rendendo il lavoro esempi, io non so che

func.__code__ 

dovrebbe essere sostituito con

func.func_code

Ecco una soluzione più chiara.

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

Il codice seguente evita di usare la funzione hash () di Python perché non fornirà hash coerenti tra i riavvii di Python (vedere la funzione hash in Python 3.3 restituisce risultati diversi tra le sessioni ). make_hashable()convertirà l'oggetto in tuple nidificate e make_hash_sha256()convertirà anche repr()in un hash SHA256 con codifica base64.

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=

Aggiornato dalla risposta 2013 ...

Nessuna delle risposte sopra mi sembra affidabile. Il motivo è l'uso di items (). Per quanto ne so, questo viene fuori in un ordine dipendente dalla macchina.

Che ne dici di questo invece?

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

Per mantenere l'ordine chiave, invece che hash(str(dictionary))o hash(json.dumps(dictionary))io preferirei soluzione rapida-and-dirty:

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

Funzionerà anche per tipi come DateTimee altro che non sono serializzabili JSON.

È possibile utilizzare il frozendictmodulo di terze parti per bloccare il dict e renderlo hash.

from frozendict import frozendict
my_dict = frozendict(my_dict)

Per la gestione di oggetti nidificati, è possibile utilizzare:

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

Se vuoi supportare più tipi, usa functools.singledispatch(Python 3.7):

@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

È possibile utilizzare la libreria di mappe per farlo. In particolare, maps.FrozenMap

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

Per installare maps, basta fare:

pip install maps

Gestisce anche il dictcaso nidificato :

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

Disclaimer: sono l'autore della mapsbiblioteca.

Un modo per affrontare il problema è creare una tupla degli elementi del dizionario:

hash(tuple(my_dict.items()))

Lo faccio così:

hash(str(my_dict))