Bản đồ hai chiều / ngược lại [trùng lặp]

Tôi đang làm điều này trong tổng đài bằng python, nơi tôi cần theo dõi ai đang nói chuyện với ai, vì vậy nếu Alice -> Bob, thì điều đó ngụ ý rằng Bob -> Alice.

Có, tôi có thể điền vào hai bản đồ băm, nhưng tôi đang tự hỏi liệu có ai có ý tưởng làm điều đó với một bản đồ không.

Hoặc đề xuất cấu trúc dữ liệu khác.

Không có nhiều cuộc trò chuyện. Giả sử đây là cho một trung tâm cuộc gọi dịch vụ khách hàng, vì vậy khi Alice gọi vào tổng đài, cô ấy sẽ chỉ nói chuyện với Bob. Những câu trả lời của anh cũng chỉ dành cho cô.

Bạn có thể tạo loại từ điển của riêng mình bằng cách phân lớp con dict và thêm logic mà bạn muốn. Đây là một ví dụ cơ bản:

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

Và nó hoạt động như vậy:

>>> 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'

Tôi chắc chắn rằng tôi đã không bao gồm tất cả các trường hợp, nhưng điều đó sẽ giúp bạn bắt đầu.

Trong trường hợp đặc biệt của bạn, bạn có thể lưu trữ cả hai trong một từ điển:

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

Vì những gì bạn đang mô tả là một mối quan hệ đối xứng. A -> B => B -> A

Tôi biết đó là một câu hỏi cũ, nhưng tôi muốn đề cập đến một giải pháp tuyệt vời cho vấn đề này, cụ thể là gói python bidict . Nó cực kỳ dễ sử dụng:

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

Tôi sẽ chỉ điền một băm thứ hai, với

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

Hai bản đồ băm thực sự có lẽ là giải pháp hoạt động nhanh nhất giả sử bạn có thể dành bộ nhớ. Tôi sẽ gói chúng trong một lớp duy nhất - gánh nặng đối với lập trình viên là đảm bảo rằng hai bản đồ băm đồng bộ hóa chính xác.

Bạn có hai vấn đề riêng biệt.

1. Bạn có một đối tượng "Hội thoại". Nó đề cập đến hai Ngôi vị. Vì một người có thể có nhiều cuộc trò chuyện, bạn có một mối quan hệ nhiều-nhiều.

2. Bạn có Bản đồ từ Người đến danh sách Cuộc trò chuyện. Một Chuyển đổi sẽ có một cặp Người.

Làm điều gì đó như thế này

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 )

Không, thực sự không có cách nào để làm điều này mà không tạo hai từ điển. Làm thế nào để có thể thực hiện điều này chỉ với một từ điển trong khi vẫn tiếp tục cung cấp hiệu suất tương đương?

Tốt hơn hết là bạn nên tạo một kiểu tùy chỉnh bao gồm hai từ điển và hiển thị chức năng bạn muốn.

Một cách ít dài dòng hơn, vẫn sử dụng đảo ngược:

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

Bạn có thể sử dụng một DoubleDictnhư được hiển thị trong công thức 578224 trên Python Cookbook .

Một giải pháp khả thi khác là triển khai một lớp con của dict, chứa từ điển gốc và theo dõi phiên bản đảo ngược của nó. Giữ hai vùng riêng biệt có thể hữu ích nếu các khóa và giá trị trùng nhau.

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. 

Thí dụ:

>>> 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'}

Có thư viện mở rộng bộ sưu tập trên pypi: https://pypi.python.org/pypi/collections-extended/0.6.0

Sử dụng lớp bijection dễ dàng như:

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

Tôi thích đề xuất của bidict trong một trong các bình luận.

pip install bidict

Sử dụng:

# 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))    

Vì không có nhiều tài liệu về nó. Nhưng tôi có tất cả các tính năng tôi cần từ nó hoạt động bình thường.

Bản in:

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

Mô-đun mở rộng kjbuckets C cung cấp cấu trúc dữ liệu "đồ thị" mà tôi tin rằng sẽ cung cấp cho bạn những gì bạn muốn.

Dưới đây là một cách triển khai từ điển hai chiều nữa bằng cách mở rộng dictlớp pythons trong trường hợp bạn không thích bất kỳ lớp nào khác trong số đó:

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)

Sử dụng nó như một từ điển python bình thường ngoại trừ trong xây dựng:

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

Một cách tôi thích làm loại việc này là:

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