Discussion :

[manaliac]

Bonjour,

Je voudrais supprimer des doublons dans une des sous-listes de la liste principales , mais ça ne marche pas !!
Pourtant mon code a l'air correct !

Code :

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

1
2
3
4
5
6
7
8
 
    for blk in split_ff: # liste principale
        if len(blk) >= 6 : # condition d'existence de la sous-liste ciblee
           for i in xrange(len(blk[5])):
               for j in reversed(xrange(i,len(blk[5]))):
                   if (blk[5][j] == blk[5][j-1]):
                       aki = blk[5].index(blk[5][j-1])
                       blk[5].pop(aki)

Qu'en pensez vous??

Merci
M.

[eyquem]

A priori, c’est grave komplik.
Ça le paraîtra peut être moins quand j’aurai compris la méthode.


Est-ce que blk[5] est une liste ?


On pourrait pas avoir une liste toute prête à être traitée, stp ?

[Zavonen]

Une astuce pour éliminer les doublons:

Code python :

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

1
2
3
L=[1,1,2,3]
Q=list(set(L))
print Q

A appliquer à votre sous-liste caractérisée par votre condition

Code python :

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

1
2
3
4
5
6
7
def cond(L):
    return len(L)>=6
def clean(L):
    return list(set(L))
E=[[1,1,2,3,4,5],[1,1,2]]
 
print [clean(x) if cond(x) else x for x in E]

[manaliac]

Bonjour,

Une astuce pour éliminer les doublons:
Code python :

L=[1,1,2,3]
Q=list(set(L))
print Q

J'ai déjà essayé cette méthode mais comme mes doublons sont des sous-listes, ça ne marche pas !!

Est-ce que blk[5] est une liste ?

En effet, en gros blk[5] est la liste qui contient mes sous listes avec doublons !!

Je dois vérifier si blk[5] existe, si oui, on rentre dans blk[5] qui contient des sous listes (d'ou les boucles sur les blk[5][j] et on compare puis on supprime l'élément visé)

M.

[manaliac]

Rebonjour,

J'ai programme ce petit code, et pour le moment il réussit à faire ce que je veux !!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
def rm_doublons(liste): 
    for blk in liste:           
        if len(blk) >= 6 :# condition de presence de patch dans le block
           for a in blk[5]:
               flag = 0
               for b in blk[5]:
                   if (a == b ):
                      flag = flag +1
                      if flag > 1 :
                         aki = blk[5].index(b)
                         blk[5].pop(aki)

Qu'en pensez vous??

[pacificator]

Bonjour,

comme mes doublons sont des sous-listes, ça ne marche pas !!

tu peux essayer en transformant tes sous-listes en tuple:

Code :

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

1
2
3
4
5
 
try:
    blk[5] = [list(y) for y in set([tuple(x) for x in blk[5]])]
except IndexError:
    pass

[wiztricks]

Salut,

Si le code vous plaît tant mieux car comme vous ne donnez aucune indication sur ce que sont le contenu des listes ni ce que le code est supposé faire dans les différents cas... Je ne vois pas trop comment nous pourrions vous aider.

Votre histoire semble pour le moins embrouillée.
Pourquoi ne pas faire un jeu de tests style: "lorsque l'entrée est XXXX, le résultat devrait être YYYY".
C'est vous qui voyez.
Bon courage.
- W

[manaliac]

Ben voilà le contenu des listes si cela vous aide :

liste = [a,b,c,d,e,[[1,2],[158,48],[1,2],[1,2]]

Je veux donc supprimer mes doublons [1,2] !!

M.

[tyrtamos]

Bonjour,

Ci-dessous un algo un peu rustique qui a l'air de faire ce que tu cherches (si j'ai bien compris):

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
def eliminedoublons(liste):
    r = []
    for elem in liste:
        if isinstance(elem, list):
            r2 = []
            for elem2 in elem:
                if elem2 not in r2:
                    r2.append(elem2)
            r.append(r2)
        else:
            r.append(elem)
    return r
 
liste = ['a', 'b', 'c', 'd', 'e', [[1,2], [158,48], [1,2], [1,2]]]
print eliminedoublons(liste)
['a', 'b', 'c', 'd', 'e', [[1, 2], [158, 48]]]

Tyrtamos

[eyquem]

Ben voilà le contenu des listes si cela vous aide

oh, à peine....

Code :

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

1
2
3
4
5
6
7
8
9
liste = ['a','b','c','d','e', [ [1,2],[158,48],[1,2],[1,2] ]  ]
 
vues,res = [],[]
[ (res.append(u),vues.append(u)) if u not in vues else vues.append(u) for u in liste[5]]
liste[5] = res
print id(res)
del res,vues
print liste
print id(liste[5])

tu vois, ça te fais deux réponses.
à peine

[manaliac]

Citation:
Ben voilà le contenu des listes si cela vous aide
oh, à peine....

Soyez pas méchants avec moi je suis perdue dans des listes immenses !!

