150 lines
4.3 KiB
Python
150 lines
4.3 KiB
Python
from collections import UserList
|
|
from typing import Any, Iterator
|
|
|
|
|
|
class Lict(UserList): # TODO: 优化同步(惰性同步), 当前性能为 O(n)
|
|
""" "列典" 对象
|
|
|
|
同时兼容字典和列表大多数 API, 两边数据同步的容器
|
|
列表数据是 dictobj.items() 的格式
|
|
支持根据字典或列表初始化
|
|
限制要求:
|
|
- 键名一定唯一, 且仅能为字符串
|
|
- 值一定是引用对象
|
|
- 不使用并发
|
|
- 不在乎列表顺序语义(严格按键名字符序排列)和列表索引查找, 因此外部的 sort, index 等功能不可用
|
|
- append 的元组中, 表示键名的元素不能重复, 否则会导致覆盖行为
|
|
|
|
只有在 Python 3.7+ 中, forced_order 行为才能被取消.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
initlist: list | None = None,
|
|
initdict: dict | None = None,
|
|
forced_order=True,
|
|
):
|
|
self.dicted_data = {}
|
|
if initdict != None:
|
|
initlist = list(initdict.items())
|
|
super().__init__(initlist=initlist)
|
|
self.forced_order = forced_order
|
|
self._sync_based_on_list()
|
|
if self.forced_order:
|
|
self.data.sort()
|
|
|
|
def _sync_based_on_dict(self):
|
|
self.data = list(self.dicted_data.items())
|
|
if self.forced_order:
|
|
self.data.sort()
|
|
|
|
def _sync_based_on_list(self):
|
|
self.dicted_data = {}
|
|
for i in self.data:
|
|
self.dicted_data[i[0]] = i[1]
|
|
|
|
def __iter__(self) -> Iterator:
|
|
return self.data.__iter__()
|
|
|
|
def __getitem__(self, i):
|
|
if isinstance(i, str):
|
|
return self.dicted_data[i]
|
|
else:
|
|
return super().__getitem__(i)
|
|
|
|
def get_itemic_unit(self, ident):
|
|
return (ident, self.dicted_data[ident])
|
|
|
|
def __setitem__(self, i, item):
|
|
if isinstance(i, str):
|
|
self.dicted_data[i] = item
|
|
self._sync_based_on_dict()
|
|
else:
|
|
if item != (item[0], item[1]):
|
|
raise NotImplementedError
|
|
super().__setitem__(i, item)
|
|
self._sync_based_on_list()
|
|
|
|
def __delitem__(self, i):
|
|
if isinstance(i, str):
|
|
del self.dicted_data[i]
|
|
self._sync_based_on_dict()
|
|
else:
|
|
super().__delitem__(i)
|
|
self._sync_based_on_list()
|
|
|
|
def __contains__(self, item):
|
|
return item in self.data or item in self.keys() or item in self.values()
|
|
|
|
def append(self, item: Any) -> None:
|
|
if item != (item[0], item[1]):
|
|
raise NotImplementedError
|
|
super().append(item)
|
|
self._sync_based_on_list()
|
|
if self.forced_order:
|
|
self.data.sort()
|
|
|
|
def append_new(self, item: Any):
|
|
if item != (item[0], item[1]):
|
|
raise NotImplementedError
|
|
if item[0] not in self:
|
|
super().append(item)
|
|
self._sync_based_on_list()
|
|
if self.forced_order:
|
|
self.data.sort()
|
|
|
|
def insert(self, i: int, item: Any) -> None:
|
|
if item != (item[0], item[1]): # 确保 item 是遵从限制的元组
|
|
raise NotImplementedError
|
|
super().insert(i, item)
|
|
self._sync_based_on_list()
|
|
if self.forced_order:
|
|
self.data.sort()
|
|
|
|
def pop(self, i: int = -1) -> Any:
|
|
res = super().pop(i)
|
|
self._sync_based_on_list()
|
|
return res
|
|
|
|
def remove(self, item: Any) -> None:
|
|
if isinstance(item, str):
|
|
item = (item, self.dicted_data[item])
|
|
if item != (item[0], item[1]):
|
|
raise NotImplementedError
|
|
super().remove(item)
|
|
self._sync_based_on_list()
|
|
if self.forced_order:
|
|
self.data.sort()
|
|
|
|
def clear(self) -> None:
|
|
super().clear()
|
|
self._sync_based_on_list()
|
|
|
|
def index(self):
|
|
raise NotImplementedError
|
|
|
|
def extend(self):
|
|
raise NotImplementedError
|
|
|
|
def sort(self):
|
|
raise NotImplementedError
|
|
|
|
def reverse(self):
|
|
raise NotImplementedError
|
|
|
|
def keys(self):
|
|
return self.dicted_data.keys()
|
|
|
|
def values(self):
|
|
return self.dicted_data.values()
|
|
|
|
def items(self):
|
|
return self.data
|
|
|
|
def keys_equal_with(self, other):
|
|
return self.key_equality(self, other)
|
|
|
|
@classmethod
|
|
def key_equality(cls, a, b):
|
|
return a.keys() == b.keys()
|