Wie implementiert man eine effiziente bidirektionale Hash-Tabelle in Python?

Implementierung einer effizienten bidirektionalen Hash-Tabelle

Eine bidirektionale Hash-Tabelle ermöglicht sowohl Schlüssel-zu-Wert- als auch Wert-zu-Schlüssel-Suchen. Die integrierte Diktdatenstruktur von Python eignet sich zwar hervorragend für Schlüssel-zu-Wert-Suchen, bietet jedoch keine effizienten Wert-zu-Schlüssel-Abrufe.

Eine effektive Methode zum Implementieren einer bidirektionalen Hash-Tabelle ist die Verwendung einer Klasse das erweitert das Standarddikt. Diese Klasse mit dem Namen „bidict“ verwaltet ein inverses Verzeichnis, das bei allen Änderungen am regulären „dict“ automatisch aktualisiert wird.

Code-Implementierung:

<code class="python">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)</code>

Hauptfunktionen :

• Das inverse Verzeichnis (bd.inverse) ist ein Wörterbuch, das Werte einer Liste von Schlüsseln mit diesem Wert zuordnet.
• Das inverse Verzeichnis wird beim Bidict automatisch aktualisiert wird geändert.
• Im Gegensatz zu einigen Bidict-Implementierungen ermöglicht diese Klasse, dass mehrere Schlüssel denselben Wert haben.

Verwendungsbeispiel:

<code class="python">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']}</code>

Das obige ist der detaillierte Inhalt vonWie implementiert man eine effiziente bidirektionale Hash-Tabelle in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!