在 Python 中创建一个带有重复键的字典

Question

我有以下列表，其中包含具有不同值的重复汽车登记号。我想把它转换成一个接受这多个汽车登记号码键的字典。

到目前为止，当我尝试将列表转换为字典时，它消除了其中一个键。如何制作带有重复键的字典？

名单是：

EDF768, Bill Meyer, 2456, Vet_Parking
TY5678, Jane Miller, 8987, AgHort_Parking
GEF123, Jill Black, 3456, Creche_Parking
ABC234, Fred Greenside, 2345, AgHort_Parking
GH7682, Clara Hill, 7689, AgHort_Parking
JU9807, Jacky Blair, 7867, Vet_Parking
KLOI98, Martha Miller, 4563, Vet_Parking
ADF645, Cloe Freckle, 6789, Vet_Parking
DF7800, Jacko Frizzle, 4532, Creche_Parking
WER546, Olga Grey, 9898, Creche_Parking
HUY768, Wilbur Matty, 8912, Creche_Parking
EDF768, Jenny Meyer, 9987, Vet_Parking
TY5678, Jo King, 8987, AgHort_Parking
JU9807, Mike Green, 3212, Vet_Parking

我试过的代码是：

data_dict = {}
data_list = []

def createDictionaryModified(filename):
  path = "C:\Users\user\Desktop"
  basename = "ParkingData_Part3.txt"
  filename = path + "//" + basename
  file = open(filename)
  contents = file.read()
  print contents,"\n"
  data_list = [lines.split(",") for lines in contents.split("\n")]
  for line in data_list:
    regNumber = line[0]
    name = line[1]
    phoneExtn = line[2]
    carpark = line[3].strip()
    details = (name,phoneExtn,carpark)
    data_dict[regNumber] = details
  print data_dict,"\n"
  print data_dict.items(),"\n"
  print data_dict.values()

Answer 1

这是一个老问题，但也许我的解决方案可以帮助某人。

通过覆盖__hash__魔术方法，您可以在dict中保存相同的对象。

例子：

from random import choices

class DictStr(str):
    """
        This class behave exacly like str class but
        can be duplicated in dict
    """
    def __new__(cls, value='', custom_id='', id_length=64):
        # If you want know why I use __new__ instead of __init__
        # SEE: https://stackoverflow.com/a/2673863/9917276
        obj = str.__new__(cls, value)
        if custom_id:
            obj.id = custom_id
        else:
            # Make a string with length of 64
            choice_str = "abcdefghijklmopqrstuvwxyzABCDEFJHIJKLMNOPQRSTUVWXYZ1234567890"
            obj.id = ''.join(choices(choice_str, k=id_length))
        return obj

    def __hash__(self) -> int:
        return self.id.__hash__()

现在让我们创建一个字典：

>>> a_1 = DictStr('a')
>>> a_2 = DictStr('a')
>>> a_3 = 'a'
>>> a_1
a
>>> a_2
a
>>> a_1 == a_2 == a_3
True
>>> d = dict()
>>> d[a_1] = 'some_data'
>>> d[a_2] = 'other'
>>> print(d)
{'a': 'some_data', 'a': 'other'}

注意：此解决方案可以适用于任何基本数据结构，例如 (int, float,...)

解释：

我们几乎可以使用任何对象作为dict 类中的键（或者在其他语言中通常称为HashMap 或HashTable），但是应该有一种方法来区分键，因为dict 不知道对象。

为此，想要以某种方式作为键添加到字典中的对象必须为自己提供一个唯一的标识符号（我将其命名为 uniq_id，它实际上是一个以某种方式使用哈希算法创建的数字）。

由于字典结构在大多数解决方案中广泛使用， 大多数编程语言将对象 uniq_id 生成隐藏在 hash 名称构建方法中，该方法在键搜索中提供 dict

因此，如果您操作类的 hash 方法，您可以将类的行为更改为字典键

Answer 2

字典不支持重复键，你可以使用 defaultdict
下面是如何在python3x中使用defaultdict来解决你的问题的例子

from collections import defaultdict

sdict = defaultdict(list)
keys_bucket = list()

data_list = [lines.split(",") for lines in contents.split("\n")]
for data in data_list:
    key = data.pop(0)
    detail = data
    
    keys_bucket.append(key)
    if key in keys_bucket:
        sdict[key].append(detail)
    else:
        sdict[key] = detail

print("\n", dict(sdict))

以上代码将产生如下输出：

{'EDF768': [[' Bill Meyer', ' 2456', ' Vet_Parking'], [' Jenny Meyer', ' 9987', ' Vet_Parking']], 'TY5678': [[' Jane Miller', ' 8987', ' AgHort_Parking'], [' Jo King', ' 8987', ' AgHort_Parking']], 'GEF123': [[' Jill Black', ' 3456', ' Creche_Parking']], 'ABC234': [[' Fred Greenside', ' 2345', ' AgHort_Parking']], 'GH7682': [[' Clara Hill', ' 7689', ' AgHort_Parking']], 'JU9807': [[' Jacky Blair', ' 7867', ' Vet_Parking'], [' Mike Green', ' 3212', ' Vet_Parking']], 'KLOI98': [[' Martha Miller', ' 4563', ' Vet_Parking']], 'ADF645': [[' Cloe Freckle', ' 6789', ' Vet_Parking']], 'DF7800': [[' Jacko Frizzle', ' 4532', ' Creche_Parking']], 'WER546': [[' Olga Grey', ' 9898', ' Creche_Parking']], 'HUY768': [[' Wilbur Matty', ' 8912', ' Creche_Parking']]}

