Python dictlà một cấu trúc dữ liệu rất hữu ích:
d = {'a': 1, 'b': 2}
d['a'] # get 1
Đôi khi bạn cũng muốn lập chỉ mục theo các giá trị.
d[1] # get 'a'
Cách hiệu quả nhất để triển khai cấu trúc dữ liệu này là gì? Bất kỳ chính thức khuyến nghị cách để làm điều đó?
{1: ['a', 'A'], 2: 'b'}. Hãy xem câu trả lời của tôi để biết cách làm như vậy.
Câu trả lời:
Đây là một lớp cho một hai chiều dict, lấy cảm hứng từ Tìm khóa từ giá trị trong từ điển Python và được sửa đổi để cho phép 2) và 3) sau.
Lưu ý rằng:
bd.inverse tự động cập nhật khi bdsửa đổi chính tả tiêu chuẩn .bd.inverse[value] luôn là một danh sách các keyví dụ đó bd[key] == value.bidictmô-đun từ https://pypi.python.org/pypi/bidict , ở đây chúng ta có thể có 2 khóa có cùng giá trị, điều này rất quan trọng .Mã:
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)
Ví dụ sử dụng:
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']}
self[key]trong __delitem__()với một value = self[key]nhiệm vụ duy nhất được sử dụng lại cho các tra cứu như vậy. Nhưng ... vâng. Đó là không đáng kể. Cảm ơn vì sự tuyệt vời thuần khiết, Basj !
Bạn có thể sử dụng cùng một mệnh đề bằng cách thêm cặp khóa, cặp giá trị theo thứ tự ngược lại.
d = {'a': 1, 'b': 2}
revd = dict ([đảo ngược (i) cho tôi trong d.items ()])
d. cập nhật (revd)
d.update( dict((d[k], k) for k in d) ).
dict((v, k) for (k, v) in d.items()). Trong mọi trường hợp, bạn có thể chuyển các cặp trực tiếp đến .update : d.update(reversed(i) for i in d.items()).
d={'a':1, 'b':2, 1: 'b'}
dict(map(reversed, a_dict.items())).
d.update(revd)Tuy nhiên, vì hai dòng đầu tiên của câu trả lời này bỏ qua phần cuối là điều tuyệt vời, tôi vẫn đang suy tính về một sự ủng hộ. Hãy suy nghĩ về điều này.
Bảng băm hai chiều của một người nghèo sẽ chỉ sử dụng hai từ điển (đây là những cấu trúc dữ liệu đã được tinh chỉnh cao).
Ngoài ra còn có một bidict gói trên các chỉ số:
Nguồn cho bidict có thể được tìm thấy trên github:
Đoạn mã dưới đây triển khai một bản đồ (bijective) có thể đảo ngược:
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)
Ưu điểm của cách triển khai này là inversethuộc tính của a BijectiveMaplại là a BijectiveMap. Do đó, bạn có thể làm những việc như:
>>> foo = BijectiveMap()
>>> foo['steve'] = 42
>>> foo.inverse
{42: 'steve'}
>>> foo.inverse.inverse
{'steve': 42}
>>> foo.inverse.inverse is foo
True
Một cái gì đó như thế này, có thể:
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))
Bạn phải quyết định điều gì bạn muốn xảy ra nếu nhiều hơn một khóa có giá trị nhất định; tính hai chiều của một cặp nhất định có thể dễ dàng bị che lấp bởi một số cặp sau đó bạn đã chèn. Tôi đã thực hiện một lựa chọn khả thi.
Thí dụ :
bd = BidirDict({'a': 'myvalue1', 'b': 'myvalue2', 'c': 'myvalue2'})
print bd['myvalue1'] # a
print bd['myvalue2'] # b
dict([('a', 'b'), ('b', 'c')]); dict['b']-> 'c'thay vì phím 'a'.
print bd['myvalue2']câu trả lời đó b, c(hoặc [b, c], hoặc (b, c), hoặc bất cứ điều gì khác)?
Đầu tiên, bạn phải đảm bảo chìa khóa của ánh xạ giá trị là 1-1, nếu không, không thể xây dựng bản đồ hai chiều.
Thứ hai, tập dữ liệu lớn như thế nào? Nếu không có nhiều dữ liệu, chỉ cần sử dụng 2 bản đồ riêng biệt, và cập nhật cả 2 bản đồ khi cập nhật. Hoặc tốt hơn, sử dụng một giải pháp hiện có như Bidict , chỉ là một gói bao gồm 2 phần, với cập nhật / xóa được tích hợp sẵn.
Nhưng nếu tập dữ liệu lớn và việc duy trì 2 vùng là không mong muốn:
Nếu cả khóa và giá trị đều là số, hãy xem xét khả năng sử dụng Nội suy để ánh xạ gần đúng. Nếu phần lớn các cặp khóa-giá trị có thể được bao hàm bởi chức năng ánh xạ (và
chức năng đảo ngược của nó ), thì bạn chỉ cần ghi lại các ngoại lệ trong bản đồ.
Nếu phần lớn quyền truy cập là đơn hướng (key-> value), thì bạn hoàn toàn có thể xây dựng bản đồ ngược theo từng bước, để đánh đổi thời gian lấy
không gian.
Mã:
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]
Thật không may, câu trả lời được đánh giá cao nhất, bidictkhông hoạt động.
Có ba lựa chọn:
Lớp con dict : Bạn có thể tạo một lớp con của dict, nhưng hãy cẩn thận. Bạn cần phải viết triển khai tùy chỉnh của update, pop, initializer, setdefault. Các dicttriển khai không gọi __setitem__. Đây là lý do tại sao câu trả lời được đánh giá cao nhất có vấn đề.
Kế thừa từ UserDict : Đây giống như một câu lệnh, ngoại trừ tất cả các quy trình được thực hiện để gọi một cách chính xác. Nó sử dụng một mệnh đề dưới mui xe, trong một mục được gọi là data. Bạn có thể đọc Tài liệu Python hoặc sử dụng cách triển khai đơn giản của danh sách theo hướng hoạt động trong Python 3 . Xin lỗi vì đã không bao gồm nguyên văn: Tôi không chắc về bản quyền của nó.
Kế thừa từ các lớp cơ sở trừu tượng : Kế thừa từ collection.abc sẽ giúp bạn nhận được tất cả các giao thức và triển khai chính xác cho một lớp mới. Điều này là quá mức cần thiết đối với từ điển hai chiều, trừ khi nó cũng có thể mã hóa và lưu vào bộ nhớ cache vào cơ sở dữ liệu.
TL; DR - Sử dụng cái này cho mã của bạn. Đọc bài báo của Trey Hunner để biết thêm chi tiết.