Python - Liste de dictionnaires uniques

Disons que j'ai une liste de dictionnaires:

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

et j'ai besoin d'obtenir une liste de dictionnaires uniques (en supprimant les doublons):

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

Quelqu'un peut-il m'aider avec le moyen le plus efficace d'y parvenir en Python?

Alors faites un dict temporaire avec la clé étant le id. Cela filtre les doublons. levalues() du dict sera la liste

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

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

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

La façon habituelle de trouver uniquement les éléments communs dans un ensemble est d'utiliser la setclasse de Python . Ajoutez simplement tous les éléments à l'ensemble, puis convertissez l'ensemble en a list, et bam les doublons ont disparu.

Le problème, bien sûr, est que a set()ne peut contenir que des entrées hachables, et a dictn'est pas hachable.

Si j'avais ce problème, ma solution serait de convertir chacun dicten une chaîne qui représente le dict, puis d'ajouter toutes les chaînes à a, set()puis de lire les valeurs de chaîne en tant que a list()et de les reconvertir endict .

Une bonne représentation d'un dictsous forme de chaîne est le format JSON. Et Python a un module intégré pour JSON (appelé jsonbien sûr).

Le problème restant est que les éléments de a dictne sont pas ordonnés, et lorsque Python convertit le dicten une chaîne JSON, vous pouvez obtenir deux chaînes JSON qui représentent des dictionnaires équivalents mais ne sont pas des chaînes identiques. La solution simple est de passer l'argument sort_keys=Truelorsque vous appelez json.dumps().

EDIT: Cette solution supposait qu'une donnée dictpouvait avoir n'importe quelle partie différente. Si nous pouvons supposer que tous dictavec la même "id"valeur correspondront à tous les autres dictavec la même "id"valeur, alors c'est exagéré; La solution de @ gnibbler serait plus rapide et plus simple.

EDIT: Maintenant, il y a un commentaire d'André Lima disant explicitement que si l'ID est un double, il est prudent de supposer que le tout dictest un double. Donc, cette réponse est exagérée et je recommande la réponse de @ gnibbler.

Dans le cas où les dictionnaires ne sont identifiés que de manière unique par tous les éléments (l'ID n'est pas disponible), vous pouvez utiliser la réponse en utilisant JSON. Ce qui suit est une alternative qui n'utilise pas JSON et fonctionnera tant que toutes les valeurs du dictionnaire sont immuables

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

Vous pouvez utiliser la bibliothèque numpy (fonctionne uniquement pour Python2.x):

   import numpy as np 

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

Pour le faire fonctionner avec Python 3.x (et les versions récentes de numpy), vous devez convertir un tableau de dictées en tableau numpy de chaînes, par exemple

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

Voici une solution raisonnablement compacte, même si je soupçonne qu'elle n'est pas particulièrement efficace (pour le moins dire):

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

Puisque le idest suffisant pour détecter les doublons et qu'il idest hachable: exécutez-les dans un dictionnaire qui a idcomme clé. La valeur de chaque clé est le dictionnaire d'origine.

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

En Python 3, values()ne renvoie pas de liste; vous aurez besoin d'envelopper tout le côté droit de cette expression list(), et vous pouvez écrire la viande de l'expression de manière plus économique comme une compréhension de dict:

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

Notez que le résultat ne sera probablement pas dans le même ordre que l'original. Si c'est une exigence, vous pouvez utiliser un Collections.OrderedDictau lieu d'un dict.

En passant, il peut être très judicieux de simplement conserver les données dans un dictionnaire qui utilise la idclé as pour commencer.

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)

les sorties:

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

Extension de la réponse de John La Rooy ( Python - Liste de dictionnaires uniques ), ce qui la rend un peu plus flexible:

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

Fonction d'appel:

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

On peut faire avec 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'}]

Remarquez légèrement différent de la réponse d'acceptation.

drop_duplicates vérifiera toutes les colonnes des pandas, si elles sont toutes identiques, la ligne sera supprimée.

Par exemple :

Si nous changeons le 2ème dictnom de John en 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'}]

En python 3.6+ (ce que j'ai testé), utilisez simplement:

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)

Explication: nous mappons le json.dumpspour encoder les dictionnaires en tant qu'objets json, qui sont immuables. setpeut ensuite être utilisé pour produire un itérable d' immuables uniques . Enfin, nous retournons à notre représentation de dictionnaire en utilisant json.loads. Notez qu'au départ, il faut trier par clés pour disposer les dictionnaires sous une forme unique. Ceci est valable pour Python 3.6+ puisque les dictionnaires sont classés par défaut.

J'ai résumé mes favoris pour essayer:

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)

Une solution rapide et sale consiste simplement à générer une nouvelle liste.

sortedlist = []

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

Je ne sais pas si vous voulez seulement que l'identifiant de vos dictés dans la liste soit unique, mais si le but est d'avoir un ensemble de dict où l'unicité est sur les valeurs de toutes les clés ... vous devez utiliser la clé tuples comme celle-ci dans votre compréhension:

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

J'espère que cela vous aidera ou aidera une autre personne à vous inquiéter ....

Il y a beaucoup de réponses ici, alors laissez-moi en ajouter une autre:

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)

Option assez simple:

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

Eh bien, toutes les réponses mentionnées ici sont bonnes, mais dans certaines réponses, on peut faire face à une erreur si les éléments du dictionnaire ont une liste ou un dictionnaire imbriqués, donc je propose une réponse simple

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

Voici une implémentation avec peu de surcharge de mémoire au prix de ne pas être aussi compacte que le reste.

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

production:

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

Voici la solution que j'ai trouvée:

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

En gros, vous vérifiez si l'ID est présent dans la liste, si c'est le cas, supprimez le dictionnaire, sinon, ajoutez l'ID à la liste