Discussion :

[PauseKawa]

Bonjour,

Que pensez vous de ce code ?

Code :

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

1
2
3
4
5
l = [1,5,4,1,23,1,2,1]
try:
    while True: l.remove(1)
except: pass
print l  ## [5,4,23,2]

Je dois avouer que le

Code :

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

1
2
3
4
try:
    while True:
except:
    pass

me gene...
A la limite un except ValueError pour être explicite, mais même... J'ai du mal.

Pourquoi pas un

Code :

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

1
2
while 1 in l:
    l.remove(1)

?

Je passe sur un

Code :

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

1
2
3
for v in l:
    if v == 1:
        l.remove(1)

Qui fonctionnerais ici puisque l'on a passer l'index lors du remove mais qui serais un mauvais exemple pour le lecteur.

Votre avis ?

[mont29]

«*Liste en intension*»… sic.

Bref, non, le dernier code ne fonctionne pas. Essaye*:

Code :

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

1
2
3
4
5
6
l = [1, 1, 1, 2, 3, 4, 1, 1, 5, 2, 3]
for v in l:
    if v == 1:
        l.remove(1)
 
print(l)

On retrouve l’éternel problème de modifier une liste (ou autre) en cours d’itération, 99% du temps ça foire.

Code :

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

1
2
while 1 in l:
    l.remove(1)

… est certes plus esthétique, mais il présente l’inconvénient d’impliquer deux itérations pour chaque élément 1 (in n’a d’autre choix que de parcourir la liste, lui aussi…).

En fait, je ne comprends même pas le besoin de donner la première solution à base d’exception, fonctionnelle mais hideuse et peut performante, alors que celle qui est amha de loin la meilleure est donnée ensuite –*utiliser une comprehension avec test (un seul parcours de la liste pour toute l’opération)*!

On peut même éviter la création d’une nouvelle liste, en py3:

Code :

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

l[:] = (i for i in l if i != 1)

PS*: Dans la FAQ, quand il utilise set(), il oublie aussi de préciser que l’ordre est perdu, set() étant non-ordonné…

[fred1599]

Que pensez vous de ce code ?

Que c'est très moche, mais FAQ ou tutoriel, il y a toujours des points discutables. C'est un avis personnel, mais en effet, il y a d'autres façons plus pythonique de faire cela.

Code :

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

1
2
3
>>> l = [1,5,4,1,23,1,2,1]
>>> [i for i in l if i != 1]
[5, 4, 23, 2]

Ce qu'il fait d'ailleurs par la suite.

À la rigueur la première solution ne devrait pas être présente, car celui qui ne lit pas la suite pourrait le prendre comme une bonne manière de faire.

A la limite un except ValueError pour être explicite, mais même... J'ai du mal.

Et comme il le dit lui même c'est lent.

[PauseKawa]

C'est bien la solution basée sur try/except:pass que je souligne.

Bref, non, le dernier code ne fonctionne pas.

Exact, de toute manière c'est a oublier et ce n'était valable que pour la liste donnée.

On peut même éviter la création d’une nouvelle liste, en py3

L[:] fonctionne bien avant Python 3.x

[dividee]

À la rigueur la première solution ne devrait pas être présente, car celui qui ne lit pas la suite pourrait le prendre comme une bonne manière de faire.

Le problème est que la question est "Comment supprimer une occurence dans une liste ?". Dans ce contexte, il faut tout de même parler de remove.

Ne serait-ce pas mieux de donner d'abord un exemple plus simple ou on ne supprime, effectivement, qu'une seule occurrence ?

PS : Dans la FAQ, quand il utilise set(), il oublie aussi de préciser que l’ordre est perdu, set() étant non-ordonné…

Oui cela devrait être précisé...
Pour conserver l'ordre (de première occurrence) on peut faire comme ceci:

Code :

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

1
2
3
l = [1,5,4,1,23,1,2,1]
l = sorted(set(l), key=l.index)
print l ## [1,5,4,23,2]

[PauseKawa]

Cela complique: Le but de la FAQ c'est de répondre simplement à des questions fréquentes.

Dans le sens "Comment supprimer une occurrence dans une liste ?":
Il est bien de signaler que .remove(), du fait du parcours de la liste du début pour supprimer la première occurrence*, est long. *A signaler aussi
Il serait bien de parler de la suppression par index (pop) et valeur.

C'est plus pour le try/except: pass que je réagit.
Combien avez vous vus de code while True/try/exept: pass/while.... ou le PO ne s'en sortait plus ? La FAQ se doit d’être propre il me semble.

[mont29]

l[:] fonctionne bien avant Python 3.x

Bien sûr. Mais faire*:

Code :

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

l[:] = [i for i in l if i != 1]

