主页 / 问题 / 1180125
Accepted
Владислав Харламов
Asked:2020-09-20 02:38:17 +0000 UTC2020-09-20 02:38:17 +0000 UTC

字典的多键

  • 772

有什么方法可以创建一个字典，使多个键适合一个值，而无需创建额外的。字典中的值，工作示例：

dict = {(a, b, c) : value}
dict[a] == value
dict[b] == value
dict[c] == value

无需使用 {a : value, b : value, ...} 创建字典

python

3 个回答

  1. Best Answer

    关键是在这本字典中，我改变了一些地方的键和值。由于该值并不总是可散列的，因此我将其传输到单独的字典并通过对象 ID 链接它。

    这是我得到的基本版本

    class MultiKeyDict():
    def __init__(self):
        self.__keys = {}
        self.__values = {}
    def __setitem__(self, key, value):
        value_id = id(value)
        try:
# старое значение и любой ключ
            self.__keys[value_id].append(key)
            return
        except KeyError:
            pass
# старый ключ и новое значение, связанные ключи тоже изменяются
# можно вместо удаления связи переносить ключ из одного сета в другой - переписать тут
        self.__values[value_id] = value
        for vid, keys in self.__keys.items():
            if key in keys:
                self.__keys.pop(vid)
                self.__values.pop(vid)
                self.__keys[value_id] = self.__keys.get(value_id, set() ) + keys
                break
        else:
# новое значение, новый ключ
            self.__keys[value_id] = set([key]) 
    def __getitem__(self, key):
        for vid, keys in self.__keys():
            if key in keys:
                return self.__values[vid]
        raise KeyError(key)
    def items(self):
# чтоб работать с этим в циклах
        for vid in self.__keys.keys():
            yield (tuple(self.__keys[vid]), self.__values[vid])
    def __repr__(self):
# соберем из двух словарей один
        return repr(dict(self.items()))

    似乎适合这个问题

    >>> a=MultiKeyDict()
>>> a[2]='hello'
>>> a[5]='hello'
>>> a
{(2, 5): 'hello'}
>>>
    • 4

  2. 你可以试试这个选项：

    class MultiDict:
    def __init__(self):
        self.__dict = {}

    def __setitem__(self, key, value):
        try:
            self.__dict[key].append(value)
        except KeyError:
            self.__dict[key] = [value]

    def __getitem__(self, key):
        return self.__dict[key]
    • 2

  3. Python 具有用于创建自己的容器类型的内置功能，其工作方式类似于内置容器（list、dict、tuple）：模拟容器类型。因此，您可以创建一个新类型，用必要的方法填充它，从而获得所需的功能。

    我的解决方案的想法如下：

    例如mlt_dict['a', 'b', 'c'] = "green"

    • 从接收到的key中，我们选择一个，主key，将这个key下的值写入到带值的字典中。

        {
      'a' : "green"
  }

    • 在第二个字典中，我们编写了所有带有主键链接的键。

        {
      'a' : 'a',
      'b' : 'a',
      'c' : 'a'
  }

    • 在第三个字典中，我们将主键与给定值的所有键的链接保持在一起。当删除一个元素以从第二个字典中删除其所有键时需要这样做（基于这样的假设：当通过任何键删除元素时，元素本身和引用它的所有键都被删除）。

        {
      'a' : ('a', 'b', 'c')
  }

    目前，新类型支持添加，删除，检查存在（x in dct），打印出对象的内容。我没有添加检查，以免弄乱解决方案，也不会浪费时间——这段代码只是这个想法的演示。

    class Multi_key_dict:
    def __init__(self, *items):
        self.values_dict = {}
        self.minor_to_major_links = {}
        self.major_to_minor_links = {}

        for keys, value in items:
            self[keys] = value

    def __setitem__(self, keys, value):
        major_key = keys[0]

        for key in keys:
            self.minor_to_major_links[key] = major_key

        self.major_to_minor_links[major_key] = keys
        self.values_dict[major_key] = value
        
    def __getitem__(self, key):
        major_key = self.minor_to_major_links[key]
        return self.values_dict[major_key]

    def __delitem__(self, key):
        major_key = self.minor_to_major_links[key]
        del self.values_dict[major_key]

        for key in self.major_to_minor_links[major_key]:
            del self.minor_to_major_links[key]

        del self.major_to_minor_links[major_key]

    def __contains__(self, key):
        return key in self.minor_to_major_links

    def __repr__(self):
        mlt_dct = ', '.join (f"{keys} : {repr(self.values_dict[major])}" for major, keys in self.major_to_minor_links.items())
        return f"Multi_key_dict({mlt_dct})"

    测试

    mlt_dict = Multi_key_dict(
                            (('a', 'b', 'c'), "green"),
                            (('d', 'e', 'f'), "red"),
                            (('g', 'h', 'i'), "blue"),
                            ((1, 2, 3), "violet"),
                            ((8, 9, 10), ("one", "two", "three"))
                        )

mlt_dict['x', 'y', 'z'] = "orange"

print(mlt_dict['a'])
print(mlt_dict['b'])
print(mlt_dict['c'])

print(mlt_dict['d'])
print(mlt_dict['e'])
print(mlt_dict['f'])

print(mlt_dict['g'])
print(mlt_dict['h'])
print(mlt_dict['i'])
print()

print("{:#^40s}".format("print(mlt_dict)"))
print(mlt_dict)
print()

print("{:#^40s}".format("del mlt_dict['a']"))
del mlt_dict['a']
print()

print("{:#^40s}".format("print(mlt_dict)"))
print(mlt_dict)
print()

print("{:#^40s}".format("print('a' in mlt_dict)"))
print('a' in mlt_dict)
print()

    结果

    green
green
green
red
red
red
blue
blue
blue

############print(mlt_dict)#############
Multi_key_dict(('a', 'b', 'c') : 'green', ('d', 'e', 'f') : 'red', ('g', 'h', 'i') : 'blue', (1, 2, 3) : 'violet', (8, 9, 10) : ('one', 'two', 'three'), ('x', 'y', 'z') : 'orange')

###########del mlt_dict['a']############

############print(mlt_dict)#############
Multi_key_dict(('d', 'e', 'f') : 'red', ('g', 'h', 'i') : 'blue', (1, 2, 3) : 'violet', (8, 9, 10) : ('one', 'two', 'three'), ('x', 'y', 'z') : 'orange')

#########print('a' in mlt_dict)#########
False
    • 2

相关问题