0

我正在处理文本并且需要存储大量可散列对象 - 有时是字符串，有时是单词元组等。我一直在考虑使用散列函数来提供一个简单的存储和检索类，但我的第一种方法是单个哈希键可能会解析为多个项目。鉴于我添加了一个将 add 的返回值作为参数的 get 函数，我无法知道要返回列表中的哪个项目。

class HashStore:
    def __init__(self):
        self.uniques = {}

    def add(self, big_hashable):
        hash_value = hash(big_hashable)
        if hash_value not in self.uniques:
            self.uniques[hash_value] = [big_hashable]
        elif big_hashable not in self.uniques[hash_value]:
            self.uniques[hash_value].append(big_hashable)

        return hash_value

另一种方法最终确保每个唯一的可散列项只有一个映射。

class SingleStore:
    def __init__(self):
        self.uniques = {}
        self.indexed = {}
        self.index = 0

    def add(self, big_hashable):
        if big_hashable not in self.uniques:
            self.index += 1
            self.uniques[big_hashable] = self.index
            self.indexed[self.index] = big_hashable

        return self.uniques[big_hashable]

这有效并确保 add 的返回值可用于返回唯一值。只是看起来有点笨拙。有没有更好、更 Pythonic 的方式来处理这种情况？

我对这个问题一直模棱两可。有两个问题 - 一个是我有数百万个对象当前正在使用从 100 到 1000 字节的键（big_hashable 的东西）。将它们转换为整数可以处理比我目前更多的数据。其次，只保留每个 big_hashable 事物的单个规范副本也会减少内存使用量，尽管这是引发我的问题的第一个问题，因为每个键实际上都是 big_hashable 事物的单独副本。

4

1 回答 1

2

如果您不需要能够有效地检索给定不同副本的对象的规范副本，则可以只使用一个集合：

s = set()
s.add(3)
s.add(3)
# s only has one 3 in it

如果您确实需要能够有效地检索对象的规范副本，请不要按哈希值存储它们——那会被严重破坏。直接使用 hashable 即可。

class Interner(object):
    def __init__(self):
        self._store = {}
    def canonical_object(self, thing):
        """Returns a canonical object equal to thing.

        Always returns the same result for equal things.

        """

        return self._store.setdefault(thing, thing)

使用该weakref模块，您可以改进它以在客户端代码放开它时不保留规范对象，就像内置intern函数对字符串所做的那样。

于 2013-08-23T19:27:50.700 回答