Python - Список унікальних словників

Скажімо, я отримав список словників:

[
    {'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},
]

Чи може хто-небудь допомогти мені з найбільш ефективним способом досягти цього в Python?

Тож складіть тимчасовий дикт з ключовим ключем 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'}]

Звичайний спосіб знайти просто загальні елементи в наборі - це використовувати setклас Python . Просто додайте всі елементи до набору, потім перетворіть набір у a list, а бам дублікатів вже не буде.

Проблема, звичайно, полягає в тому, що set()може містити лише хешируемые записи, а а dict- не хешируемый.

Якби у мене була ця проблема, моїм рішенням було б перетворити кожну dictв рядок, що представляє собою dict, а потім додати всі рядки до set()потім прочитаних значень рядків у вигляді list()і перетворити назад у dict.

Хорошим представленням dictрядкової форми є формат JSON. І Python має вбудований модуль для JSON (називається jsonзвичайно).

Залишилася проблема полягає в тому, що елементи в a dictне впорядковані, і коли Python перетворює dictрядок в JSON, ви можете отримати два рядки JSON, які представляють еквівалентні словники, але не є ідентичними рядками. Просте рішення - передавати аргумент sort_keys=Trueпід час дзвінка json.dumps().

EDIT: Це рішення передбачало, що дана dictможе мати будь-яку частину. Якщо ми можемо припустити, що кожен dictз однаковим "id"значенням буде відповідати один одному dictз однаковим "id"значенням, то це надмірно; @ рішення gnibbler було б швидше і простіше.

EDIT: Зараз є коментар від Андре Ліма, який прямо говорить про те, що якщо ідентифікатор є дублікатом, можна припустити, що ціле dict- це дублікат. Тож ця відповідь є надмірною, і я рекомендую відповідь @ gnibbler.

У випадку, якщо словники мають унікальну ідентифікацію всіх елементів (ідентифікатор недоступний), ви можете скористатися відповіддю за допомогою JSON. Далі наведена альтернатива, яка не використовує JSON, і працюватиме до тих пір, поки всі значення словника будуть незмінні

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

Ви можете використовувати бібліотеку 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)))

Ось досить компактне рішення, хоча я підозрюю, що не особливо ефективний (м'яко кажучи):

>>> 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'}]

Оскільки цього 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())

Зауважте, що результат, ймовірно, не буде в тому ж порядку, що і вихідний. Якщо це вимога, ви можете використовувати Collections.OrderedDictзамість dict.

На відміну від цього, можливо, має сенс просто зберігати дані у словнику, який для початку використовує idключ.

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)

Виходи:

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

Розширення на відповідь Джона Ла Роя ( 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'])

Ми можемо зробити 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 перевірить увесь стовпець у пандах, якщо все те саме, тоді рядок буде відмінено.

Наприклад :

Якщо ми змінимо 2-е dictім’я з john на peter

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'}]

У 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+, оскільки словники впорядковані за замовчуванням.

Я узагальнив свої улюблені, щоб спробувати:

https://repl.it/@SmaMa/Python-List-of-unique-dic Словники

# ----------------------------------------------
# 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)

Швидке та брудне рішення - це лише створення нового списку.

sortedlist = []

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

Я не знаю, чи хочете ви лише, щоб ідентифікатор ваших диктовок у списку був унікальним, але якщо мета полягає в тому, щоб мати набір dict, де єдина є значення всіх значень клавіш .. ви повинні використовувати кортежні ключі, як цей у вашому розумінні:

>>> 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

Сподіваюсь, це допоможе вам чи іншій особі, яка має занепокоєння ....

Тут є багато відповідей, тому дозвольте додати ще одну:

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)

Досить простий варіант:

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

Ну всі відповіді, згадані тут, хороші, але в деяких відповідях можна зіткнутися з помилкою, якщо елементи словника мають вкладений список або словник, тому я пропоную просту відповідь

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

Ось реалізація з невеликою витратою пам’яті ціною не бути такою компактною, як решта.

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'}]

Це рішення, яке я знайшов:

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

В основному ви перевіряєте, чи ідентифікатор присутній у списку, якщо він є, ви видаляєте словник, якщо ні, додаєте ідентифікатор до списку