En tout cas merci pour tout !

Une dernière question : est ce que mon programme est correct?

M.

[eyquem]

Ce n’est pas de la méchanceté gratuite. C’est pour te faire comprendre que tu aurais intérêt à te réveiller un peu.

21/07/2010 18h03
On pourrait pas avoir une liste toute prête à être traitée, stp ?

Hier 15h04
comme vous ne donnez aucune indication sur ce que sont le contenu des listes (...)... Je ne vois pas trop comment nous pourrions vous aider.

Aujourd'hui 13h46
Ben voilà le contenu des listes si cela vous aide :

Aujourd'hui 14h16
Aujourd'hui 14h23
boum: deux réponses

Tu as perdu 44 heures.









Méthode plus déliée et lisible, en une seule ligne:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
liste = ['a','b','c','d','e', [ [1,2],[158,48],[1,2],[1,2] ]  ]
 
print liste
print 'id(liste)    =',id(liste)
print 'id(liste[5]) =',id(liste[5])
 
liste[5] =  [  u for i,u in enumerate(liste[5]) if u not in liste[5][0:i] ]
 
print '\n',liste
print 'id(liste)    =',id(liste)
print 'id(liste[5]) =',id(liste[5])

Code :

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

1
2
3
4
5
6
7
['a', 'b', 'c', 'd', 'e', [[1, 2], [158, 48], [1, 2], [1, 2]]]
id(liste)    = 17540520
id(liste[5]) = 17418920
 
['a', 'b', 'c', 'd', 'e', [[1, 2], [158, 48]]]
id(liste)    = 17540520
id(liste[5]) = 17541480

Nota bene 1:
l'ordre est conservé

NB 2:
Cette méthode n’est valable que pour des listes de longueur moderée, car à chaque fois qu’un examen if u not in liste[5][0:i] est effectué,
la partie liste[5][0:i-1] est réexaminée alors qu’elle l’a déjà été au précédent tour.
C’est le prix à payer pour avoir une expression en une ligne.





Les résultats avant/après de

Code :

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

1
2
print 'id(liste)    =',id(liste)
print 'id(liste[5]) =',id(liste[5])

sont intéressants: il est bon de s’habituer à penser selon le data model de Python.



id() donne l’adresse d’un objet.

L’adresse de l’objet liste ne change pas.

Par contre l’adresse de liste[5] change.
« Oh ! comme c’est bizarre » dira un habitué d’un langage utilisant les variables dont la localisation est fixe et le contenu modifiable.



C’est que liste[5] n’est pas une variable.
En Python, la représentation binaire de la data donnée par liste[5] n’est pas à l’emplacement 5 dans liste.

Alors qu’est ce que liste[5] ?
liste[5] n’est pas l’emplacement 5 de liste: c’est un objet qui est ailleurs que dans liste , quelque part à l’adresse id(liste[5]) . C’est cette adresse qui est placée par l’exécution à l’emplacement 5 dans liste.

Les deux objets avant et après ne sont pas les mêmes, c’est à dire que leurs adresses sont différentes. Seul l’endroit où leurs adresses sont stockées reste la même: il s’agit de l’emplacement 5 de liste.

La nouvelle adresse de l’objet liste[5] remplace à l’emplacement 5 de liste l’adresse de l’objet qui assurait la représentation de la data donnée par liste[5] avant sa transformation.





En termes de ce qui nous intéresse, c’est à dire les data hébergées par liste[5] , cette dernière ne se comporte pas comme une variable.

Mais l’emplacement 5 de liste se comporte, lui, comme une variable.

[manaliac]

Merci infiniment !!

M.

[wiztricks]

Plus sportif?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
def dedoublonne(li):
    def is_not_mapped(u, d={}):
        if u not in d:
            d[u] = None
            return True
    return [ e for e in li if is_not_mapped(tuple(e)) ]
 
if __name__ == '__main__':
    liste = [[1,2], [158,48], [1,2], [1,2]]
    nli = dedoublonne(liste)
    for x in nli:
        print x,

- W

[eyquem]

Message #10

Code :

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

1
2
3
4
5
6
7
8
9
liste = ['a','b','c','d','e', [ [1,2],[158,48],[1,2],[1,2] ]  ]
 
vues,res = [],[]
[ (res.append(u),vues.append(u)) if u not in vues else vues.append(u) for u in liste[5]]
liste[5] = res
print id(res)
del res,vues
print liste
print id(liste[5])

idiot

[eyquem]

Code :

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

1
2
3
4
5
6
def dedoublonne(li):
    def is_not_mapped(u, d={}):
        if u not in d:
            d[u] = None
            return True
    return [ e for e in li if is_not_mapped(tuple(e)) ]

Pas mal.
Je suis un peu obsédé par la concision, d’où ma recherche d’un code plus court et moins abstrus que celui du message # 10. J’ai aussi tendance à chercher à éviter la définition de fonctions. Ce qui m'a conduit au code du message #12:
liste[5] = [ u for i,u in enumerate(liste[5]) if u not in liste[5][0:i] ]
Mais cette fonction dedoublonne() rend le code plus “parlant“.