… Implique la création temporaire d’une liste (du coup, autant simplement l’assigner à l en remplacement de l’ancienne, comme dans la FAQ), alors que*:

Code :

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

l[:] = (i for i in l if i != 1)

… Crée seulement un iterator, donc économie de mémoire (ce qui peut avoir son importance si la liste à “nettoyer” est très longue…), et très probablement de meilleures performances (puisqu’on ne construit pas d’abord une nouvelle liste avant d’en copier les éléments dans l’ancienne).

C'est plus pour le try/except: pass que je réagit.
Combien avez vous vus de code while True/try/exept: pass/while.... ou le PO ne s'en sortait plus ? La FAQ se doit d’être propre il me semble.

Entièrement d’accord, amha ce bout de code n’a rien à faire là, il s’agit en fait presque d’un contre-exemple, de quoi brouiller les pistes plus qu’autre chose, pour un débutant…

[PauseKawa]

Bien sûr. Mais faire*:

Code :

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

l[:] = [i for i in l if i != 1]

… Implique la création temporaire d’une liste (du coup, autant simplement l’assigner à l en remplacement de l’ancienne, comme dans la FAQ), alors que*:

Code :

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

l[:] = (i for i in l if i != 1)

… Crée seulement un iterator, donc économie de mémoire (ce qui peut avoir son importance si la liste à “nettoyer” est très longue…), et très probablement de meilleures performances (puisqu’on ne construit pas d’abord une nouvelle liste avant d’en copier les éléments dans l’ancienne)

Je pensais juste à yield

Code :

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

1
2
3
4
5
6
7
8
9
>>> l = [1, 5, 4, 1, 23, 1, 2, 1]
>>> def removeall(l, cond):
...     for e in l:
...         if e != cond:
...             yield e
... 
>>> l[:] = removeall(l, 1)
>>> l
[5, 4, 23, 2]

Mais bon: Cela implique de connaître les fonctions et yield. Ce n'est pas le sujet (les listes).
N'y le sujet de ce post qui en soit n'est pas la pour critiquer la FAQ mais pour avoir une FAQ propre.

[wiztricks]

Salut

Au départ, nous avons une rubrique de la FAQ intitulée "Comment supprimer une occurrence dans une liste ?" qui propose 3 "recettes":
- suppression de l'objet par une itération d'appels à .remove
- nouvelle liste sans l'objet "supprimé"
- nouvelle liste à partir d'un set construit sur la liste initiale
La forme sous laquelle sont proposées ces recettes "illustrent" des opérations qui devraient se passer en mode console mais qui sont présentées sous la forme de bouts de scripts.

Illustration. En écrivant:

Code :

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

1
2
3
4
5
l = [1,5,4,1,23,1,2,1]
try:
    while True: l.remove(1)
except: pass
print l  ## [5,4,23,2]

nous avons une sorte de bout de script.

En l'écrivant:

Code :

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

1
2
3
4
5
6
7
>>> l = [1,5,4,1,23,1,2,1]
>>> try:
...     while True: l.remove(1)
... except: pass
...
>>> l
[5, 4, 23, 2]

Nous montrons les mêmes ingrédients de la "recette".
Mais nous indiquons au lecteur qu'il devra adapter ces ingrédients à son contexte.
En présentant cela sous la forme d'un truc montré "à la va vite", nous évitons (partiellement) le soucis côté "bonne pratique à montrer" présenté par PauseKawa i.e. toujours expliciter l'exception "acceptable".
Quoi qu'on pense de l'exemple, il ne coûte rien d'écrire:

Code :

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

1
2
3
4
5
6
7
>>> l = [1,5,4,1,23,1,2,1]
>>> try:
...     while True: l.remove(1)
... except ValueError: pass
...
>>> l
[5, 4, 23, 2]

Les autres sujets résultent de "ajoutons du contexte"...
Comme celui ci est rarement explicite, les "solutions" sont source de discussions, normal!

Définissons, par exemple, le QUOI par une méthode applicable à l'objet "list" genre remove_any(list, object).
Un des COMMENT pourrait être:

Code :

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

1
2
def remove_any(lst, obj):
    lst[:] = [ x for x in lst if x is not obj ]

Il y a dans la FAQ et cette discussion des exemples "semblables" mais pleins de différences subtiles dues à un contexte "non défini" ou trop ouvert. i.e. en quoi ce code là est-il différent des codes:

Code :

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

1
2
3
lst = [ x for x in lst if x != obj ]
lst = ( x for x in lst if x != obj )
lst[:] = [ x for x in lst if x != obj ]

- W

[PauseKawa]

Bonjour wiztricks,

Je suis bien conscient de la difficulté (et la dérive de ce post pour apporter des solutions le montre) a proposer un code pour la FAQ.

Quel intérêt d'écrire