Answer 3

您可以参考以下文章： http://www.wellho.net/mouth/3934_Multiple-identical-keys-in-a-Python-dict-yes-you-can-.html

在字典中，如果一个键是一个对象，则没有重复的问题。

例如：

class p(object):
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return self.name
    def __str__(self):
        return self.name
d = {p('k'): 1, p('k'): 2}

Answer 4

如果您希望仅在必要时拥有列表，并在任何其他情况下使用值，那么您可以这样做：

class DictList(dict):
    def __setitem__(self, key, value):
        try:
            # Assumes there is a list on the key
            self[key].append(value)
        except KeyError: # If it fails, because there is no key
            super(DictList, self).__setitem__(key, value)
        except AttributeError: # If it fails because it is not a list
            super(DictList, self).__setitem__(key, [self[key], value])

然后您可以执行以下操作：

dl = DictList()
dl['a']  = 1
dl['b']  = 2
dl['b'] = 3

其中将存储以下{'a': 1, 'b': [2, 3]}。

---

当我想要反向/反向字典时，我倾向于使用此实现，在这种情况下我只是这样做：

my_dict = {1: 'a', 2: 'b', 3: 'b'}
rev = DictList()
for k, v in my_dict.items():
    rev_med[v] = k

这将产生与上面相同的输出：{'a': 1, 'b': [2, 3]}。

---

CAVEAT： 此实现依赖于不存在 append 方法（在您存储的值中）。如果您存储的值是列表，这可能会产生意外结果。例如，

dl = DictList()
dl['a']  = 1
dl['b']  = [2]
dl['b'] = 3

将产生与{'a': 1, 'b': [2, 3]} 之前相同的结果，但可能会出现以下结果：{'a': 1, 'b': [[2], 3]}。

Answer 5

您可以更改 Python 中内置类型的行为。对于您的情况，创建一个 dict 子类非常容易，该子类将自动将重复值存储在同一键下的列表中：

class Dictlist(dict):
    def __setitem__(self, key, value):
        try:
            self[key]
        except KeyError:
            super(Dictlist, self).__setitem__(key, [])
        self[key].append(value)

输出示例：

>>> d = dictlist.Dictlist()
>>> d['test'] = 1
>>> d['test'] = 2
>>> d['test'] = 3
>>> d
{'test': [1, 2, 3]}
>>> d['other'] = 100
>>> d
{'test': [1, 2, 3], 'other': [100]}

Answer 6

字典中不能有重复的键。使用列表的字典：

for line in data_list:
  regNumber = line[0]
  name = line[1]
  phoneExtn = line[2]
  carpark = line[3].strip()
  details = (name,phoneExtn,carpark)
  if not data_dict.has_key(regNumber):
    data_dict[regNumber] = [details]
  else:
    data_dict[regNumber].append(details)

Answer 7

你不能有一个带有重复键的字典来定义！ 相反，您可以使用单个键，并将具有该键的元素列表作为值。

因此您可以按照以下步骤操作：

1. 查看当前元素的（初始集合中的）键是否在最终字典中。如果是，请转到第 3 步
2. 用键更新字典
3. 将新值附加到 dict[key] 列表中
4. 重复 [1-3]

Answer 8

我刚刚发布了一个问题的答案，该问题随后作为该问题的副本关闭（我认为有充分的理由），但我很惊讶地看到我提出的解决方案未包含在此处的任何答案中。

您可以使用setdefault 方法轻松地将值附加到字典中的列表中，而不是使用defaultdict 或搞乱成员资格测试或手动异常处理：

results = {}                              # use a normal dictionary for our output
for k, v in some_data:                    # the keys may be duplicates
    results.setdefault(k, []).append(v)   # magic happens here!

这很像使用默认字典，但您不需要特殊的数据类型。当您调用setdefault 时，它会检查第一个参数（键）是否已经在字典中。如果没有找到任何东西，它会将第二个参数（默认值，在这种情况下为空列表）分配为键的新值。如果密钥确实存在，则不做任何特殊处理（默认未使用）。不过，无论哪种情况，都会返回值（无论是旧的还是新的），因此我们可以无条件地对其调用 append，知道它应该始终是一个列表。

Answer 9

Python 字典不支持重复键。一种解决方法是将列表或集合存储在字典中。

一个简单的方法是使用defaultdict：

from collections import defaultdict

data_dict = defaultdict(list)

你所要做的就是替换

data_dict[regNumber] = details

与

data_dict[regNumber].append(details)

你会得到一个列表字典。