แปลพจนานุกรม

เพื่อวัตถุประสงค์ในการแคชฉันต้องสร้างแคชคีย์จากข้อโต้แย้ง GET ซึ่งมีอยู่ใน dict

ขณะนี้ฉันกำลังใช้sha1(repr(sorted(my_dict.items())))( sha1()เป็นวิธีการอำนวยความสะดวกที่ใช้hashlibภายใน) แต่ฉันอยากรู้ว่ามีวิธีที่ดีกว่านี้หรือไม่

หากพจนานุกรมของคุณไม่ซ้อนคุณสามารถสร้างไอเท็มได้หลายอย่างพร้อมไอเท็มของ 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 ที่เรียบง่ายกว่า (และเร็วกว่า) (ซึ่งใช้ได้กับพจนานุกรมที่ซ้อนกัน)

แม้ว่าคำตอบจะได้รับการยอมรับ แต่ชื่อของคำถามคือ "Hashing a python Dictionary" และคำตอบนั้นไม่สมบูรณ์ตามชื่อเรื่องนั้น (สำหรับเนื้อหาของคำถามคำตอบนั้นสมบูรณ์)

พจนานุกรมที่ซ้อนกัน

หากมีใครค้นหา Stack Overflow สำหรับวิธีการแฮชพจนานุกรมหนึ่งอาจสะดุดกับคำถามที่เหมาะเจาะนี้และปล่อยให้ไม่พอใจถ้ามีใครพยายามแฮชพจนานุกรมที่ซ้อนกันหลายตัว คำตอบข้างต้นจะไม่ทำงานในกรณีนี้และคุณจะต้องใช้กลไกแบบเรียกซ้ำเพื่อดึงข้อมูลแฮช

นี่คือกลไกหนึ่งอย่าง:

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 hash แตกต่างกันไปขึ้นอยู่กับคำจำกัดความปัจจุบันโซลูชันจะ hash off สิ่งที่เปลี่ยนแปลงจริง ในกรณีนี้__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()))))

คุณสามารถใช้สิ่งนี้เพื่อส่งกลับ hup tuple ขององค์ประกอบหลายอย่างที่คุณต้องการ:

# -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 hash () เพราะจะไม่ให้แฮชที่สอดคล้องกันตลอดการรีสตาร์ท Python (ดูฟังก์ชันแฮชใน Python 3.3 จะให้ผลลัพธ์ที่แตกต่างกันระหว่างเซสชัน ) make_hashable()จะแปลงวัตถุเป็น tuples ที่ซ้อนกันและmake_hash_sha256()จะแปลงrepr()เป็นแฮช SHA256 ที่เข้ารหัส 64 ด้วย

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โมดูลของบุคคลที่สามเพื่อตรึง 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

คุณสามารถใช้ไลบรารีแผนที่เพื่อทำสิ่งนี้ โดยเฉพาะแผนที่ 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))