supprimer des doublons d'une liste

@ phili_b
Ta solution calcule le nombre d'occurrences de chaque élément de la liste par un appel à 'count'. Or nous n'avons rien à faire de ce nombre, nous voulons seulement savoir si un élément possède une autre occurrence.
Donc, dans le genre (dédoublonnage 'en place'), je préfère:

Code:

---

1 2 3 4 5 6 7 8 9 10

L = ['a','b','c','b','d','a','e'] n=len(L) i=0 while i <=n-2: if L[i] in L[i+1:]: L.remove(L[i]) n-=1 else: i+=1 print L

---

@eyquem:
Faudra bien que je lise ton post, mais pas ce soir (trop fatigué).

Citation:

---

Ah oui, groupby() m’a fait beaucoup phosphorer, à un moment.

D’ailleurs je vois qu’il manque quelque chose dans ce code:
quand on dit que l’ordre ne compte pas, c’est pour justifier l’emploi de sort()


Il faut

Code :

from itertools import groupby

def dedoublonne(l):
l.sort()
return [x[0] for x in groupby(l)]

---

Après un appel à 'sort' l'utilisation de groupby est redondante et coûteuse.
Faire plutôt, en utilisant une version simplifiée de mon exemple précédent:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

L = ['a','b','c','b','d','a','e'] L.sort() n=len(L) i=0 while i <=n-2: if L[i] == L[i+1]: L.remove(L[i]) n-=1 else: i+=1 print L

---

qui garantit une efficacité en nlog(n)

Citation:

---

Envoyé par Zavonen

Après un appel à 'sort' l'utilisation de groupby est redondante et coûteuse.

---

Coûteuse, je ne sais pas.

Redondante, sûrement pas :

Code:

---

1 2 3 4 5 6

>>> from itertools import groupby >>> [k for k, g in groupby('AAAABBBCCDAABBB')] ['A', 'B', 'C', 'D', 'A', 'B'] >>> [k for k, g in groupby(sorted('AAAABBBCCDAABBB'))] ['A', 'B', 'C', 'D']

---

Ok, j'ai utilisé sorted et pas sort, mais bon, c'était juste pour gagner 1 ligne. :P

Edit : je me rends compte que j'ai écrit que l'utilisation de sort n'est pas redondante avant un appel à groupby alors que, Zavonen, tu estimes que l'appel à groupby après l'appel à sort est redondant.
J'ai le sentiment d'avoir répondu légèrement à côté, mais bon, ce qui est écrit est écrit.

Bonjour,
voici une version TEXTE de ce qu'a proposé Zavoven :

Code:

---

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

#! /usr/bin/env python3   def adHoc(text): iMax = len(text) - 1 i = 0   while i < iMax: if text[i] in text[i+1:]: text = text[i] + text.replace(text[i], '') iMax = len(text) - 1 else: i += 1   return text   tests = [ 'A', 'AA', 'AB', 'AAAABBBCCDAABBB', ]   for oneTest in tests: print( '---', oneTest, 'CHARACTERS USED ==> ' + adHoc(oneTest), sep = "\n" )

---

Sous Python 3, on obtient :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

--- A CHARACTERS USED ==> A --- AA CHARACTERS USED ==> A --- AB CHARACTERS USED ==> AB --- AAAABBBCCDAABBB CHARACTERS USED ==> CBAD

---

Au passage, dans le code Zavoven, on peut faire la nano-amélioration suivante :

Code:

---

1 2 3 4 5 6 7

... #n=len(L) n=len(L)-1 i=0 #while i <=n-2: while i < n: ...

---

Citation:

---

Envoyé par rambc

Bonjour,
voici une version TEXTE de ce qu'a proposé Zavoven :

---

8O

Je ne comprends pas pourquoi tu fais cela.

Le fichier zavonen.py

Code:

---

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

#!/usr/bin/env python #coding: utf-8   def zavonen(l): """     Supprime les doublons d'une liste.       Exemples:     >>> zavonen([1, 2, 3, 4, 2, 3, 5])     [1, 2, 3, 4, 5]     >>> ''.join(zavonen(list('AAAABBBCCDAAABB')))     'ABCD'     """ l.sort() n = len(l) i = 0 while i <= n - 2: if l[i] == l[i + 1]: l.remove(l[i]) # ou l.pop(i) n -= 1 else: i += 1 return l   if __name__ == '__main__': from doctest import testmod testmod(verbose=True)

---

A l'exécution :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

Trying: zavonen([1, 2, 3, 4, 2, 3, 5]) Expecting: [1, 2, 3, 4, 5] ok Trying: ''.join(zavonen(list('AAAABBBCCDAAABB'))) Expecting: 'ABCD' ok # du blabla dont on se fiche...

---

Tu peux éventuellement faire une fonction :

Code:

---

1 2 3

def zavonentext(texte): return ''.join(zavonen(list(text)))

---

De cette manière, tu évites la duplication du code et les futurs problèmes de maintenance inhérents.

D'ailleurs, on peut même faire mieux:

Code:

---

1 2 3 4

def zavonen(input): l = list(input) #le reste du code pareil

---

De cette manière, on est assurés de travailler sur une liste et donc de ne pas avoir de problème sur le reste de la fonction.

Pas très pythonique d'avoir une version d'une fonction par type possible d'argument.

Ma version ultime serait :

Code:

---

1 2 3 4 5 6 7

def nodoublon(input): seen = [] for x in input: if x not in seen: yield x seen.append(x)

---

Ce qui ressemble diantrement à ce qui a déjà été proposé par je-ne-sais-plus-qui (désolé).

Les points forts:
1. on se fiche totalement du type de input : liste, tuple, string, générateur sont acceptés ;
2. on retourne un générateur et on peut en faire ce qu'on veut : 1 liste (avec list(nodoublon(input))), une string (''.join(nodoublon(input)), voire ''.join(str(x) for x in nodoublon(input))), un tuple, un simple itérateur ( for x in nodoublon(input): dosomethingwith(x)) ;
3. le code est self-explanatory et je ne me prendrais pas la tête dans 3 mois à le relire (commentaires et tests sout toutefois toujours les bienvenus, avec modération).

Ne reste plus qu'à benchmarker tout cela, si la vitesse d'exécution est réellement importante (et, dans ce cas, je suppose que coder la fonction de zavonen dans un module Python écrit en C est la meilleure solution).

Edit : à noter que la principale différence est que l'algo de Zavonen fait de la modification sur-place, pas le mien (ni aucun des autres présentés si je ne m'abuse). Je me pose des questions sur les avantages d'une telle méthode (ça veut pas dire que je trouve ça bête, juste que je ne connais pas les différences entre sur-place et pas-sur-place : contrainte temps ? contrainte mémoire ? beauté du geste ? autre ?)

Citation:

---

Envoyé par nardo47

8O

Je ne comprends pas pourquoi tu fais cela.

---

Juste pour le plaisir et aussi dans un contexte où on ne travaille que sur des chaînes.