Pas mal aussi le coup de l’argument par défaut qui recueille les valeurs déjà vues: ça évite une ligne...
Le fait que l’argument par défaut d={} soit défini pour la fonction is_not_mapped() qui est dans la fonction dedoublonne() , et que donc cet argument par défaut reparte avec une valeur vide {} à chaque appel de dedoublonne() , est à remarquer comme une bonne chose résultant de cette définition de dedoublonne().






Mais il y a un problème à employer tuple() pour rendre hashables les éléments afin de pouvoir les mettre en dictionnaire:
certains éléments qui devraient se retrouver dans la liste dédoublonnée ne le sont pas à cause de la transformation qu’opère tuple() sur un dictionnaire et une chaîne de caractères:

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
def dedoublonne(li):
    def is_not_mapped(u, d={}):
        if u not in d:
            d[u] = None
            return True
    return [  e for e in li if is_not_mapped(tuple(e)) ]
 
 
for lou in ([ [1,2],    [1,2],[90,78],{1:'AA' ,2:'BB'} ,[123,7],[90,78] ],
            [ [111,222],[1,2],[90,78],{111:'a',222:'b'},[123,7],[90,78] ],
            [ [1,2],'ar',[1,2],[90,78],{'a':8,'r':9},[3,7],[90,78] ],
            [ [1,2],'ar',[1,2],[90,78],['a','r'],[3,7],[90,78] ],
            [ [1,2],('b','g'),[1,2],[90,78],'bg',[3,7],[90,78] ],
            [ [1,2],[13,99],234,[1,2],[78,66]]
            ):
    print '\nlou =\n',lou,'\ndedoublonne(lou) =\n',dedoublonne(lou)

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
lou =
[[1, 2], [1, 2], [90, 78], {1: 'AA', 2: 'BB'}, [123, 7], [90, 78]] 
dedoublonne(lou) =
[[1, 2], [90, 78], [123, 7]]
 
lou =
[[111, 222], [1, 2], [90, 78], {222: 'b', 111: 'a'}, [123, 7], [90, 78]] 
dedoublonne(lou) =
[[111, 222], [1, 2], [90, 78], {222: 'b', 111: 'a'}, [123, 7]]
 
lou =
[[1, 2], 'ar', [1, 2], [90, 78], {'a': 8, 'r': 9}, [3, 7], [90, 78]] 
dedoublonne(lou) =
[[1, 2], 'ar', [90, 78], [3, 7]]
 
lou =
[[1, 2], 'ar', [1, 2], [90, 78], ['a', 'r'], [3, 7], [90, 78]] 
dedoublonne(lou) =
[[1, 2], 'ar', [90, 78], [3, 7]]
 
lou =
[[1, 2], ('b', 'g'), [1, 2], [90, 78], 'bg', [3, 7], [90, 78]] 
dedoublonne(lou) =
[[1, 2], ('b', 'g'), [90, 78], [3, 7]]
 
lou =
[[1, 2], [13, 99], 234, [1, 2], [78, 66]] 
dedoublonne(lou) =
 
Traceback (most recent call last):
  File "E:\Python\python27 12juillet10\liuy.py", line 16, in <module>
    print '\nlou =\n',lou,'\ndedoublonne(lou) =\n',dedoublonne(lou)
  File "E:\Python\python27 12juillet10\liuy.py", line 6, in dedoublonne
    return [  e for e in li if is_not_mapped(tuple(e)) ]
TypeError: 'int' object is not iterable

tuple(un dictionnaire) renvoie un truc basé sur les clés seulement
et
tuple(un nombre) --> erreur

Code :

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

1
2
3
4
print "tuple({1:'AA' ,2:'BB'}) =",tuple({1:'AA' ,2:'BB'})
print "tuple({111:'a',222:'b'}) =",tuple({111:'a',222:'b'})
print "tuple({'a':8,'r':9}) =",tuple({'a':8,'r':9})
print 'tuple(234) =',tuple(234)

Code :

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

1
2
3
4
5
6
7
8
9
tuple({1:'AA' ,2:'BB'}) = (1, 2)
tuple({111:'a',222:'b'}) = (222, 111)
tuple({'a':8,'r':9}) = ('a', 'r')
tuple(234) =
 
Traceback (most recent call last):
  File "E:\Python\python27 12juillet10\wert.py", line 25, in <module>
    print 'tuple(234) =',tuple(234)
TypeError: 'int' object is not iterable

----------------



Il vaut mieux employer repr() à la place de tuple() pour rendre hashable un objet et pouvoir le mettre comme clé de dictionnaire:

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
def dedoublonne2(li):
    def is_not_mapped(u, d={}):
        if u not in d:
            d[u] = None
            return True
    return [  e for e in li if is_not_mapped(repr(e)) ]
 
