Двостороння / зворотна карта [дублікат]

Я роблю цю справу з комутацією в python, де мені потрібно відслідковувати, хто з ким спілкується, тож якщо Аліса -> Боб, то це означає, що Боб -> Аліса.

Так, я можу заповнити дві хеш-карти, але мені цікаво, чи є у когось ідея зробити це з однією.

Або запропонувати іншу структуру даних.

Немає кількох розмов. Скажімо, це для центру обслуговування клієнтів, тож коли Аліса набирає номер у комутаційному щиті, вона збирається поговорити лише з Боб. Його відповіді також стосуються лише її.

Ви можете створити свій власний тип словника шляхом підкласифікації dictта додавання потрібної логіки. Ось основний приклад:

class TwoWayDict(dict):
    def __setitem__(self, key, value):
        # Remove any previous connections with these values
        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):
        dict.__delitem__(self, self[key])
        dict.__delitem__(self, key)

    def __len__(self):
        """Returns the number of connections"""
        return dict.__len__(self) // 2

І це працює так:

>>> d = TwoWayDict()
>>> d['foo'] = 'bar'
>>> d['foo']
'bar'
>>> d['bar']
'foo'
>>> len(d)
1
>>> del d['foo']
>>> d['bar']
Traceback (most recent call last):
  File "<stdin>", line 7, in <module>
KeyError: 'bar'

Я впевнений, що я не охоплював усіх справ, але це повинно вас почати.

У вашому спеціальному випадку ви можете зберігати обидва в одному словнику:

relation = {}
relation['Alice'] = 'Bob'
relation['Bob'] = 'Alice'

Оскільки те, що ви описуєте, - це симетричні відносини. A -> B => B -> A

Я знаю, що це давнє питання, але я хотів зазначити ще одне чудове рішення цієї проблеми, а саме пакет python bidict . Це надзвичайно прямо вперед:

from bidict import bidict
map = bidict(Bob = "Alice")
print(map["Bob"])
print(map.inv["Alice"])

Я би просто заповнив другий хеш, с

reverse_map = dict((reversed(item) for item in forward_map.items()))

Дві карти хеша - це, мабуть, найшвидше рішення, якщо ви можете зекономити пам'ять. Я б переклав їх в один клас - тягар на програміста полягає в тому, щоб дві хеш-карти правильно синхронізувалися.

У вас є два окремих питання.

1. У вас є об’єкт "Бесіда". Це стосується двох осіб. Оскільки людина може вести кілька розмов, у вас є стосунки «багато до багатьох».

2. У вас є карта від людини до списку розмов. Конверсія матиме пару осіб.

Зробіть щось подібне

from collections import defaultdict
switchboard= defaultdict( list )

x = Conversation( "Alice", "Bob" )
y = Conversation( "Alice", "Charlie" )

for c in ( x, y ):
    switchboard[c.p1].append( c )
    switchboard[c.p2].append( c )

Ні, насправді немає способу зробити це без створення двох словників. Як можна було б реалізувати це лише одним словником, продовжуючи пропонувати порівнянні показники?

Вам краще створити користувацький тип, який інкапсулює два словники та відкриває потрібну функціональність.

Менш багатослівний спосіб, як і раніше використовується зворотний:

dict(map(reversed, my_dict.items()))

Можливо, ви зможете скористатись таким, DoubleDictяк показано в рецепті 578224 на кулінарній книзі Python .

Іншим можливим рішенням є реалізація підкласу dict, який містить оригінальний словник та відслідковує перевернуту його версію. Зберігання двох окремих диктовок може бути корисним, якщо ключі та значення перетинаються.

class TwoWayDict(dict):
    def __init__(self, my_dict):
        dict.__init__(self, my_dict)
        self.rev_dict = {v : k for k,v in my_dict.iteritems()}

    def __setitem__(self, key, value):
        dict.__setitem__(self, key, value)
        self.rev_dict.__setitem__(value, key)

    def pop(self, key):
        self.rev_dict.pop(self[key])
        dict.pop(self, key)

    # The above is just an idea other methods
    # should also be overridden. 

Приклад:

>>> d = {'a' : 1, 'b' : 2} # suppose we need to use d and its reversed version
>>> twd = TwoWayDict(d)    # create a two-way dict
>>> twd
{'a': 1, 'b': 2}
>>> twd.rev_dict
{1: 'a', 2: 'b'}
>>> twd['a']
1
>>> twd.rev_dict[2]
'b'
>>> twd['c'] = 3    # we add to twd and reversed version also changes
>>> twd
{'a': 1, 'c': 3, 'b': 2}
>>> twd.rev_dict
{1: 'a', 2: 'b', 3: 'c'}
>>> twd.pop('a')   # we pop elements from twd and reversed  version changes
>>> twd
{'c': 3, 'b': 2}
>>> twd.rev_dict
{2: 'b', 3: 'c'}

Існує розширена колекція бібліотеки на pypi: https://pypi.python.org/pypi/collections-extended/0.6.0

Використовувати клас біекції так само просто, як:

RESPONSE_TYPES = bijection({
    0x03 : 'module_info',
    0x09 : 'network_status_response',
    0x10 : 'trust_center_device_update'
})
>>> RESPONSE_TYPES[0x03]
'module_info'
>>> RESPONSE_TYPES.inverse['network_status_response']
0x09

Мені подобається пропозиція бідікт в одному з коментарів.

pip install bidict

Використання:

# This normalization method should save hugely as aDaD ~ yXyX have the same form of smallest grammar.
# To get back to your grammar's alphabet use trans

def normalize_string(s, nv=None):
    if nv is None:
        nv = ord('a')
    trans = bidict()
    r = ''
    for c in s:
        if c not in trans.inverse:
            a = chr(nv)
            nv += 1
            trans[a] = c
        else:
            a = trans.inverse[c]
        r += a
    return r, trans


def translate_string(s, trans):
    res = ''
    for c in s:
        res += trans[c]
    return res


if __name__ == "__main__":
    s = "bnhnbiodfjos"

    n, tr = normalize_string(s)
    print(n)
    print(tr)
    print(translate_string(n, tr))    

Оскільки про це не так багато документів. Але у мене є всі функції, які мені потрібні, щоб він працював правильно.

Друкує:

abcbadefghei
bidict({'a': 'b', 'b': 'n', 'c': 'h', 'd': 'i', 'e': 'o', 'f': 'd', 'g': 'f', 'h': 'j', 'i': 's'})
bnhnbiodfjos

Модуль розширення kjbuckets C забезпечує структуру даних "графік", яка, на мою думку, дає вам те, що ви хочете.

Ось ще одна двостороння реалізація словника шляхом розширення dictкласу pythons, якщо вам не сподобався жоден з цих:

class DoubleD(dict):
    """ Access and delete dictionary elements by key or value. """ 

    def __getitem__(self, key):
        if key not in self:
            inv_dict = {v:k for k,v in self.items()}
            return inv_dict[key]
        return dict.__getitem__(self, key)

    def __delitem__(self, key):
        if key not in self:
            inv_dict = {v:k for k,v in self.items()}
            dict.__delitem__(self, inv_dict[key])
        else:
            dict.__delitem__(self, key)

Використовуйте його як звичайний словник python, за винятком будівництва:

dd = DoubleD()
dd['foo'] = 'bar'

Спосіб, який я люблю робити подібні речі, є чимось на кшталт:

{my_dict[key]: key for key in my_dict.keys()}