Eliminar duplicados en una lista mientras se mantiene su orden (Python)

Question

Esto es realmente una extensión de esta pregunta. Las respuestas de esa pregunta no mantuvieron el "orden" de la lista después de eliminar los duplicados. How to remove these duplicates in a list (python)

biglist = 

[ 

    {'title':'U2 Band','link':'u2.com'}, 
    {'title':'Live Concert by U2','link':'u2.com'}, 
    {'title':'ABC Station','link':'abc.com'} 

] 

En este caso, el segundo elemento debe ser eliminado porque un elemento previo "u2.com" ya existe. Sin embargo, la orden debe mantenerse.

Answer 1

Mi respuesta a su otra pregunta, que ignora por completo !, muestra se equivoca al afirmar que

las respuestas de la pregunta no lo hicieron mantener el "orden"

• mi respuesta hizo mantener el orden, y claramente dijo lo hizo. Aquí está otra vez, con énfasis añadido para ver si sólo se puede seguir ignorando que ...:

Probablemente el método más rápido, para obtener una lista muy grande, si desea conservar el orden exacto de los artículos que permanecen, es el siguiente ...:

biglist = [ 
    {'title':'U2 Band','link':'u2.com'}, 
    {'title':'ABC Station','link':'abc.com'}, 
    {'title':'Live Concert by U2','link':'u2.com'} 
] 

known_links = set() 
newlist = [] 

for d in biglist: 
    link = d['link'] 
    if link in known_links: continue 
    newlist.append(d) 
    known_links.add(link) 

biglist[:] = newlist 

Answer 2

Una manera muy fácil de hacer esto es:

def uniq(a): 
    if len(a) == 0: 
     return [] 
    else: 
     return [a[0]] + uniq([x for x in a if x != a[0]]) 

Esta no es la forma más eficiente, debido a que:

• que busca a través de toda la lista de todos los elementos de la lista, por lo es O (n^2)
• es recursiva de modo utiliza una profundidad de pila igual a la longitud de la lista

Sin embargo, para usos simples (no más de unos pocos cientos de elementos, no el rendimiento crítico) es suficiente.

Answer 3

Esta página discute los diferentes métodos y sus velocidades: http://www.peterbe.com/plog/uniqifiers-benchmark

El método recomendado *:

def f5(seq, idfun=None): 
    # order preserving 
    if idfun is None: 
     def idfun(x): return x 
    seen = {} 
    result = [] 
    for item in seq: 
     marker = idfun(item) 
     # in old Python versions: 
     # if seen.has_key(marker) 
     # but in new ones: 
     if marker in seen: continue 
     seen[marker] = 1 
     result.append(item) 
    return result 

f5(biglist,lambda x: x['link']) 

* por esa página

Answer 4

dups = {} 
newlist = [] 
for x in biglist: 
    if x['link'] not in dups: 
     newlist.append(x) 
     dups[x['link']] = None 

print newlist 

produce

[{'link': 'u2.com', 'title': 'U2 Band'}, {'link': 'abc.com', 'title': 'ABC Station'}] 

Tenga en cuenta que aquí utilicé un diccionario. Esto hace que la prueba not in dups sea mucho más eficiente que usar una lista.

Answer 5

Creo que usar un conjunto debería ser bastante eficiente.

seen_links = set() 
for index in len(biglist): 
    link = biglist[index]['link'] 
    if link in seen_links: 
     del(biglist[index]) 
    seen_links.add(link) 

creo que esto debería venir en O (n log (n))

Answer 6

generadores son grandes.

def unique(seq): 
    seen = set() 
    for item in seq: 
     if item not in seen: 
      seen.add(item) 
      yield item 

biglist[:] = unique(biglist) 

Answer 7

list = ['aaa','aba','aaa','aea','baa','aaa','aac','aaa',] 

uniq = [] 

for i in list: 
       if i not in uniq: 
        uniq.append(i) 

print list 

print uniq 

salida será:

[ 'aaa', 'aba', 'aaa', 'AEA', 'BAA', 'aaa', 'aac', 'aaa' ]

[ 'AAA', 'aba', 'aea', 'BAA', 'aac']

Answer 8

Esta es una manera elegante y compacto, con la lista de comprensión (pero no tan eficiente como con el diccionario) :

mylist = ['aaa','aba','aaa','aea','baa','aaa','aac','aaa',] 

[ v for (i,v) in enumerate(mylist) if v not in mylist[0:i] ] 

Y en el contexto de la respuesta:

[ v for (i,v) in enumerate(biglist) if v['link'] not in map(lambda d: d['link'], biglist[0:i]) ] 

Answer 9

conjunto de uso(), a continuación, volver a clasificar utilizando el índice de la lista original.

>>> mylist = ['c','a','a','b','a','b','c'] 
>>> sorted(set(mylist), key=lambda x: mylist.index(x)) 
['c', 'a', 'b']