for lou in ([ [1,2],    [1,2],[90,78],{1:'AA' ,2:'BB'} ,[123,7],[90,78] ],
            [ [111,222],[1,2],[90,78],{111:'a',222:'b'},[123,7],[90,78] ],
            [ [1,2],'ar',[1,2],[90,78],{'a':8,'r':9},[3,7],[90,78] ],
            [ [1,2],'ar',[1,2],[90,78],['a','r'],[3,7],[90,78] ],
            [ [1,2],('b','g'),[1,2],[90,78],'bg',[3,7],[90,78] ],
            [ [1,2],[13,99],234,[1,2],[78,66]]):
    print '\nlou =\n',lou,'\ndedoublonne2(lou) =\n',dedoublonne2(lou)
 
print '\n\n'
 
print "repr({1:'AA' ,2:'BB'}) =",repr({1:'AA' ,2:'BB'})
print "repr({111:'a',222:'b'}) =",repr({111:'a',222:'b'})
print "repr({'a':8,'r':9}) =",repr({'a':8,'r':9})
print 'repr(234) =',repr(234)

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
lou =
[[1, 2], [1, 2], [90, 78], {1: 'AA', 2: 'BB'}, [123, 7], [90, 78]] 
dedoublonne2(lou) =
[[1, 2], [90, 78], {1: 'AA', 2: 'BB'}, [123, 7]]
 
lou =
[[111, 222], [1, 2], [90, 78], {222: 'b', 111: 'a'}, [123, 7], [90, 78]] 
dedoublonne2(lou) =
[[111, 222], [1, 2], [90, 78], {222: 'b', 111: 'a'}, [123, 7]]
 
lou =
[[1, 2], 'ar', [1, 2], [90, 78], {'a': 8, 'r': 9}, [3, 7], [90, 78]] 
dedoublonne2(lou) =
[[1, 2], 'ar', [90, 78], {'a': 8, 'r': 9}, [3, 7]]
 
lou =
[[1, 2], 'ar', [1, 2], [90, 78], ['a', 'r'], [3, 7], [90, 78]] 
dedoublonne2(lou) =
[[1, 2], 'ar', [90, 78], ['a', 'r'], [3, 7]]
 
lou =
[[1, 2], ('b', 'g'), [1, 2], [90, 78], 'bg', [3, 7], [90, 78]] 
dedoublonne2(lou) =
[[1, 2], ('b', 'g'), [90, 78], 'bg', [3, 7]]
 
lou =
[[1, 2], [13, 99], 234, [1, 2], [78, 66]] 
dedoublonne2(lou) =
[[1, 2], [13, 99], 234, [78, 66]]
 
 
 
repr({1:'AA' ,2:'BB'}) = {1: 'AA', 2: 'BB'}
repr({111:'a',222:'b'}) = {222: 'b', 111: 'a'}
repr({'a':8,'r':9}) = {'a': 8, 'r': 9}
repr(234) = 234

Ceci dit, pourquoi vouloir employer un dictionnaire plutôt qu’une liste ??

Utiliser une liste comme stockage des déjà vus permet au passage une petite astuce à mon goût qui permet de diminuer d’une ligne (!...) , puisque liste.append(truc) retourne None et que not None vaut True.

Dans la foulée, je préfère renommer is_not_mapped() en first_met() pour dénommer la fonction d’une façon qui correspond à ce qu’elle fait positivement, et non pas par ce qu’elle évite.

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','b','c','d','e', [ [1,2],[158,48],[1,2],[1,2] ]  ]
 
def dedoublonne(li):
    def first_met(u, stokli=[]):
        if u not in stokli:  return not stokli.append(u)
    return [ e for e in li if first_met(e) ]
 
for lou in ([ [1,2],    [1,2],[90,78],{1:'AA' ,2:'BB'} ,[123,7],[90,78] ],
            [ [111,222],[1,2],[90,78],{111:'a',222:'b'},[123,7],[90,78] ],
            [ [1,2],'ar',[1,2],[90,78],{'a':8,'r':9},[3,7],[90,78] ],
            [ [1,2],'ar',[1,2],[90,78],['a','r'],[3,7],[90,78] ],
            [ [1,2],('b','g'),[1,2],[90,78],'bg',[3,7],[90,78] ],
            [ [1,2],[13,99],234,[1,2],[78,66]]):
    print '\nlou =\n',lou,'\ndedoublonne(lou) =\n',dedoublonne(lou)

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
lou =
[[1, 2], [1, 2], [90, 78], {1: 'AA', 2: 'BB'}, [123, 7], [90, 78]] 
dedoublonne(lou) =
[[1, 2], [90, 78], {1: 'AA', 2: 'BB'}, [123, 7]]
 
lou =
[[111, 222], [1, 2], [90, 78], {222: 'b', 111: 'a'}, [123, 7], [90, 78]] 
dedoublonne(lou) =
[[111, 222], [1, 2], [90, 78], {222: 'b', 111: 'a'}, [123, 7]]
 
