Python - Elenco di dizionari unici

Diciamo che ho un elenco di dizionari:

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

e ho bisogno di ottenere un elenco di dizionari univoci (rimuovendo i duplicati):

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

Qualcuno può aiutarmi con il modo più efficiente per raggiungere questo obiettivo in Python?

Quindi crea un dict temporaneo con la chiave come id. Questo filtra i duplicati. Ilvalues() dict sarà la lista

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

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

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

Il solito modo di trovare solo gli elementi comuni in un set è usare la setclasse di Python . Basta aggiungere tutti gli elementi al set, quindi convertire il set in a liste bam i duplicati sono spariti.

Il problema, ovviamente, è che a set()può contenere solo voci hash e a dictnon è hash.

Se avessi questo problema, la mia soluzione sarebbe quella di convertire ciascuno dictin una stringa che rappresenta il dict, quindi aggiungere tutte le stringhe a un set()quindi leggere i valori della stringa come a list()e convertire nuovamente indict .

Una buona rappresentazione di una dictforma in stringa è il formato JSON. E Python ha un modulo integrato per JSON (chiamato jsonovviamente).

Il problema rimanente è che gli elementi in a dictnon sono ordinati e quando Python converte la dictstringa in una stringa JSON, potresti ottenere due stringhe JSON che rappresentano dizionari equivalenti ma non sono stringhe identiche. La soluzione semplice è passare l'argomento sort_keys=Truequando chiami json.dumps().

EDIT: questa soluzione presupponeva che un dato dictpotesse avere qualsiasi parte diversa. Se possiamo supporre che ognuno dictcon lo stesso "id"valore corrisponderà a vicenda dictcon lo stesso"id" valore, allora questo è eccessivo; La soluzione di @ gnibbler sarebbe più veloce e più facile.

EDIT: Ora c'è un commento di André Lima che dice esplicitamente che se l'ID è un duplicato, si può presumere che l'intero dictsia un duplicato. Quindi questa risposta è eccessiva e raccomando la risposta di @ gnibbler.

Nel caso in cui i dizionari siano identificati in modo univoco da tutti gli elementi (ID non disponibile) è possibile utilizzare la risposta utilizzando JSON. Di seguito è un'alternativa che non utilizza JSON e funzionerà fino a quando tutti i valori del dizionario sono immutabili

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

Puoi usare la libreria numpy (funziona solo per Python2.x):

   import numpy as np 

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

Per farlo funzionare con Python 3.x (e le versioni recenti di numpy), è necessario convertire un array di dicts in un numpy array di stringhe, ad es.

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

Ecco una soluzione ragionevolmente compatta, anche se sospetto non particolarmente efficiente (per dirla in parole povere):

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

Dato che idè sufficiente per rilevare duplicati e idhash: eseguili attraverso un dizionario che ha idcome chiave. Il valore per ogni chiave è il dizionario originale.

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

In Python 3, values()non restituisce un elenco; dovrai avvolgere l'intero lato destro di quell'espressione list()e puoi scrivere la carne dell'espressione in modo più economico come comprensione dettata:

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

Si noti che il risultato probabilmente non sarà nello stesso ordine dell'originale. Se questo è un requisito, è possibile utilizzare un Collections.OrderedDictanziché un dict.

Per inciso, può essere sensato conservare i dati in un dizionario che utilizza la idchiave as per cominciare.

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)

uscite:

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

Espandendo sulla risposta John La Rooy ( Python - Elenco di dizionari unici ), rendendolo un po 'più flessibile:

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

Funzione chiamante:

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

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

Notare leggermente diverso dalla risposta accettata.

drop_duplicates controllerà tutta la colonna in panda, se tutti uguali la riga verrà eliminata.

Per esempio :

Se cambiamo il secondo dictnome da John a 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'}]

In python 3.6+ (quello che ho testato), basta usare:

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)

Spiegazione: stiamo mappando il json.dumpscodice per codificare i dizionari come oggetti json, che sono immutabili. setpuò quindi essere utilizzato per produrre un iterabile di immutabili unici . Infine, riconvertiamo la nostra rappresentazione del dizionario usando json.loads. Si noti che inizialmente è necessario ordinare in base alle chiavi per disporre i dizionari in una forma univoca. Questo è valido per Python 3.6+ poiché i dizionari sono ordinati per impostazione predefinita.

Ho riassunto i miei preferiti per provare:

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)

Una soluzione rapida è semplicemente generando un nuovo elenco.

sortedlist = []

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

Non so se vuoi solo che l'id delle tue parole nell'elenco sia unico, ma se l'obiettivo è quello di avere una serie di dict in cui l'unicità sia sui valori di tutte le chiavi .. dovresti usare la chiave delle tuple in questo modo nella tua comprensione:

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

Spero che aiuti te o un'altra persona a preoccuparti ...

Ci sono molte risposte qui, quindi vorrei aggiungerne un'altra:

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)

Opzione piuttosto semplice:

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

Bene, tutte le risposte menzionate qui sono buone, ma in alcune risposte si possono riscontrare errori se gli elementi del dizionario hanno un elenco o un dizionario nidificati, quindi propongo una risposta semplice

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

Ecco un'implementazione con poca memoria overhead al costo di non essere compatta come il resto.

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

produzione:

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

Questa è la soluzione che ho trovato:

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

Fondamentalmente si controlla se l'ID è presente nell'elenco, se lo è, eliminare il dizionario, in caso contrario, aggiungere l'ID all'elenco