在保持其順序的同時刪除列表中的重復項（Python）

Question

這實際上是這個問題的延伸。 刪除重復項后，該問題的答案沒有保留列表的“順序”。 如何在列表中刪除這些重復項（python）

biglist = 

[ 

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

]

在這種情況下，應該刪除第二個元素，因為先前的“u2.com”元素已經存在。 但是，應該保留訂單。

Answer 1

使用set（），然后使用原始列表的索引重新排序。

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

Answer 2

我對你完全忽略的另一個問題的答案，表明你聲稱這是錯誤的

這個問題的答案沒有保持“秩序”

• 我的回答確實保持秩序，它明確表示確實如此。 在這里再次強調，看看你是否可以繼續忽略它......：

對於一個非常大的列表， 如果你想保留剩余物品的確切順序，可能是最快的方法，如下......：

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 3

發電機很棒。

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

biglist[:] = unique( biglist )

Answer 4

本頁討論了不同的方法及其速度： http ： //www.peterbe.com/plog/uniqifiers-benchmark

推薦*方法：

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

*通過該頁面

Answer 5

這是一種優雅而緊湊的方式，具有列表理解（但不像字典那樣有效）：

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

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

在答案的背景下：

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

Answer 6

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

print newlist

產生

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

請注意，我在這里使用了字典。 這使得測試not in dups比使用列表更有效。

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

輸出將是：

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

Answer 8

一個非常簡單的方法是：

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

這不是最有效的方法，因為：

• 它在整個列表中搜索列表中的每個元素，因此它是O（n ^ 2）
• 它是遞歸的，因此使用的堆棧深度等於列表的長度

但是，對於簡單的用途（不超過幾百項，而不是性能關鍵）就足夠了。

Answer 9

我認為使用套裝應該非常有效。

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

我認為這應該在O（nlog（n））