Python - Liste des dictionnaires

La manière habituelle pour trouver les éléments communs d'un ensemble est d'utiliser Python set classe. Ajouter tous les éléments de l'ensemble, puis de convertir l'ensemble à un list, et bam les doublons sont partis.

Le problème, bien sûr, c'est qu'un set() ne peut contenir que des hashable entrées, et un dict n'est pas hashable.

Si j'ai eu ce problème, ma solution serait de convertir chaque dict dans une chaîne de caractères qui représente le dict, puis ajoutez toutes les chaînes à une set() puis la lecture de la chaîne de valeurs comme un list() et de convertir retour à dict.

Une bonne représentation d'un dict dans la forme d'une chaîne est le format JSON. Et Python a intégré dans le module JSON (appelé json bien sûr).

Le problème reste que les éléments dans un dict ne sont pas commandés, et quand Python convertit le dict à une chaîne JSON, vous pourriez obtenir deux chaînes JSON qui représentent l'équivalent des dictionnaires, mais ne sont pas identiques cordes. La solution facile est de passer l'argument sort_keys=True lorsque vous appelez json.dumps().

EDIT: Cette solution est à supposer qu'un dict peut avoir un rôle différent. Si nous pouvons supposer que chaque dict avec la même "id" de la valeur de correspondre à tous les autres dict avec la même "id" valeur, alors c'est exagéré; @gnibbler la solution serait plus rapide et plus facile.

EDIT: Maintenant, il y a un commentaire d'André Lima qui dit explicitement que si l'ID est un doublon, il est sûr de supposer que l'ensemble de la dict est un doublon. Si cette réponse est exagéré, et je recommande @gnibbler de réponse.

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

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

Depuis le id est suffisante pour détecter les doublons et les id est hashable: run 'em par le biais d'un dictionnaire qui a le id comme la 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 retourne pas une liste; vous en aurez besoin pour envelopper l'ensemble de la droite de cette expression dans les list(), et vous pouvez écrire la viande de l'expression de la plus économiquement comme dict compréhension:

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

À noter 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.OrderedDict au lieu d'un dict.

En aparté, il peut faire une bonne affaire de sens à garder les données dans un dictionnaire qui utilise le id comme la clé pour commencer.

Expansion sur John La Rooy (Python - Liste des dictionnaires) réponse, le rendant un peu plus souple:

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

L'Appel De La Fonction:

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

En python 3.6+ (ce que j'ai testé), il suffit d'utiliser:

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 sommes cartographie de la json.dumps pour coder les dictionnaires comme des objets json, qui sont immuables. set peut ensuite être utilisé pour produire un objet iterable unique immutables. Enfin, nous convertir en arrière de notre dictionnaire de la représentation à l'aide de json.loads. Notez qu'au départ, on doit trier par touches pour organiser les dictionnaires dans une forme unique. Ceci est valable pour Python 3.6+ depuis les dictionnaires sont commandés par défaut.

Assez simple option:

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

Il y a beaucoup de réponses ici, alors laissez-moi 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)

C'est la solution que j'ai trouvé:

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

Fondamentalement, vous vérifiez si l'ID est présent dans la liste, si c'est le cas, supprimez le dictionnaire, si non, ajouter l'ID de la liste