Băm một từ điển?

Đối với mục đích lưu trữ, tôi cần tạo khóa bộ đệm từ các đối số GET có trong một lệnh.

Hiện tại tôi đang sử dụng sha1(repr(sorted(my_dict.items())))( sha1()là một phương pháp tiện lợi sử dụng hashlib trong nội bộ) nhưng tôi tò mò liệu có cách nào tốt hơn không.

Nếu từ điển của bạn không được lồng nhau, bạn có thể tạo một fro chụcet với các mục của dict và sử dụng hash():

hash(frozenset(my_dict.items()))

Điều này ít chuyên sâu hơn về mặt tính toán so với việc tạo chuỗi JSON hoặc biểu diễn của từ điển.

CẬP NHẬT: Vui lòng xem các ý kiến ​​dưới đây, tại sao phương pháp này có thể không tạo ra kết quả ổn định.

Sử dụng sorted(d.items())không đủ để giúp chúng tôi có một repr ổn định. Một số giá trị trong đó dcũng có thể là từ điển và các khóa của chúng vẫn sẽ xuất hiện theo thứ tự tùy ý. Miễn là tất cả các khóa là chuỗi, tôi thích sử dụng:

json.dumps(d, sort_keys=True)

Điều đó nói rằng, nếu băm cần ổn định trên các máy khác nhau hoặc các phiên bản Python, tôi không chắc chắn rằng đây là khả năng chống đạn. Bạn có thể muốn thêm separatorsvà các ensure_asciiđối số để bảo vệ bản thân khỏi mọi thay đổi đối với các mặc định ở đó. Tôi đánh giá cao ý kiến.

EDIT : Nếu tất cả các khóa của bạn là chuỗi , thì trước khi tiếp tục đọc câu trả lời này, vui lòng xem giải pháp đơn giản hơn (và nhanh hơn) của Jack O'Connor (cũng hoạt động để băm từ điển lồng nhau).

Mặc dù câu trả lời đã được chấp nhận, tiêu đề của câu hỏi là "Băm một từ điển trăn" và câu trả lời không đầy đủ về tiêu đề đó. (Liên quan đến phần chính của câu hỏi, câu trả lời đã hoàn tất.)

Từ điển lồng nhau

Nếu một người tìm kiếm Stack Overflow để tìm cách băm từ điển, người ta có thể vấp phải câu hỏi có tiêu đề thích hợp này và không hài lòng nếu ai đó cố gắng băm nhiều từ điển lồng nhau. Câu trả lời ở trên sẽ không hoạt động trong trường hợp này và bạn sẽ phải thực hiện một số loại cơ chế đệ quy để truy xuất hàm băm.

Đây là một cơ chế như vậy:

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

Phần thưởng: Các đối tượng và lớp băm

Các hash()chức năng hoạt động tuyệt vời khi bạn băm lớp hoặc trường hợp. Tuy nhiên, đây là một vấn đề tôi tìm thấy với hàm băm, liên quan đến các đối tượng:

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

Băm là như nhau, ngay cả sau khi tôi đã thay đổi foo. Điều này là do danh tính của foo chưa thay đổi, vì vậy hàm băm là như nhau. Nếu bạn muốn foo băm khác nhau tùy thuộc vào định nghĩa hiện tại của nó, giải pháp là băm ra bất cứ điều gì thực sự thay đổi. Trong trường hợp này, __dict__thuộc tính:

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

Than ôi, khi bạn cố gắng làm điều tương tự với chính lớp đó:

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

__dict__Thuộc tính lớp không phải là một từ điển bình thường:

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

Đây là một cơ chế tương tự như trước đây sẽ xử lý các lớp một cách thích hợp:

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

Bạn có thể sử dụng điều này để trả về một bộ băm gồm nhiều yếu tố bạn muốn:

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

LƯU Ý: tất cả các mã trên giả định Python 3.x. Không thử nghiệm trong các phiên bản trước, mặc dù tôi giả sử make_hash()sẽ hoạt động trong 2.7.2. Theo như làm công việc ví dụ, tôi làm biết rằng

func.__code__ 

nên được thay thế bằng

func.func_code

Đây là một giải pháp rõ ràng hơn.

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

Mã bên dưới tránh sử dụng hàm băm Python () vì nó sẽ không cung cấp các giá trị băm nhất quán trong quá trình khởi động lại Python (xem hàm băm trong Python 3.3 trả về các kết quả khác nhau giữa các phiên ). make_hashable()sẽ chuyển đổi đối tượng thành các bộ dữ liệu lồng nhau và make_hash_sha256()cũng sẽ chuyển đổi repr()hàm băm SHA256 được mã hóa 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=

Cập nhật từ năm 2013 trả lời ...

Không có câu trả lời nào ở trên có vẻ đáng tin cậy đối với tôi. Lý do là việc sử dụng các mặt hàng (). Theo như tôi biết, điều này xuất hiện theo thứ tự phụ thuộc vào máy.

Làm thế nào về điều này thay thế?

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

Để duy trì trật tự quan trọng, thay vì hash(str(dictionary))hoặc hash(json.dumps(dictionary))tôi thích giải pháp nhanh và bẩn:

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

Nó sẽ hoạt động ngay cả đối với các kiểu như DateTimevà nhiều hơn nữa không phải là tuần tự hóa JSON.

Bạn có thể sử dụng frozendictmô-đun của bên thứ ba để đóng băng chính tả của mình và làm cho nó có thể băm được.

from frozendict import frozendict
my_dict = frozendict(my_dict)

Để xử lý các đối tượng lồng nhau, bạn có thể đi với:

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

Nếu bạn muốn hỗ trợ nhiều loại hơn, hãy sử dụng 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

Bạn có thể sử dụng thư viện bản đồ để làm điều này. Cụ thể, maps.F FrozenMap

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

Để cài đặt maps, chỉ cần làm:

pip install maps

Nó cũng xử lý dicttrường hợp lồng nhau :

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

Tuyên bố miễn trừ trách nhiệm: Tôi là tác giả của mapsthư viện.

Một cách để tiếp cận vấn đề là tạo ra một bộ các mục của từ điển:

hash(tuple(my_dict.items()))

Tôi làm như thế này:

hash(str(my_dict))