Usuwanie duplikatów z listy przy zachowaniu jej kolejności (Python)

Question

Jest to w rzeczywistości rozszerzenie tego pytania. Odpowiedzi na to pytanie nie zachowały "porządku" listy po usunięciu duplikatów. 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'} 

] 

W tym przypadku, 2. element powinien zostać usunięty, ponieważ poprzednie „u2.com” Element już istnieje. Jednak należy zachować porządek.

Answer 1

Moja odpowiedź na inne pytanie, które całkowicie ignorowane !, pokazuje mylisz się twierdząc, że

odpowiedzi tej kwestii nie utrzymania „porządku”

• moja odpowiedź zrobił zachować porządek, a to wyraźnie powiedział to zrobił. Tutaj jest to kolejny, z dodatkiem naciskiem, aby zobaczyć, czy można po prostu zachować ignorując go ...:

Prawdopodobnie najszybszy podejście, o naprawdę duże liście, jeśli chcesz zachować dokładną kolejność elementów które pozostają, jest następujące:

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

super łatwy sposób to zrobić, to:

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

Nie jest to najbardziej skuteczny sposób, ponieważ:

• przeszukuje całej listy dla każdego elementu na liście, więc to o (n^2)
• to rekurencyjny to wykorzystuje zagnieżdżenia równy długości listy

Jednak dla prostych zastosowań (nie więcej niż kilkaset pozycji, nie krytycznych pod względem wydajności) jest to wystarczające.

Answer 3

Ta strona omawia różne metody i ich prędkości: http://www.peterbe.com/plog/uniqifiers-benchmark

* Zalecana metoda:

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

* od tej strony

Answer 4

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

print newlist 

produkuje

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

Zauważ, że tutaj użyłem słownika. Dzięki temu test jest znacznie bardziej wydajny niż przy użyciu listy.

Answer 5

Myślę, że używanie zestawu powinno być całkiem skuteczne.

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

myślę, że to powinno wejść w O (nlog (n))

Answer 6

Generatory są świetne.

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 

wyjściowy będzie:

[ 'A A', 'ABA', 'A A', 'AEA', 'Baa', 'aaa', 'AAC', 'aaa' ]

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

Answer 8

jest to elegancki i kompaktowy sposób, z listowego (ale nie tak skuteczny jak w słowniku) :

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

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

A w kontekście odpowiedzi:

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

Answer 9

użycie set(), a następnie ponownego sortowania za pomocą indeksu oryginalnej listy.

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