lou =
[[1, 2], 'ar', [1, 2], [90, 78], {'a': 8, 'r': 9}, [3, 7], [90, 78]] 
dedoublonne(lou) =
[[1, 2], 'ar', [90, 78], {'a': 8, 'r': 9}, [3, 7]]
 
lou =
[[1, 2], 'ar', [1, 2], [90, 78], ['a', 'r'], [3, 7], [90, 78]] 
dedoublonne(lou) =
[[1, 2], 'ar', [90, 78], ['a', 'r'], [3, 7]]
 
lou =
[[1, 2], ('b', 'g'), [1, 2], [90, 78], 'bg', [3, 7], [90, 78]] 
dedoublonne(lou) =
[[1, 2], ('b', 'g'), [90, 78], 'bg', [3, 7]]
 
lou =
[[1, 2], [13, 99], 234, [1, 2], [78, 66]] 
dedoublonne(lou) =
[[1, 2], [13, 99], 234, [78, 66]]

.

[wiztricks]

Whaouh Eyquem

Je vois que mes quelques lignes de programmation instinctive t'ont bien inspiré.
Et effectivement remplacer tuple par repr et dict par list permettre de généraliser un peu plus cela.
Mais fondamentalement le truc qui me gène est que la chose construite par la "nested function" repète la chose qui sera retournée à l'appelant.

Pour l'instant, je n'ai pas de version satisfaisante... .Sinon le machin ci dessous qui fait un peu çà.

Comme la liste retournée est construite à partir de la liste lue, "instinctivement" çà fait penser à un generator du style:
g = (s.append(u) for u in L if u not in s and True or False)
Pour amorcer le "generator":
for x in g: pass # tres beurk!!!
Le tout ensemble:

Code :

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

1
2
3
4
5
def dedoublonne(L):
    def foo(L, s=[]):
        g = (s.append(u) for u in L if u not in s and True or False)
        return [s for x in g][0]
    return foo(L)

- W
PS: Une version plus compacte... où comment utiliser des effets de bords qui rendent le code dur à comprendre.

Code :

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

dedoublonne = lambda L, s=[]: [ s for u in L if u not in s and (not s.append(u)) or 0 ][0]

[eyquem]

Je vois que mes quelques lignes de programmation instinctive t'ont bien inspiré.

En effet.
Je porte un peu plus d’attention à certains posts, disons à certains auteurs.

Cela me conduit aussi plus facilement à y trouver à redire.


Ainsi concernant

Code :

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

1
2
3
    def foo(L, s=[]):
        g = (s.append(u) for u in L if u not in s and True or False)
        return [s for x in g][0]

il n’y a pas que la façon d’activer le générateur qui est beurk. C’est tout l’ensemble que je trouve.... horrible.






D’abord u not in s and True or False qui me laisse perplexe.
Je sais bien qu’il s’agit de l’astuce and-or
http://diveintopython.org/power_of_i...r.html#d0e9975
mais je ne vois pas sa nécessité ici.

Ça marche aussi bien sans.

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
iste = [[1,2], [158,48], [1,2], [1,2], [23,45], [1,2], [23,45],[345,89,4],
         [20,13],[4,9,20],[1,2],[1,2],[4,9,0,1000],[23,45],[4,9,20],[1,2],
         [158,48],[345,89,4],[1,2],[4,9,20],[0,10],[11,2],[345,89,4],[1,2],
         [2014,2012,2011],[1,2],[23,45],[1,2],[11,2],[345,89,4],[138,48]]
 
def dedoublonne(L):
    def foo(L, s=[]):
        g = (s.append(u) for u in L if u not in s and True or False)
        return [s for x in g][0]
    return foo(L)
 
print 'liste =\n',liste
print '\ndedoublonne(liste) =\n',dedoublonne(liste)
 
 
def dedoublonne_sansTF(L):
    def foo(L, s=[]):
        g = (s.append(u) for u in L if u not in s)
        return [s for x in g][0]
    return foo(L)
 
print '\ndedoublonne_sansTF =\n',dedoublonne_sansTF(liste)

Code :

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

1
2
3
4
5
6
7
8
liste =
[[1, 2], [158, 48], [1, 2], [1, 2], [23, 45], [1, 2], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [1, 2], [1, 2], [4, 9, 0, 1000], [23, 45], [4, 9, 20], [1, 2], [158, 48], [345, 89, 4], [1, 2], [4, 9, 20], [0, 10], [11, 2], [345, 89, 4], [1, 2], [2014, 2012, 2011], [1, 2], [23, 45], [1, 2], [11, 2], [345, 89, 4], [138, 48]]
 
dedoublonne(liste) =
[[1, 2], [158, 48], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [4, 9, 0, 1000], [0, 10], [11, 2], [2014, 2012, 2011], [138, 48]]
 
dedoublonne_sansTF =
[[1, 2], [158, 48], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [4, 9, 0, 1000], [0, 10], [11, 2], [2014, 2012, 2011], [138, 48]]

