supprimer les doublons de dictionnaires imbriqués dans la liste

Question

rapide et très basique newbie question.

Si j'ai liste des dictionnaires qui ressemble à ceci:

L = [] 
L.append({"value1": value1, "value2": value2, "value3": value3, "value4": value4}) 

Disons qu'il existe plusieurs entrées où value3 et valeur4 sont identiques à d'autres dictionnaires imbriqués. Comment puis-je trouver et supprimer rapidement et facilement ces dictionnaires en double.

L'ordre de conservation n'a pas d'importance.

Merci.

EDIT:

S'il y a cinq entrées, comme celui-ci:

L = [{"value1": fssd, "value2": dsfds, "value3": abcd, "value4": gk}, 
    {"value1": asdasd, "value2": asdas, "value3": dafdd, "value4": sdfsdf}, 
    {"value1": sdfsf, "value2": sdfsdf, "value3": abcd, "value4": gk}, 
    {"value1": asddas, "value2": asdsa, "value3": abcd, "value4": gk}, 
    {"value1": asdasd, "value2": dskksks, "value3": ldlsld, "value4": sdlsld}] 

La sortie shoud ressemble à ceci:

L = [{"value1": fssd, "value2": dsfds, "value3": abcd, "value4": gk}, 
    {"value1": asdasd, "value2": asdas, "value3": dafdd, "value4": sdfsdf}, 
    {"value1": asdasd, "value2": dskksks, "value3": ldlsld, "value4": sdlsld} 

Answer 1

En Python 2.6 ou 3. *:

import itertools 
import pprint 

L = [{"value1": "fssd", "value2": "dsfds", "value3": "abcd", "value4": "gk"}, 
    {"value1": "asdasd", "value2": "asdas", "value3": "dafdd", "value4": "sdfsdf"}, 
    {"value1": "sdfsf", "value2": "sdfsdf", "value3": "abcd", "value4": "gk"}, 
    {"value1": "asddas", "value2": "asdsa", "value3": "abcd", "value4": "gk"}, 
    {"value1": "asdasd", "value2": "dskksks", "value3": "ldlsld", "value4": "sdlsld"}] 

getvals = operator.itemgetter('value3', 'value4') 

L.sort(key=getvals) 

result = [] 
for k, g in itertools.groupby(L, getvals): 
    result.append(g.next()) 

L[:] = result 
pprint.pprint(L) 

Presque même en Python 2.5, sauf que vous doit utiliser g.next() au lieu de next (g) dans l'append.

Answer 2

for dic in list: 
    for anotherdic in list: 
    if dic != anotherdic: 
     if dic["value3"] == anotherdic["value3"] or dic["value4"] == anotherdic["value4"]: 
     list.remove(anotherdic) 

testé avec

list = [{"value1": 'fssd', "value2": 'dsfds', "value3": 'abcd', "value4": 'gk'}, 
{"value1": 'asdasd', "value2": 'asdas', "value3": 'dafdd', "value4": 'sdfsdf'}, 
{"value1": 'sdfsf', "value2": 'sdfsdf', "value3": 'abcd', "value4": 'gk'}, 
{"value1": 'asddas', "value2": 'asdsa', "value3": 'abcd', "value4": 'gk'}, 
{"value1": 'asdasd', "value2": 'dskksks', "value3": 'ldlsld', "value4": 'sdlsld'}] 

a bien fonctionné pour moi :)

Answer 3

C'est une liste d'un dictionnaire et mais, en supposant qu'il ya plus de dictionnaires dans la liste l:

l = [ldict for ldict in l if ldict.get("value3") != value3 or ldict.get("value4") != value4] 

Mais est-ce que vous voulez vraiment faire? Peut-être avez-vous besoin d'affiner votre description.

BTW, n'utilisez pas list comme nom car c'est le nom d'un built-in Python.

EDIT: En supposant que vous avez commencé avec une liste de dictionnaires, plutôt qu'une liste de listes de 1 dictionnaire chacune qui devrait fonctionner avec votre exemple. Il ne fonctionnera pas si l'une des valeurs avait pas, alors il vaut mieux quelque chose comme:

l = [ldict for ldict in l if not (("value3" in ldict and ldict["value3"] == value3) and ("value4" in ldict and ldict["value4"] == value4))] 

Mais il semble encore comme une structure de données hors du commun.

EDIT: inutile d'utiliser explicitement get s.

De plus, il y a toujours des compromis dans les solutions. Sans plus d'informations et sans réellement mesurer, il est difficile de savoir quels compromis de performance sont les plus importants pour le problème. Mais, comme le Zen sez: "Simple est mieux que complexe".

Answer 4

Vous pouvez utiliser une matrice temporaire pour stocker un élément. Le code précédent était buggé pour supprimer des éléments dans la boucle for.

(v,r) = ([],[]) 
for i in l: 
    if ('value4', i['value4']) not in v and ('value3', i['value3']) not in v: 
     r.append(i) 
    v.extend(i.items()) 
l = r 

Votre test:

l = [{"value1": 'fssd', "value2": 'dsfds', "value3": 'abcd', "value4": 'gk'}, 
    {"value1": 'asdasd', "value2": 'asdas', "value3": 'dafdd', "value4": 'sdfsdf'}, 
    {"value1": 'sdfsf', "value2": 'sdfsdf', "value3": 'abcd', "value4": 'gk'}, 
    {"value1": 'asddas', "value2": 'asdsa', "value3": 'abcd', "value4": 'gk'}, 
    {"value1": 'asdasd', "value2": 'dskksks', "value3": 'ldlsld', "value4": 'sdlsld'}] 

ouputs

{'value4': 'gk', 'value3': 'abcd', 'value2': 'dsfds', 'value1': 'fssd'} 
{'value4': 'sdfsdf', 'value3': 'dafdd', 'value2': 'asdas', 'value1': 'asdasd'} 
{'value4': 'sdlsld', 'value3': 'ldlsld', 'value2': 'dskksks', 'value1': 'asdasd'} 

Answer 5

Voici une façon:

keyfunc = lambda d: (d['value3'], d['value4']) 

from itertools import groupby 
giter = groupby(sorted(L, key=keyfunc), keyfunc) 

L2 = [g[1].next() for g in giter] 
print L2 

Answer 6

Si je comprends bien, vous voulez jeter les matchs qui viennent plus tard la liste originale, mais ne se soucient pas de la o rder de la liste résultante, donc:

(testé avec 2.5.2)

tempDict = {} 
for d in L[::-1]: 
    tempDict[(d["value3"],d["value4"])] = d 
L[:] = tempDict.itervalues() 
tempDict = None