Discussion :

[kali38]

Bonjour,

Ma question est simple, savoir comment supprimer des listes qui pourrait se répèter dans une liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

maListe = [[a,a],[b,b],[a,a],[b,b]]

et j'aimerai obtenir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

maNewList = [[a,a],[b,b]]

[rambc]

Bonjour,
on peut faire comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
maListe = [['a','a'],['b','b'],['a','a'],['b','b']]
 
listeNettoyee = []
 
for x in maListe:
    if x not in listeNettoyee:
        listeNettoyee.append(x)
 
print listeNettoyee

Ceci renvoie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[['a', 'a'], ['b', 'b']]

[fred1599]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

maListe = [list(x) for x in set(tuple(x) for x in maListe)]

Somme toutes la fonction de rambc est bien plus efficace.

[yoshik]

Bonsoir,

Comme ça aussi ça marche (c'est un peu du "détournement") :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
maListe = [['a','a'],['b','b'],['a','a'],['b','b']]
 
listeNettoyee,a = [],[]
 
for L in maListe:
    try:
        a=listeNettoyee.index(L)
    except:
        listeNettoyee.append(L)
 
print listeNettoyee

J'avais envie de mettre mon grain de sel...

@+

[fred1599]

@yoshik c'est une autre solution, mais pas la meilleure, rambc reste bien loin devant

fred1599@fred1599-Aspire-5741G:~/Bureau$ python3 test.py
yoshik : 7.5600000000000005 secondes
rambc : 1.1499999999999995 secondes
fred1599 : 4.300000000000001 secondes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import time
maListe = [['a','a'],['b','b'],['a','a'],['b','b']]
 
def yoshik(liste):
    listeNettoyee,a = [],[]
    for L in liste:
        try:
            a=listeNettoyee.index(L)
        except:
            listeNettoyee.append(L)
    return listeNettoyee
 
def rambc(liste):
    listeNettoyee = []
    for x in liste:
        if x not in listeNettoyee:
            listeNettoyee.append(x)
    return listeNettoyee
 
def fred1599(liste):
    return [list(x) for x in set(tuple(x) for x in maListe)]
 
start = time.clock()
for i in range(1000000):
    yoshik(maListe)
print("yoshik : {} secondes".format(time.clock()-start))
 
start = time.clock()
for i in range(1000000):
    rambc(maListe)
print("rambc : {} secondes".format(time.clock()-start))
 
start = time.clock()
for i in range(1000000):
    fred1599(maListe)
print("fred1599 : {} secondes".format(time.clock()-start))

[yoshik]

Re,

Oui, j'en étais bien persuadé d'avance : trop d'appels à la liste... ;-)
C'était juste parce que un peu atypique.

@+

[fred1599]

Bon j'ai trouvé plus rapide (un peu) avec ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def filtrer(liste):
    for i in liste:
        if liste.count(i)>1:
            liste.remove(i)
    return liste

fred1599 : 0.84 secondes

[wiztricks]

Salut,
Oui mais ca n'enlève "que" la première occurrence et non tout les doublons.

Personnellement je préfère la construction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
liste = [...]
new_list = list(set(liste))

qui ne fonctionne pas ici car les item de liste ne sont pas "hashable"...

Ce qui m'interpelle quelque part car si on sait dire que A == B lorsque A et B sont des types simples, çà devient beaucoup plus compliqué à établir lorsque ce sont des "boîtes" telle qu'une liste...
Dit autrement quand list(set(liste)) ne fonctionne pas, je suis peut être en train de faire n'importe quoi.

Ne serait-il pas possible d'avoir une liste de tuple à la place?
genre: maListe = [('a','a'),('b','b'),('a','a'),('b','b')]

- W

[fred1599]

Oui mais ca n'enlève "que" la première occurrence et non tout les doublons.

J'ai pas compris là, je parcours bien toute la liste et supprime les éléments si il y a doublon ou plus même, non?

[tyrtamos]

Bonjour,

Pour la dernière fonction "filtrer": attention à l'effet de bord: la liste initiale est aussi modifiée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
x = [['a','a'],['b','b'],['a','a'],['b','b']]
y = filtrer(x)
print x
[['a', 'a'], ['b', 'b']]
print y
[['a', 'a'], ['b', 'b']]

Tyrtamos

[PauseKawa]

Bonjour,

Pas vraiment:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
liste = [['a','a'], ['a','a'], ['a','a'], ['b','b'], ['a','a'], ['b','b']]
 
def filtrer(liste):
    for i in liste:
        if liste.count(i)>1:
            liste.remove(i)
    return liste
 
filtrer(liste)
print(liste)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[['b', 'b'], ['a', 'a'], ['b', 'b']]

Si tu souhaite vraiment compter les éléments c'est plus quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
l = [['a','a'], ['c','c'], ['a','a'], ['a','a'], ['b','b'], ['a','a'], ['b','b']]
r = []
 
def filtrer(l):
    while len(l) > 0:
        if l.count(l[0]) == 1:
            r.append(l[0])
        l.remove(l[0])
 
filtrer(l)
print(r)

@+

Edit:
Ou encore

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
l = [['a','a'], ['c','c'], ['a','a'], ['a','a'], ['b','b'], ['a','a'], ['b','b']]
r = []
 
def filtrer(l):
    while len(l) > 0:
        e = l.pop()
        if l.count(e) == 0:
            r.append(e)
 
filtrer(l)
print(r)

La version sans count

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
l = [['a','a'], ['c','c'], ['a','a'], ['a','a'], ['b','b'], ['a','a'], ['b','b']]
r = []
 
def filtrer(l):
    while len(l) > 0:
        e = l.pop()
        if e not in r:
            r.append(e)
 
filtrer(l)
print(r)

[tyrtamos]

Bonjour PauseKawa

Pas vraiment:

Effectivement, j'aurais dû avoir le reflexe: ce qui ne va pas dans cette fonction "filtrer", c'est qu'on ne doit pas modifier une liste pendant qu'on la parcours avec une boucle for!

Il faut utiliser while dans ce cas. Quelque chose comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
def filtrer(liste):
    k = 0
    while k<len(liste):
        if liste.count(liste[k])>1:
            liste.remove(liste[k])
        else:
            k += 1
    return liste

Comme précédemment, la liste initiale est modifiée.

Tyrtamos

[PauseKawa]

Effectivement.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
liste = [['a','a'], ['a','a'], ['a','a'], ['b','b'], ['a','a'], ['b','b']]
 
def filtrer(liste):
    for i, v in enumerate(liste):
        if liste.count(v) > 1:
            print v, liste.count(v)
            liste.pop(i)
 
filtrer(liste)
print liste

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
['a', 'a'] 4
['a', 'a'] 3
['a', 'a'] 2
[['a', 'a'], ['b', 'b'], ['b', 'b']]

[PauseKawa]

C'est assez trompeur tout de même

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
liste = [['a','a'], ['a','a'], ['a','a'], ['b','b'], ['a','a'], ['b','b']]
 
def filtrer(liste):
    for i, v in enumerate(liste):
        print ("Index dans la liste %i, Longueur de la liste %i")%(i, len(liste))
        if liste.count(v) > 1:
            liste.pop(i)
    print("Index final %i, Longueur finale %i")%(i, len(liste))
 
filtrer(liste)
print liste, ":("
 
liste = [['a','a'], ['a','a'], ['a','a'], ['a','a'], ['b','b'], ['b','b']]
filtrer(liste)
print liste, ":("
 
liste = [['a','a'], ['a','a'], ['a','a'], ['b','b'], ['b','b']]
filtrer(liste)
print liste, "<< ^^"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Index dans la liste 0, Longueur de la liste 6
Index dans la liste 1, Longueur de la liste 5
Index dans la liste 2, Longueur de la liste 4
Index final 2, Longueur finale 3
[['a', 'a'], ['b', 'b'], ['b', 'b']] :(
Index dans la liste 0, Longueur de la liste 6
Index dans la liste 1, Longueur de la liste 5
Index dans la liste 2, Longueur de la liste 4
Index final 2, Longueur finale 3
[['a', 'a'], ['a', 'a'], ['b', 'b']] :(
Index dans la liste 0, Longueur de la liste 5
Index dans la liste 1, Longueur de la liste 4
Index dans la liste 2, Longueur de la liste 3
Index final 2, Longueur finale 2
[['a', 'a'], ['b', 'b']] << ^^

[fred1599]

En effet j'ai été un peu rapide dans mes conclusions, je vois le problème maintenant.

Merci pour les démonstrations.

[PauseKawa]

Bonjour,

Il faut utiliser while dans ce cas. Quelque chose comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
def filtrer(liste):
    k = 0
    while k<len(liste):
        if liste.count(liste[k])>1:
            liste.remove(liste[k])
        else:
            k += 1
    return liste

Comme précédemment, la liste initiale est modifiée.

Tyrtamos

Le tout est de savoir ce que souhaite kali38, modifier la liste ou en créer une nouvelle. C'est pas clair sur le sujet.

Bonjour,

Ma question est simple, savoir comment supprimer des listes qui pourrait se répèter dans une liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

maListe = [[a,a],[b,b],[a,a],[b,b]]

et j'aimerai obtenir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

maNewList = [[a,a],[b,b]]

Dans le cadre de remove/pop et maNewList cela passe par une copie de liste

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
liste = [['a','a'], ['a','a'], ['a','a'], ['b','b'], ['a','a'], ['b','b']]
 
def filtrer(liste):
    manewlist = list(liste)
    k = 0
    while k<len(manewlist):
        if manewlist.count(manewlist[k]) > 1:
            manewlist.remove(manewlist[k])
        else:
            k += 1
    return manewlist
 
print(filtrer(liste))
print(liste)

Enfin... Ceci dit tout ceci c'est des paroles. La solution reste celle de rambc.

@+

[tyrtamos]

Oui, la 1ère solution de ramc est celle que je préfère, et c'est celle que j'utilise le plus souvent.

Son seul défaut est de parcourir la liste qu'on est en train de construire, autant de fois qu'il y a d'éléments dans la liste à filtrer. Pour des listes de taille importante, cela peut demander du temps.

Il m'est déjà arrivé dans ce cas d'utiliser l'astuce suivante: on profite de la rapidité du tri Python ".sort()" pour faire en sorte que les éléments identiques se suivent. Dans ce cas, on empile un nouvel élément que s'il est différent du dernier empilé!

Voilà ce que ça pourrait donner:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def filtrer(liste):
    if liste == []:
        return []
    L = liste[:]
    L.sort()
    R = [L[0]]
    for elem in L:
        if elem != R[-1]:
            R.append(elem)
    return R
 
liste = [['a','a'], ['a','a'], ['a','a'], ['b','b'], ['a','a'], ['b','b']]
 
print filtrer(liste)
[['a', 'a'], ['b', 'b']]

A voir, en fonction de la liste à filtrer, si le tri prend effectivement moins de temps que le parcours de la liste à construire.

Tyrtamos

[brachior]

Quitte à trier,
Pourquoi ne pas modifier de peu la fonction quicksort ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
def setsort(list):
  if list==[]:
    return []
  else:
    l1 = setsort([x for x in list[1:] if x < list[0]])
    l3 = setsort([x for x in list[1:] if x >= list[0]])
    l2 = (list[0] not in l1 and list[0] not in l3) and [list[0]] or []
    return l1 + l2 + l3

[fred1599]

Je ne suis pas sûr qu'une fonction récursive soit très efficace en python.

Il m'est déjà arrivé dans ce cas d'utiliser l'astuce suivante: on profite de la rapidité du tri Python ".sort()" pour faire en sorte que les éléments identiques se suivent. Dans ce cas, on empile un nouvel élément que s'il est différent du dernier empilé!

Bien vu! On y pense jamais

Ta fonction est 2 fois plus rapide que la mienne, mais 2 fois plus lente que celle de rambc pour 10 Millions de répétitions.

@pausekawa ta version avec while est plus rapide que ma 1ère fonction mais moins rapide que la dernière version de tyrtamos.

Voici les résultats

analyse de la fonction rambc :
temps : 10.79 secondes
analyse de la fonction tyrtamos_while :
temps : 13.1 secondes
analyse de la fonction tyrtamos :
temps : 23.140000000000008 secondes
analyse de la fonction pausekawa :
temps : 33.08999999999999 secondes
analyse de la fonction fred1599 :
temps : 41.05 secondes
analyse de la fonction yoshik :
temps : 73.14 secondes

[PauseKawa]

Bonjour,

@pausekawa ta version avec while est plus rapide que ma 1ère fonction mais moins rapide que la dernière version de tyrtamos

Je n'avais pas chercher des résultats
De toute manière plus c'est 'simple' et plus c'est rapide (je ne parle pas des traitements lourds, multiprocessing et autre) mais surtout 'lisible'.

@+

Ps: Lors d'autres tests j'avais constater que while et 'plus long' que for. A confirmer.