Supprimer les doublons dans une liste tout en gardant son ordonnance (Python)

C'est en fait une extension de cette question. Les réponses de cette question n'a pas pu maintenir "l'ordre" de la liste après la suppression des doublons. Comment faire pour supprimer ces doublons dans une liste (python)

biglist = 

[ 

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

]

Dans ce cas, le 2ème élément doit être supprimé, parce que le précédent "u2.com" l'élément existe déjà. Toutefois, l'ordre doit être maintenu.

InformationsquelleAutor TIMEX | 2009-10-11

list python

23

Ma réponse à votre autre question, qui vous a complètement ignoré!, montre vous vous trompez en affirmant que

Les réponses de cette question n'a pas
garder le "bon de commande"
- ma réponse ne maintenir l'ordre, et c'est clairement la dit il l'a fait. Ici, il est, à nouveau, avec plus d'emphase pour voir si vous pouvez continuer à l'ignorer...:
Probablement le plus rapide approche, pour une très grande liste, si vous souhaitez préserver l'ordre exact des éléments qui restent, est la suivante...:
```
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
```
- Hey Alex, la curiosité, pourquoi mettez-vous le [:] sur le côté gauche de l'affectation? J'ai souvent vu sur les RHS. Est-il juste préférence personnelle? En regardant d'abord, je n'étais même pas sûr de ce qu'il allait faire, haha.
- À l'aide de [:] sur la gauche remplacé tous les éléments dans la liste, au lieu de la liste elle-même. Elle pourrait avoir un effet par exemple si vous faites cela à l'intérieur d'une fonction à une liste qui est passé: si vous modifier de la liste, il est modifié en dehors de la fonction, si vous remplacer, puis l'extérieur de la liste n'est pas affectée). Dans ce cas particulier, il n'y a pas d'effet visible que je peux voir.
InformationsquelleAutor Alex Martelli
32

utilisez set(), puis re-trier à l'aide de l'index de la liste d'origine.
```
>>> mylist = ['c','a','a','b','a','b','c']
>>> sorted(set(mylist), key=lambda x: mylist.index(x))
['c', 'a', 'b']
```
- C'est fantastique! Exactement ce que je cherchais. Pourriez-vous nous expliquer comment cela fonctionne? (avec l'utilisation de lambda, etc) Merci
- Neat code Python. L'inconvénient est qu'il provoque un tri supplémentaire, donc inutile de O(n * log(n)) (où O(n) serait suffisante).
- peut être soignée, en terme de performance loin d'être optimale
InformationsquelleAutor egafni
9

Générateurs sont grands.
```
def unique( seq ):
    seen = set()
    for item in seq:
        if item not in seen:
            seen.add( item )
            yield item

biglist[:] = unique( biglist )
```
- C'est ce dont j'avais besoin pour mon problème. Je suggère de le rendre plus générique, l'ajout de key=lambda item: item à la signature de la méthode. Ensuite, utilisez key(item) pour le jeu.
InformationsquelleAutor Jochen Ritzel

Cette page décrit les différentes méthodes et leurs vitesses:
http://www.peterbe.com/plog/uniqifiers-benchmark

Recommandée* méthode:

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

*par cette page

InformationsquelleAutor Tarnay Kálmán

C'est un élégant et compact, avec une compréhension de liste (mais pas aussi efficace qu'avec dictionnaire):

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

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

Et dans le contexte de la réponse:

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

InformationsquelleAutor rools

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

print newlist
```
produit
```
[{'link': 'u2.com', 'title': 'U2 Band'}, {'link': 'abc.com', 'title': 'ABC Station'}]
```
Notez qu'ici, j'ai utilisé un dictionnaire. Cela rend le test not in dups beaucoup plus efficace que l'utilisation d'une liste.
- Vous vous trompez sur la vérification dans un dict étant plus rapide que dans un jeu (les listes sont d'une nature différente).
- ok, corrigé, merci. Je suppose que jeu est probablement mis en œuvre avec une valeur de hachage.
InformationsquelleAutor Peter

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

sortie sera:

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

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

InformationsquelleAutor falco

0

Un moyen super facile à faire c'est:
```
def uniq(a):
    if len(a) == 0:
        return []
    else:
        return [a[0]] + uniq([x for x in a if x != a[0]])
```
Ce n'est pas la manière la plus efficace, parce que:
- il recherche à travers l'ensemble de la liste pour chaque élément dans la liste, il est donc O(n^2)
- c'est récursif donc utilise une pile de profondeur égale à la longueur de la liste
Cependant, par des gestes simples (pas plus de quelques centaines d'articles, et non pas critique pour les performances), il est suffisant.
- Quelqu'un peut-il trouver un moyen qui est-il évolutif?
- Kalmi de la réponse à un certain nombre de bonnes solutions.
InformationsquelleAutor Greg Hewgill
0

Je pense que l'utilisation d'un ensemble doit être assez efficace.
```
seen_links = set()
for index in len(biglist):
    link = biglist[index]['link']
    if link in seen_links:
        del(biglist[index])
    seen_links.add(link)
```
Je pense que cela devrait venir en O(nlog(n))
- en fait, il est O(n^2) parce que del sur une liste est O(n)
- Il en est ainsi. Merci!
InformationsquelleAutor ABentSpoon

Vous devez vous connecter pour publier un commentaire.