fondamentalement le truc qui me gène est que la chose construite par la "nested function" repète la chose qui sera retournée à l'appelant.

Tu veux dire que dans le code suivant

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
def dedoublonne_X(li):
    def first_met(u, stokli=[]):
        if u not in stokli:
            stokli.append(u)
            return True
    res = [ e for e in li if first_met(e) ]
    print '\navant la sortie de dedoublonne_X():'
    print '\nsortie de dedoublonne_X  =',res,'  (res)'
    print '\nfirst_met.func_defaults =',first_met.func_defaults,'(stokli)'
    print 'id(res) =',id(res)
    print 'id(first_met.func_defaults) =',id(first_met.func_defaults)
    print 'id(first_met.func_defaults[0]) =',id(first_met.func_defaults[0])
    return res
 
lulu = [[6,8],[9,67],[5,1,2],[9,67],[6,8],[9,67],[3,4],[6,8]]
print 'lulu =\n',lulu
dedoublonne_X(lulu)

res et stokli sont deux objets différents alors qu’ils ont la même valeur ? :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
lulu =
[[6, 8], [9, 67], [5, 1, 2], [9, 67], [6, 8], [9, 67], [3, 4], [6, 8]]

avant la sortie de dedoublonne_X():

sortie de dedoublonne_X  = [[6, 8], [9, 67], [5, 1, 2], [3, 4]]   (res)

first_met.func_defaults = ([[6, 8], [9, 67], [5, 1, 2], [3, 4]],) (stokli)
id(res) = 17552008
id(first_met.func_defaults) = 9930480
id(first_met.func_defaults[0]) = 17551728

C’est tout à fait pertinent comme remarque ça.
Finalement, pour dédoublonner les éléments d’une liste, je passe par la liste dédoublonnée en double !

D’où l’aspiration à éviter ce doublement.


Mais là où je ne suis plus, c’est

la liste retournée est construite à partir de la liste lue, "instinctivement" çà fait penser à un generator

Primo, pour ce qui est d’activer le générateur.... allons allons wiztricks:

Code :

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

1
2
3
4
5
6
def dedoublonne1(L):
    def foo(L, s=[]):
        g = (s.append(u) for u in L if u not in s and True or False)
        list(g)
        return s
    return foo(L)

Secondo, pourquoi penser à un generateur, et pas à une comprehension list tout de suite ??? C’est à dire à rien d’autre que list(g) ....

Code :

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

1
2
3
def dedoublonne_CL_AD(L,s=[]):
    [ s.append(u) for u in L if u not in s ]
    return s

Mais attention à l’argument par défaut s=[] qui stocke les listes dédoublées produites lors d’appels successifs de dedoublonne()

Code :

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

1
2
3
4
5
6
7
8
9
def dedoublonne_CL_AD(L,s=[]):
    [ s.append(u) for u in L if u not in s ]
    return s
 
lala = [[6,8],[9,67],[5,1,2],[9,67],[6,8],[3,4],[6,8]]
lala2 = [[1,3],[100,200],[5,1,2],[100,200],[1,3],[5,7]]
print '\nlala =',lala,'\nlala2 =',lala2
print '\ndedoublonne_CL_AD(lala ) =',dedoublonne_CL_AD(lala)
print 'dedoublonne_CL_AD(lala2) =',dedoublonne_CL_AD(lala2)

Code :

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

1
2
3
4
5
lala = [[6, 8], [9, 67], [5, 1, 2], [9, 67], [6, 8], [3, 4], [6, 8]] 
lala2 = [[1, 3], [100, 200], [5, 1, 2], [100, 200], [1, 3], [5, 7]]
 
dedoublonne_CL_AD(lala ) = [[6, 8], [9, 67], [5, 1, 2], [3, 4]]
dedoublonne_CL_AD(lala2) = [[6, 8], [9, 67], [5, 1, 2], [3, 4], [1, 3], [100, 200], [5, 7]]

La solution: s pas en argument par défaut:

Code :

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

1
2
3
4
def dedoublonneCL(L):
    s = []
    [ s.append(u) for u in L if u not in s ]
    return s

Finalement, penser “exécution éclair par générateur“ c’est bien, mais se retrouver enfermé dans la problématique du fonctionnement d’un générateur, ça l’est moins.

Surtout que dedoublonneCL() ne fait qu’envoyer en sortie une adresse, il n’y a pas recopie dans un nouvel objet de la liste s construite à l’intérieur de la fonction dedoublonneCL()

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 dedoublonneCL(L):
    s = []
    [ s.append(u) for u in L if u not in s ]
    print '\nid(s) avant sortie de dedoublonneCL() =',id(s)
    return s
 