Code :

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

1
2
3
try:
    while True: l.remove(1)
except: pass

Plutôt que

Code :

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

1
2
while 1 in l:
    l.remove(1)

Si ce n'est rajouter un cache misère ?

[wiztricks]

Salut PauseKawa,

Si on veut démasquer la misère, la construction:

Code :

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

1
2
3
try:
    while True: l.remove(1)
except ValueError: pass

me semble préférable.

La forme:

Code :

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

1
2
while 1 in l:
    l.remove(1)

est intéressante parce qu'en lisant le code, on "comprend" mieux ce qu'il fait.
i.e. nous avons le QUOI: "supprimer les 1 de la liste" proche du COMMENT qui dit "tant qu'il y a des 1 dans la liste, supprimer 1 de la liste".

Un des avantages de Python est de permettre un passage "simple" du QUOI au COMMENT qui peut être rassurant pour le débutant. Ce pourrait être un des premiers exemples de la FAQ sur le sujet. Les autres étant là pour "ouvrir des portes" sur d'autres méthodes.

Ceci dit, en programmation, passer du QUOI au COMMENT se fait toujours par des abstractions intermédiaires qui passent par la définition et la construction d'objets de type "class" et "function" qui vont "masquer" le COMMENT.

Ce qui fait sortir le sujet d'une simple FAQ qui se borne aux usage "simples" pour aller vers quelque chose qui serait plus "tutorial".
- W

[PauseKawa]

Bonjour,

est intéressante parce qu'en lisant le code, on "comprend" mieux ce qu'il fait.
i.e. nous avons le QUOI: "supprimer les 1 de la liste" proche du COMMENT qui dit "tant qu'il y a des 1 dans la liste, supprimer 1 de la liste".

Et c'est ce qui est demandé à la FAQ, non ?

La partie abordée ici c'est les listes, quelque chose de basique donc, et je ne pense pas que le lecteur auras des notions sur la gestion des erreurs.
Utiliser try pour se passer d'une comparaison supplémentaire ? Peut être mais pas sans être explicite sur l'erreur attendue.
L'exemple qui me viens sur les dangers de présenter ce genre de code à un débutant s'impose à moi par rapport à une erreur récurrente chez les débutants: La porté des variables.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> l = [1, 2, 3]
>>> def Foo():
...     a = 1
... 
>>> try:
...     while True:
...         l.remove(a)
... except:
...     pass
... 
>>> l
[1, 2, 3]

C'est basique ? C'est bien cela : Nous sommes bien au niveau des basiques.
Donc except: pass est a oublier à ce niveau de la FAQ.

'démasquer la misère' ? Nous entrons là dans des considérations qui ne devraient pas êtres à ce niveau de la FAQ, ne pensez vous pas ?
Et pas question d'inclure un tuto sur les erreurs en plein milieu de la FAQ sur les listes.

L'exemple

Code :

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

1
2
while 1 in l:
    l.remove(1)

Bien qu'ajoutant un test est bien plus clair.
Le but ici n'étant pas d'utiliser .remove(x) pour enlever toutes les occurrences mais de signaler que c'est lent pour passer à quelque chose d'autre, bien plus intéressant, ce code est largement suffisant.

A la limite le titre est trompeur: pop/remove sont abordés juste au dessus et le but est de montrer comment supprimer toutes les occurrences d'une valeur. On pourrais donc ne parler que rapidement de pop/remove pour passer à la suite.

Bref : Tout ce qui me gène ici c'est le

Code :

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

1
2
3
4
5
try:
    while True:
        quelque chose
except:
    pass

Donné en pâture à nos lecteurs et qui vas finir dans les codes du forum.
Donc rajoutons le ValueError, si c'est ce qui est décidé, mais ne laissons pas ce code tel quel.

@+

[wiztricks]

Et c'est ce qui est demandé à la FAQ, non? La partie abordée ici c'est les listes, quelque chose de basique donc, et je ne pense pas que le lecteur aura des notions sur la gestion des erreurs

Si on dit que la FAQ doit permettre au lecteur de trouver des ouvertures sur d'autres sujets, on peut lui infliger des try...except (mieux construits).
N'ai je pas écrit que la forme:

Code :

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

1
2
while 1 in l:
    l.remove(1)

pouvait être proposée en "premier" exemple.

- W

[PauseKawa]

Bonsoir,

Ce n'était pas une attaque personnelle wiztricks mais mes derniers arguments avant de clôturer le sujet.
Le sujet est en effet clos car vous allez tous dans mon sens.

Bien sur nous comprenons tous la difficulté d'écrire du code pour une FAQ et que la critique est aisée mais le sujet me semblais devoir être discuté.

A voir ce que cela vas donner.

@+ et bonne semaine @ll