web-dev-qa-db-ja.com

効率的な双方向ハッシュテーブルを実装する方法

Python dictは非常に便利なデータ構造です。

d = {'a': 1, 'b': 2}

d['a'] # get 1

値でインデックスを作成したい場合もあります。

d[1] # get 'a'

このデータ構造を実装する最も効率的な方法はどれですか？公式に推奨される方法はありますか？

pythonhashtablebidirectional
62
Juanjo Conti

Python辞書 の値からキーを検索し、次の2）および3）を許可するように修正された双方向dictのクラスを次に示します。 。

ご了承ください ：

  • 1）逆ディレクトリbd.inverseは、標準のdict bdが変更されると自動的に更新されます。
  • 2）逆ディレクトリbd.inverse[value]は常にkeyのlistであり、bd[key] == value。
  • 3） https://pypi.python.org/pypi/bidict のbidictモジュールとは異なり、ここでは同じ値を持つ2つのキーを持つことができ、これは非常に重要。

コード：

class bidict(dict):
    def __init__(self, *args, **kwargs):
        super(bidict, self).__init__(*args, **kwargs)
        self.inverse = {}
        for key, value in self.items():
            self.inverse.setdefault(value,[]).append(key) 

    def __setitem__(self, key, value):
        if key in self:
            self.inverse[self[key]].remove(key) 
        super(bidict, self).__setitem__(key, value)
        self.inverse.setdefault(value,[]).append(key)        

    def __delitem__(self, key):
        self.inverse.setdefault(self[key],[]).remove(key)
        if self[key] in self.inverse and not self.inverse[self[key]]: 
            del self.inverse[self[key]]
        super(bidict, self).__delitem__(key)

使用例：

bd = bidict({'a': 1, 'b': 2})  
print(bd)                     # {'a': 1, 'b': 2}                 
print(bd.inverse)             # {1: ['a'], 2: ['b']}
bd['c'] = 1                   # Now two keys have the same value (= 1)
print(bd)                     # {'a': 1, 'c': 1, 'b': 2}
print(bd.inverse)             # {1: ['a', 'c'], 2: ['b']}
del bd['c']
print(bd)                     # {'a': 1, 'b': 2}
print(bd.inverse)             # {1: ['a'], 2: ['b']}
del bd['a']
print(bd)                     # {'b': 2}
print(bd.inverse)             # {2: ['b']}
bd['b'] = 3
print(bd)                     # {'b': 3}
print(bd.inverse)             # {2: [], 3: ['b']}
47
Basj

キーと値のペアを逆の順序で追加することにより、同じ辞書自体を使用できます。

 d = {'a'：1、 'b'：2} 
 revd = dict（[reversed（i）for i for d.items（）]）] 
 d .update（revd）
35
Emil

貧乏人の双方向ハッシュテーブルは、2つの辞書のみを使用することです（これらは既に高度に調整されたデータ構造です）。

インデックスには bidict パッケージもあります：

バイディクトのソースはgithubにあります：

32
miku

以下のコードスニペットは、可逆（全単射）マップを実装しています。

class BijectionError(Exception):
    """Must set a unique value in a BijectiveMap."""

    def __init__(self, value):
        self.value = value
        msg = 'The value "{}" is already in the mapping.'
        super().__init__(msg.format(value))


class BijectiveMap(dict):
    """Invertible map."""

    def __init__(self, inverse=None):
        if inverse is None:
            inverse = self.__class__(inverse=self)
        self.inverse = inverse

    def __setitem__(self, key, value):
        if value in self.inverse:
            raise BijectionError(value)

        self.inverse._set_item(value, key)
        self._set_item(key, value)

    def __delitem__(self, key):
        self.inverse._del_item(self[key])
        self._del_item(key)

    def _del_item(self, key):
        super().__delitem__(key)

    def _set_item(self, key, value):
        super().__setitem__(key, value)

この実装の利点は、inverseのBijectiveMap属性が再びBijectiveMapになることです。したがって、次のようなことができます。

>>> foo = BijectiveMap()
>>> foo['steve'] = 42
>>> foo.inverse
{42: 'steve'}
>>> foo.inverse.inverse
{'steve': 42}
>>> foo.inverse.inverse is foo
True
2
jme

このようなもの、おそらく：

import itertools

class BidirDict(dict):
    def __init__(self, iterable=(), **kwargs):
        self.update(iterable, **kwargs)
    def update(self, iterable=(), **kwargs):
        if hasattr(iterable, 'iteritems'):
            iterable = iterable.iteritems()
        for (key, value) in itertools.chain(iterable, kwargs.iteritems()):
            self[key] = value
    def __setitem__(self, key, value):
        if key in self:
            del self[key]
        if value in self:
            del self[value]
        dict.__setitem__(self, key, value)
        dict.__setitem__(self, value, key)
    def __delitem__(self, key):
        value = self[key]
        dict.__delitem__(self, key)
        dict.__delitem__(self, value)
    def __repr__(self):
        return '%s(%s)' % (type(self).__name__, dict.__repr__(self))

複数のキーに特定の値がある場合、何を実行するかを決定する必要があります。特定のペアの双方向性は、後で挿入したペアによって簡単に破壊される可能性があります。可能な選択肢を1つ実装しました。

例：

bd = BidirDict({'a': 'myvalue1', 'b': 'myvalue2', 'c': 'myvalue2'})
print bd['myvalue1']   # a
print bd['myvalue2']   # b
1
Matt Anderson

まず、キーと値のマッピングが1対1であることを確認する必要があります。そうしないと、双方向マップを構築できません。

第二に、データセットはどれくらいの大きさですか？データがあまりない場合は、2つの個別のマップを使用し、更新時に両方を更新します。あるいは、 Bidict のような既存のソリューションを使用してください。これは、2つの辞書のラッパーであり、更新/削除が組み込まれています。

しかし、データセットが大きく、2つの辞書を維持することが望ましくない場合：

  • キーと値の両方が数値の場合、マッピングを近似するために補間を使用する可能性を考慮してください。キーと値のペアの大部分がマッピング関数でカバーできる場合（およびその
    逆関数）、マップ内の外れ値のみを記録する必要があります。

  • アクセスのほとんどが単方向（キー->値）である場合、逆マップをインクリメンタルに作成し、
    スペース。

コード：

d = {1: "one", 2: "two" }
reverse = {}

def get_key_by_value(v):
    if v not in reverse:
        for _k, _v in d.items():
           if _v == v:
               reverse[_v] = _k
               break
    return reverse[v]
0
NeoWang