lala = [[6,8],[9,67],[5,1,2],[9,67],[6,8],[3,4],[6,8]]
lala2 = [[1,3],[100,200],[5,1,2],[100,200],[1,3],[5,7]]
print '\nlala =',lala,'\n\nlala2 =',lala2
x = dedoublonneCL(lala)
print 'dedoublonneCL(lala ) =',x
print 'id(liste dedoublonnee apres sortie de dedoublonneCL() ) =',id(x)
y = dedoublonneCL(lala2)
print 'dedoublonneCL(lala2) =',y
print 'id(liste dedoublonnee apres sortie de dedoublonneCL() ) =',id(y)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
lala = [[6, 8], [9, 67], [5, 1, 2], [9, 67], [6, 8], [3, 4], [6, 8]] 

lala2 = [[1, 3], [100, 200], [5, 1, 2], [100, 200], [1, 3], [5, 7]]

id(s) avant sortie de dedoublonneCL() = 17553208
dedoublonneCL(lala ) = [[6, 8], [9, 67], [5, 1, 2], [3, 4]]
id(liste dedoublonnee apres sortie de dedoublonneCL() ) = 17553208

id(s) avant sortie de dedoublonneCL() = 17552768
dedoublonneCL(lala2) = [[1, 3], [100, 200], [5, 1, 2], [5, 7]]
id(liste dedoublonnee apres sortie de dedoublonneCL() ) = 17552768

==========================





Je signale au passage une façon de dédoublonner une liste en passant par sort().
L’idée : profiter de la grande rapidité de la fonction sort().

Encore faut-il tourner le code de telle manière qu’on en profite vraiment:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
liste = [[1,2], [158,48], [1,2], [1,2], [23,45], [1,2], [23,45],[345,89,4],
         [20,13],[4,9,20],[1,2],[1,2],[4,9,0,1000],[23,45],[4,9,20],[1,2],
         [158,48],[345,89,4],[1,2],[4,9,20],[0,10],[11,2],[345,89,4],[1,2],
         [2014,2012,2011],[1,2],[23,45],[1,2],[11,2],[345,89,4],[138,48],
         [1,2], [158,48], [1,2], [1,2], [23,45], [1,2], [23,45],[345,89,4],
         [20,13],[4,9,20],[1,2],[1,2],[4,9,0,1000],[23,45],[4,9,20],[1,2],
         [158,48],[345,89,4],[1,2],[4,9,20],[0,10],[11,2],[345,89,4],[1,2],
         [2014,2012,2011],[1,2],[23,45],[1,2],[11,2],[345,89,4],[138,48],
         [1,2], [158,48], [1,2], [1,2], [23,45], [1,2], [23,45],[345,89,4],
         [20,13],[4,9,20],[1,2],[1,2],[4,9,0,1000],[23,45],[4,9,20],[1,2],
         [158,48],[345,89,4],[1,2],[4,9,20],[0,10],[11,2],[345,89,4],[1,2],
         [2014,2012,2011],[1,2],[23,45],[1,2],[11,2],[345,89,4],[138,48]]

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
from time import clock
 
def sort_dedoublonne(L):
    L.sort()
    prec = L[0]
    s = [L[0]]
    for i,x in enumerate(L):
        if x!=prec:
            s.append(x)
            prec = x
 
    return s
 
print '\nliste =\n',liste
 
te = clock()
x = sort_dedoublonne(liste)
dt = clock() - te
print '\nsort_dedoublonne(liste) =\n',x
print 'execution : ',dt,'secondes\n'
print

Code :

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

1
2
3
4
5
6
7
8
9
10
11
def sort_dedoublonne_courte(L):
    L.sort()
    s = [L.pop(0)]
    [ s.append(x) for x in L if x!=s[-1] ]
    return s
 
te = clock()
x = sort_dedoublonne_courte(liste)
dt = clock() - te
print '\nsort_dedoublonne(liste) =\n',x
print 'execution : ',dt,'secondes\n'

Code :

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

1
2
3
4
5
6
7
8
9
10
def dedoublonneCL(L):
    s = []
    [ s.append(u) for u in L if u not in s ]
    return s
 
te = clock()
x = dedoublonneCL(liste)
dt = clock() - te
print '\nsort_dedoublonne(liste) =\n',x
print 'execution : ',dt,'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
liste =
[[1, 2], [158, 48], [1, 2], [1, 2], [23, 45], [1, 2], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [1, 2], [1, 2], [4, 9, 0, 1000], [23, 45], [4, 9, 20], [1, 2], [158, 48], [345, 89, 4], [1, 2], [4, 9, 20], [0, 10], [11, 2], [345, 89, 4], [1, 2], [2014, 2012, 2011], [1, 2], [23, 45], [1, 2], [11, 2], [345, 89, 4], [138, 48], [1, 2], [158, 48], [1, 2], [1, 2], [23, 45], [1, 2], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [1, 2], [1, 2], [4, 9, 0, 1000], [23, 45], [4, 9, 20], [1, 2], [158, 48], [345, 89, 4], [1, 2], [4, 9, 20], [0, 10], [11, 2], [345, 89, 4], [1, 2], [2014, 2012, 2011], [1, 2], [23, 45], [1, 2], [11, 2], [345, 89, 4], [138, 48], [1, 2], [158, 48], [1, 2], [1, 2], [23, 45], [1, 2], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [1, 2], [1, 2], [4, 9, 0, 1000], [23, 45], [4, 9, 20], [1, 2], [158, 48], [345, 89, 4], [1, 2], [4, 9, 20], [0, 10], [11, 2], [345, 89, 4], [1, 2], [2014, 2012, 2011], [1, 2], [23, 45], [1, 2], [11, 2], [345, 89, 4], [138, 48]]
 
