辞書をハッシュ化しますか？

キャッシュの目的で、dictに存在するGET引数からキャッシュキーを生成する必要があります。

現在私はsha1(repr(sorted(my_dict.items())))（hashlibを内部sha1()で使用する便利な方法です）を使用していますが、もっと良い方法があるかどうか知りたいです。

辞書がネストされていない場合は、dictのアイテムでフローズンセットを作成し、次を使用できますhash()。

hash(frozenset(my_dict.items()))

これは、JSON文字列やディクショナリの表現を生成するよりも、計算負荷がはるかに少なくなります。

更新：以下のコメントを参照してください。なぜこのアプローチでは安定した結果が得られないのでしょうか。

を使用しsorted(d.items())ても、安定した収益を得るためには不十分です。の値の一部dも辞書である可能性があり、それらのキーは任意の順序で出力されます。すべてのキーが文字列である限り、以下を使用することをお勧めします。

json.dumps(d, sort_keys=True)

そうは言っても、ハッシュが異なるマシンまたはPythonバージョン間で安定している必要がある場合、これが完全なものであるかどうかはわかりません。separatorsとensure_ascii引数を追加して、デフォルトの変更から保護することができます。コメントいただければ幸いです。

編集：すべてのキーが文字列の場合、この回答を読み続ける前に、Jack O'Connorの非常にシンプルな（そして高速な）ソリューションを参照してください（ネストされた辞書のハッシュにも機能します）。

回答は受理されましたが、質問のタイトルは「Python辞書のハッシュ化」であり、タイトルに関しては回答が不完全です。（質問の本文に関しては、答えは完全です。）

ネストされた辞書

辞書をハッシュする方法をStack Overflowで検索すると、この適切にタイトルが付けられた質問に出くわし、ネストされた複数の辞書をハッシュしようとすると、満足できなくなります。この場合、上記の答えは機能せず、ハッシュを取得するために何らかの再帰的なメカニズムを実装する必要があります。

そのようなメカニズムの1つを次に示します。

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

おまけ：オブジェクトとクラスのハッシュ

このhash()関数は、クラスまたはインスタンスをハッシュするときに最適です。ただし、オブジェクトに関しては、ハッシュに関して私が見つけた1つの問題があります。

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

fooを変更した後でも、ハッシュは同じです。これは、fooのIDが変更されていないため、ハッシュは同じだからです。fooの現在の定義に応じて異なる方法でハッシュしたい場合、解決策は、実際に変更されているものはすべてハッシュ化することです。この場合、__dict__属性は次のとおりです。

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

悲しいかな、あなたがクラス自体で同じことをやろうとしたとき：

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

クラス__dict__プロパティは通常の辞書ではありません：

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

これは、クラスを適切に処理する、以前と同様のメカニズムです。

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

これを使用して、必要な要素のハッシュタプルを返すことができます。

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

注：上記のコードはすべてPython 3.xを想定しています。以前のバージョンではテストしていませんでしたmake_hash()が、たとえば2.7.2で動作すると思います。例を機能させる限り、私はそれを知っています

func.__code__ 

に置き換える必要があります

func.func_code

これはより明確な解決策です。

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

以下のコードは、Pythonの再起動間で一貫したハッシュを提供しないため、Pythonのhash（）関数の使用を避けています（Python 3.3のハッシュ関数はセッション間で異なる結果を返すを参照）。make_hashable()オブジェクトをネストされたタプルにmake_hash_sha256()変換しrepr()、さらにbase64でエンコードされたSHA256ハッシュに変換します。

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年の返信から更新...

上記の答えはどれも私には信頼できるものではありません。その理由は、items（）の使用です。私の知る限り、これはマシン依存の順序で出てきます。

代わりにこれはどうですか？

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

キーの順序を維持するために、代わりに、hash(str(dictionary))またはhash(json.dumps(dictionary))私は迅速で汚いソリューションを好みます：

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

DateTimeJSONシリアライズ可能ではないなどのタイプでも機能します。

サードパーティのfrozendictモジュールを使用して、dictをフリーズしてハッシュ可能にすることができます。

from frozendict import frozendict
my_dict = frozendict(my_dict)

ネストされたオブジェクトを処理するには、次のようにします。

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

より多くのタイプをサポートする場合は、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

これを行うには、マップライブラリを使用できます。具体的には、maps.FrozenMap

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

をインストールするにはmaps、次のようにします。

pip install maps

ネストされたdictケースも処理します。

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

免責事項：私はmaps図書館の作者です。

この問題に取り組む1つの方法は、辞書の項目のタプルを作成することです。

hash(tuple(my_dict.items()))

私はそれをこのようにします：

hash(str(my_dict))