独特词典列表-IT科技

摘要：问题描述：假设我有一个字典列表：[ {'id': 1, 'name': 'john', 'age': 34}, {'id': 1, 'name': 'john', 'age': 34}, {'id': 2, 'name': 'hanna', 'age': 30}, ] 如何获取唯一词典...

问题描述：

假设我有一个字典列表：

[
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]

如何获取唯一词典列表（删除重复项）？

[
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]

请参阅如何使用一组通用键正确地对字典进行哈希处理以进行重复数据删除？以深入、技术性地讨论为什么通常的列表重复数据删除方法（在删除列表中的重复项中解释）不起作用。

解决方案 1：

因此，创建一个临时字典，其键为id。这会过滤掉重复项。values()字典的将是列表

在Python2.7中

>>> L=[
... {'id':1,'name':'john', 'age':34},
... {'id':1,'name':'john', 'age':34},
... {'id':2,'name':'hanna', 'age':30},
... ]
>>> {v['id']:v for v in L}.values()
[{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

在 Python3 中

>>> L=[
... {'id':1,'name':'john', 'age':34},
... {'id':1,'name':'john', 'age':34},
... {'id':2,'name':'hanna', 'age':30},
... ] 
>>> list({v['id']:v for v in L}.values())
[{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

在 Python2.5/2.6 中

>>> L=[
... {'id':1,'name':'john', 'age':34},
... {'id':1,'name':'john', 'age':34},
... {'id':2,'name':'hanna', 'age':30},
... ] 
>>> dict((v['id'],v) for v in L).values()
[{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

解决方案 2：

查找集合中常见元素的常用方法是使用 Python 的set类。只需将所有元素添加到集合中，然后将集合转换为list，然后重复项就会消失。

当然，问题在于 aset()只能包含可散列的条目，而 adict不可散列。

如果我遇到这个问题，我的解决方案是将每个转换dict为代表的字符串dict，然后将所有字符串添加到set()然后将字符串值读出为list()并转换回dict。

字符串形式的一种良好表示dict是 JSON 格式。并且 Python 有一个内置的 JSON 模块（json当然称为）。

剩下的问题是，a 中的元素dict没有排序，当 Python 将转换dict为 JSON 字符串时，您可能会得到两个代表等效字典但不是相同字符串的 JSON 字符串。简单的解决方案是sort_keys=True在调用时传递参数json.dumps()。

编辑：此解决方案假设给定的元素dict可以有任何不同的部分。如果我们可以假设每个dict具有相同值的部分都会与每个具有相同值的"id"其他部分相匹配，那么这就有点矫枉过正了；@gnibbler 的解决方案会更快、更简单。dict`"id"`

编辑：现在 André Lima 的评论明确指出，如果 ID 是重复的，则可以安全地假设整体dict也是重复的。所以这个答案有点过分，我推荐 @gnibbler 的答案。

解决方案 3：

如果字典仅由所有项目唯一标识（ID 不可用），则可以使用 JSON 答案。以下是不使用 JSON 的替代方案，只要所有字典值都是不可变的，它就可以工作

[dict(s) for s in set(frozenset(d.items()) for d in L)]

解决方案 4：

这是一个相当紧凑的解决方案，尽管我怀疑它不是特别有效（至少这么说）：

>>> ds = [{'id':1,'name':'john', 'age':34},
...       {'id':1,'name':'john', 'age':34},
...       {'id':2,'name':'hanna', 'age':30}
...       ]
>>> map(dict, set(tuple(sorted(d.items())) for d in ds))
[{'age': 30, 'id': 2, 'name': 'hanna'}, {'age': 34, 'id': 1, 'name': 'john'}]

解决方案 5：

您可以使用 numpy 库（仅适用于 Python2.x）：

   import numpy as np 

   list_of_unique_dicts=list(np.unique(np.array(list_of_dicts)))

为了使其与 Python 3.x（以及 numpy 的最新版本）一起工作，您需要将字典数组转换为 numpy 字符串数组，例如

list_of_unique_dicts=list(np.unique(np.array(list_of_dicts).astype(str)))

解决方案 6：

a = [
{'id':1,'name':'john', 'age':34},
{'id':1,'name':'john', 'age':34},
{'id':2,'name':'hanna', 'age':30},
]

b = {x['id']:x for x in a}.values()

print(b)

输出：

[{'年龄'：34，'id'：1，'名称'：'john'}，{'年龄'：30，'id'：2，'名称'：'hanna'}]

解决方案 7：

由于id足以检测重复项，并且id是可哈希的：将它们放入以为键的字典中id。每个键的值都是原始字典。

deduped_dicts = dict((item["id"], item) for item in list_of_dicts).values()

在 Python 3 中，values()不返回列表；您需要将该表达式的整个右侧包装在中list()，并且可以将表达式的核心更经济地写为字典理解：

deduped_dicts = list({item["id"]: item for item in list_of_dicts}.values())

请注意，结果的顺序可能与原始顺序不同。如果这是必需的，您可以使用 aCollections.OrderedDict而不是dict。

顺便说一句，将数据保存在使用 as 键的字典中可能很有意义id。

解决方案 8：

这个问题已经有很多人回答了，我再补充一个吧：

import json
from typing import List

def dedup_dicts(items: List[dict]):
    dedupped = [ json.loads(i) for i in set(json.dumps(item, sort_keys=True) for item in items)]
    return dedupped

items = [
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]
dedup_dicts(items)

解决方案 9：

我们可以pandas

import pandas as pd
yourdict=pd.DataFrame(L).drop_duplicates().to_dict('r')
Out[293]: [{'age': 34, 'id': 1, 'name': 'john'}, {'age': 30, 'id': 2, 'name': 'hanna'}]

注意与接受的答案略有不同。

drop_duplicates将检查 pandas 中的所有列，如果全部相同则将删除该行。

例如：

如果我们将第二个名字dict从约翰改为彼得

L=[
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 1, 'name': 'peter', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]
pd.DataFrame(L).drop_duplicates().to_dict('r')
Out[295]: 
[{'age': 34, 'id': 1, 'name': 'john'},
 {'age': 34, 'id': 1, 'name': 'peter'},# here will still keeping the dict in the out put 
 {'age': 30, 'id': 2, 'name': 'hanna'}]

解决方案 10：

在 python 3 中，简单的技巧，但基于唯一字段（id）：

data = [ {'id': 1}, {'id': 1}]

list({ item['id'] : item for item in data}.values())

解决方案 11：

我总结了我最喜欢尝试的东西：

https://repl.it/@SmaMa/Python-List-of-unique-dictionaries

# ----------------------------------------------
# Setup
# ----------------------------------------------

myList = [
  {"id":"1", "lala": "value_1"},
  {"id": "2", "lala": "value_2"}, 
  {"id": "2", "lala": "value_2"}, 
  {"id": "3", "lala": "value_3"}
]
print("myList:", myList)

# -----------------------------------------------
# Option 1 if objects has an unique identifier
# -----------------------------------------------

myUniqueList = list({myObject['id']:myObject for myObject in myList}.values())
print("myUniqueList:", myUniqueList)

# -----------------------------------------------
# Option 2 if uniquely identified by whole object
# -----------------------------------------------

myUniqueSet = [dict(s) for s in set(frozenset(myObject.items()) for myObject in myList)]
print("myUniqueSet:", myUniqueSet)

# -----------------------------------------------
# Option 3 for hashable objects (not dicts)
# -----------------------------------------------

myHashableObjects = list(set(["1", "2", "2", "3"]))
print("myHashAbleList:", myHashableObjects)

解决方案 12：

我不知道您是否只希望列表中字典的 id 是唯一的，但如果目标是拥有一组字典，其中所有键的值都具有唯一性，那么您应该在您的理解中使用像这样的元组键：

>>> L=[
...     {'id':1,'name':'john', 'age':34},
...    {'id':1,'name':'john', 'age':34}, 
...    {'id':2,'name':'hanna', 'age':30},
...    {'id':2,'name':'hanna', 'age':50}
...    ]
>>> len(L)
4
>>> L=list({(v['id'], v['age'], v['name']):v for v in L}.values())
>>>L
[{'id': 1, 'name': 'john', 'age': 34}, {'id': 2, 'name': 'hanna', 'age': 30}, {'id': 2, 'name': 'hanna', 'age': 50}]
>>>len(L)
3

希望它能帮助您或其他有此担忧的人......

解决方案 13：

如果字典中没有唯一的值id，那么我会保持简单并定义如下函数：

def unique(sequence):
    result = []
    for item in sequence:
        if item not in result:
            result.append(item)
    return result

这种方法的优点是，您可以将此函数重用于任何可比较的对象。它使您的代码非常易读，适用于所有现代版本的 Python，保留字典中的顺序，并且与其他方法相比速度也很快。

>>> L = [
... {'id': 1, 'name': 'john', 'age': 34},
... {'id': 1, 'name': 'john', 'age': 34},
... {'id': 2, 'name': 'hanna', 'age': 30},
... ] 
>>> unique(L)
[{'id': 1, 'name': 'john', 'age': 34}, {'id': 2, 'name': 'hanna', 'age': 30}]

解决方案 14：

扩展 John La Rooy（Python - 唯一字典列表）的答案，使其更加灵活：

def dedup_dict_list(list_of_dicts: list, columns: list) -> list:
    return list({''.join(row[column] for column in columns): row
                for row in list_of_dicts}.values())

调用函数：

sorted_list_of_dicts = dedup_dict_list(
    unsorted_list_of_dicts, ['id', 'name'])

解决方案 15：

在 python 3.6+ 中（我已经测试过），只需使用：

import json

#Toy example, but will also work for your case 
myListOfDicts = [{'a':1,'b':2},{'a':1,'b':2},{'a':1,'b':3}]
#Start by sorting each dictionary by keys
myListOfDictsSorted = [sorted(d.items()) for d in myListOfDicts]

#Using json methods with set() to get unique dict
myListOfUniqueDicts = list(map(json.loads,set(map(json.dumps, myListOfDictsSorted))))

print(myListOfUniqueDicts)

解释：我们正在映射json.dumps以将字典编码为 json 对象，这些对象是不可变的。set然后可用于生成唯一不可变的可迭代对象。最后，我们使用转换回我们的字典表示json.loads。请注意，最初必须按键排序才能以唯一形式排列字典。这对 Python 3.6+ 有效，因为字典默认是有序的。

解决方案 16：

这里提到的所有答案都很好，但是在某些答案中，如果字典项有嵌套列表或字典，则可能会遇到错误，因此我建议简单的答案

a = [str(i) for i in a]
a = list(set(a))
a = [eval(i) for i in a]

解决方案 17：

对象可以放入集合中。您可以使用对象代替字典，如果需要，在插入所有集合后将其转换回字典列表。示例

class Person:
    def __init__(self, id, age, name):
        self.id = id
        self.age = age
        self.name = name

my_set = {Person(id=2, age=3, name='Jhon')}

my_set.add(Person(id=3, age=34, name='Guy'))

my_set.add({Person(id=2, age=3, name='Jhon')})

# if needed convert to list of dicts
list_of_dict = [{'id': obj.id,
                 'name': obj.name,
                 'age': obj.age} for obj in my_set]

解决方案 18：

一个快速而简单的解决方案就是生成一个新列表。

sortedlist = []

for item in listwhichneedssorting:
    if item not in sortedlist:
        sortedlist.append(item)

解决方案 19：

让我添加我的。

对目标字典进行排序，使得 {'a' : 1, 'b': 2} 和 {'b': 2, 'a': 1} 不会被区别对待
将其设为 json
通过 set 进行重复数据删除（因为 set 不适用于字典）
再次通过 json.loads 将其转换为字典

import json

[json.loads(i) for i in set([json.dumps(i) for i in [dict(sorted(i.items())) for i in target_dict]])]

解决方案 20：

可能有更优雅的解决方案，但我认为最好添加一个更详细的解决方案以使其更容易理解。这假设没有唯一键，您有一个简单的 k,v 结构，并且您正在使用一个保证列表顺序的 python 版本。这对原始帖子有效。

data_set = [
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 1, 'name': 'john', 'age': 34},
    {'id': 2, 'name': 'hanna', 'age': 30},
]

# list of keys
keys = [k for k in data_set[0]]

# Create a List of Lists of the values from the data Set
data_set_list = [[v for v in v.values()] for v in data_set]

# Dedupe
new_data_set = []
for lst in data_set_list:
    # Check if list exists in new data set
    if lst in new_data_set:
        print(lst)
        continue
    # Add list to new data set
    new_data_set.append(lst)

# Create dicts
new_data_set = [dict(zip(keys,lst)) for lst in new_data_set]    

print(new_data_set)

解决方案 21：

'''an example of getting a list of unique dicts using named tuple'''

from collections import namedtuple

dict_list = [
    dict(a=1, b=2, c=3), 
    dict(a=10, b=20, c=30), 
    dict(a=100, b=200, c=300), 
    dict(a=1, b=2, c=3), 
    dict(a=10, b=20, c=30), 
]

first_dict = dict_list[0]
keys = list(first_dict.keys())
Nt = namedtuple('Nt', keys)

namedtuple_set = set(Nt(*elem.values()) for elem in dict_list)
unique_dict_list = [elem._asdict() for elem in namedtuple_set]
unique_dict_list

# [{'a': 1, 'b': 2, 'c': 3},
#  {'a': 100, 'b': 200, 'c': 300},
#  {'a': 10, 'b': 20, 'c': 30}]

解决方案 22：

非常简单的选择：

L = [
    {'id':1,'name':'john', 'age':34},
    {'id':1,'name':'john', 'age':34},
    {'id':2,'name':'hanna', 'age':30},
    ]


D = dict()
for l in L: D[l['id']] = l
output = list(D.values())
print output

解决方案 23：

这是一个内存开销很小的实现，但代价是不如其他实现那么紧凑。

values = [ {'id':2,'name':'hanna', 'age':30},
           {'id':1,'name':'john', 'age':34},
           {'id':1,'name':'john', 'age':34},
           {'id':2,'name':'hanna', 'age':30},
           {'id':1,'name':'john', 'age':34},]
count = {}
index = 0
while index < len(values):
    if values[index]['id'] in count:
        del values[index]
    else:
        count[values[index]['id']] = 1
        index += 1

输出：

[{'age': 30, 'id': 2, 'name': 'hanna'}, {'age': 34, 'id': 1, 'name': 'john'}]

解决方案 24：

这是我找到的解决方案：

usedID = []

x = [
{'id':1,'name':'john', 'age':34},
{'id':1,'name':'john', 'age':34},
{'id':2,'name':'hanna', 'age':30},
]

for each in x:
    if each['id'] in usedID:
        x.remove(each)
    else:
        usedID.append(each['id'])

print x

基本上，你要检查列表中是否存在该 ID，如果存在，则删除该字典，如果不存在，则将 ID 附加到列表中