sort_dedoublonne(liste) =
[[0, 10], [1, 2], [4, 9, 0, 1000], [4, 9, 20], [11, 2], [20, 13], [23, 45], [138, 48], [158, 48], [345, 89, 4], [2014, 2012, 2011]]
execution :  0.000464584185979 secondes
 
 
 
sort_dedoublonne(liste) =
[[0, 10], [1, 2], [4, 9, 0, 1000], [4, 9, 20], [11, 2], [20, 13], [23, 45], [138, 48], [158, 48], [345, 89, 4], [2014, 2012, 2011]]
execution :  0.000208406375671 secondes
 
 
sort_dedoublonne(liste) =
[[0, 10], [1, 2], [4, 9, 0, 1000], [4, 9, 20], [11, 2], [20, 13], [23, 45], [138, 48], [158, 48], [345, 89, 4], [2014, 2012, 2011]]
execution :  0.000264279398639 secondes

Si l’ordre ne compte pas, ce peut être une autre corde à son arc assez valable je crois.

[wiztricks]

Ave Eyquem
En effet la forme la plus lisible et générale pour dedoublonner une liste d'objets quelconques semble être:

Code :

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

1
2
3
4
def dedoublonneCL(L):
    s = []
    [ s.append(u) for u in L if u not in s ]
    return s

Intuitivement, la recherche de l'existence de u dans un dict semble plus performante (on passe par une fonction de hash) et si on souhaite récupérer le résultat de la construction du dict, un OrderedDict le fait aussi.

Note: C'est la raison pour laquelle je pense dict avant de penser list peut être à tord.

Mais bon, il faut que les u soient "hashable" et côté performance, la dérive n'est pas extraordinaire pour les "petites" listes (L).

Si on essaie (par jeu) d'écrire cela en une seule ligne, je n'ai rien trouvé de mieux que la chose:

Code :

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

dedoublonne = lambda L, s=[]: [ s for u in L if u not in s and (not s.append(u)) or 0 ][0]

qui est assez redoutable... j'en conviens. Pire lorsqu'on ne décompose pas les choses avec mauvais générateur et TF qui ne sert à rien.
Bon courage
- W

[Zavonen]

Expliquez moi pourquoi, juste pour utiliser une 'comprehension list' on construit un objet:
[[s[0]],[[s[0],s[1]], ......,] alors qu'on a besoin du dernier élément seulement de cette liste?
Une itération toute bête est, certes, moins 'f'ashion' mais beaucoup moins encombrante.
Autrement dit je plébiscite dedoublonneCL2 au dépend de dedoublonneCL1

Code python :

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
liste =[[1, 2], [158, 48], [1, 2], [1, 2], [23, 45], [1, 2], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [1, 2], [1, 2], [4, 9, 0, 1000], [23, 45], [4, 9, 20], [1, 2], [158, 48], [345, 89, 4], [1, 2], [4, 9, 20], [0, 10], [11, 2], [345, 89, 4], [1, 2], [2014, 2012, 2011], [1, 2], [23, 45], [1, 2], [11, 2], [345, 89, 4], [138, 48], [1, 2], [158, 48], [1, 2], [1, 2], [23, 45], [1, 2], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [1, 2], [1, 2], [4, 9, 0, 1000], [23, 45], [4, 9, 20], [1, 2], [158, 48], [345, 89, 4], [1, 2], [4, 9, 20], [0, 10], [11, 2], [345, 89, 4], [1, 2], [2014, 2012, 2011], [1, 2], [23, 45], [1, 2], [11, 2], [345, 89, 4], [138, 48], [1, 2], [158, 48], [1, 2], [1, 2], [23, 45], [1, 2], [23, 45], [345, 89, 4], [20, 13], [4, 9, 20], [1, 2], [1, 2], [4, 9, 0, 1000], [23, 45], [4, 9, 20], [1, 2], [158, 48], [345, 89, 4], [1, 2], [4, 9, 20], [0, 10], [11, 2], [345, 89, 4], [1, 2], [2014, 2012, 2011], [1, 2], [23, 45], [1, 2], [11, 2], [345, 89, 4], [138, 48]]
 
def dedoublonneCL1(L):
    s = []
    [ s.append(u) for u in L if u not in s ]
    return s
 
def dedoublonneCL2(L):
    s = []
    for u in L:
        if u not in s:
            s.append(u)
    return s
 
print dedoublonneCL1(liste)
print dedoublonneCL2(liste)