Хочете словник?

Для кешування потрібно генерувати кеш-ключ із аргументів GET, які присутні в диктаті.

В даний час я використовую sha1(repr(sorted(my_dict.items())))( sha1()це зручний метод, який використовує хешліб всередині), але мені цікаво, чи є кращий спосіб.

Якщо ваш словник не вкладений, ви можете зробити заморожений набір з елементами дикту та використовувати hash():

hash(frozenset(my_dict.items()))

Це набагато менш обчислювально, ніж генерування рядка JSON або представлення словника.

ОНОВЛЕННЯ: Будь ласка, дивіться коментарі нижче, чому такий підхід може не дати стабільного результату.

Використання sorted(d.items())недостатньо, щоб отримати стабільну репр. Деякі з значень у dможе бути і словниками, і їхні ключі все одно вийдуть у довільному порядку. Поки всі клавіші є рядками, я вважаю за краще використовувати:

json.dumps(d, sort_keys=True)

Однак, якщо хеші повинні бути стабільними на різних машинах або версіях Python, я не впевнений, що це непробито. Ви можете додати аргументи separatorsта ensure_asciiаргументи, щоб захистити себе від будь-яких змін у налаштуваннях за замовчуванням. Буду вдячний за коментарі.

EDIT : Якщо всі ваші клавіші - це рядки , то перш ніж продовжувати читати цю відповідь, будь ласка, знайдіть значно простіше (і швидше) рішення Джека О'Коннора (яке також працює для хешування вкладених словників).

Незважаючи на те, що відповідь прийнято, назва питання "Заховання словника пітона", і відповідь неповна щодо цього заголовка. (Що стосується суті питання, відповідь є повною.)

Вкладені словники

Якщо ви шукаєте переповнення стека для того, як хеш-словник, можна наткнутися на це влучно під назвою питання і залишити незадоволеним, якщо намагається хеш помножити вкладені словники. Відповідь вище не працюватиме в цьому випадку, і вам доведеться реалізувати якийсь рекурсивний механізм, щоб отримати хеш.

Ось один з таких механізмів:

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()функція чудово працює, коли у вас є хеш-класи або екземпляри. Однак ось одне питання, яке я знайшов із хешем щодо об’єктів:

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

Хеш - той самий, навіть після того, як я змінив foo. Це тому, що особа foo не змінилася, тому хеш - той самий. Якщо ви хочете, щоб 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 (див. Хеш-функція в Python 3.3 повертає різні результати між сесіями ). make_hashable()перетворить об'єкт в вкладені кортежі, а make_hash_sha256()також перетворить repr()хеш SHA256, кодований 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=

Оновлено з відповіді 2013 року ...

Жодна з наведених відповідей мені не здається надійною. Причиною є використання предметів (). Наскільки мені відомо, це виходить у машино-залежному порядку.

Як щодо цього?

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

Він працюватиме навіть для таких типів, як DateTimeі більше, які не піддаються JSON.

Ви можете використовувати сторонній frozendictмодуль, щоб заморозити дік і зробити його зручним.

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

Для цього можна використовувати бібліотеку карт . Зокрема, карти.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бібліотеки.

Один із способів наблизитись до проблеми - скласти кортеж елементів словника:

hash(tuple(my_dict.items()))

Я роблю це так:

hash(str(my_dict))