Supprimer les numéros en double d'une liste

Cela semble être un devoir mais voici une solution possible:

filtered_with_order = list(dict.fromkeys(numbers))

Cette solution ne préserve pas la commande. Si vous avez également besoin de la commande, utilisez:

import numpy as np 

numbers = [1, 1, 1, 1, 6, 5, 5, 2, 3]
filtered = list(np.unique(numbers))

print(filtered)
#[1, 2, 3, 5, 6]

Pourquoi n'utilisez-vous pas simplement un ensemble:

numbers = [1, 1, 1, 1, 6, 5, 5, 2, 3]
numbers = list(set(numbers))
print(numbers)

Pourquoi n'utilisez-vous pas fromkeys?

numbers = [1, 1, 1, 1, 6, 5, 5, 2, 3]
numbers = list(dict.fromkeys(numbers))

Résultat: [1,6,5,2,3]

Le déroulement est le suivant.

La liste est désormais [1, 1, 1, 1, 6, 5, 5, 2, 3] et l'indice est 0. Le x est 1. Le numbers.count (1) est 4 et donc le 1 à l'index 0 est supprimé.

Maintenant, la liste des nombres devient [1, 1, 1, 6, 5, 5, 2, 3] mais l'index va +1 et devient 1. Le x est 1. Le numbers.count (1) est 3 et donc le 1 et l'index 1 sont supprimés.

La liste des nombres devient alors [1, 1, 6, 5, 5, 2, 3] mais l'index sera +1 et devient 2. Le x sera 6.

etc ...

C'est pourquoi il y a deux 1.

Veuillez me corriger si je me trompe. Merci!

print(list(frozenset(numbers)))               # [1, 2, 3, 5, 6]

Avant toute chose, le premier conseil que je puisse donner est de ne jamais modifier un tableau que vous bouclez. Toutes sortes de choses farfelues se produisent. Votre code est bon (je recommande cependant de lire d'autres réponses, il existe un moyen plus simple de le faire avec un set , qui gère à peu près la duplication pour vous).

Au lieu de supprimer le nombre du tableau que vous bouclez, il suffit de cloner le tableau que vous bouclez dans la syntaxe de boucle for actuelle avec le découpage.

numbers = [1, 1, 1, 1, 6, 5, 5, 2, 3]
nubmers_a_set = {x for x in numbers }       
print(nubmers_a_set)

La réponse il y a nombres [:] , qui redonne un clone du tableau. Voici la sortie imprimée:

[1, 1, 1, 6, 5, 5, 2, 3]
[1, 1, 6, 5, 5, 2, 3]
[1, 6, 5, 5, 2, 3]
[1, 6, 5, 5, 2, 3]
[1, 6, 5, 5, 2, 3]
[1, 6, 5, 2, 3]
[1, 6, 5, 2, 3]
[1, 6, 5, 2, 3]
[1, 6, 5, 2, 3]
Final
[1, 6, 5, 2, 3]

Laisser un espace réservé ici jusqu'à ce que je trouve comment expliquer pourquoi dans votre cas particulier cela ne fonctionne pas, comme le raison étape par étape.

Une autre façon de résoudre ce problème en utilisant le beau langage qu'est Python, est de comprendre les listes et les ensembles.

Pourquoi un ensemble . Étant donné que la définition de cette structure de données est que les éléments sont uniques , même si vous essayez d'insérer plusieurs éléments identiques, ils n'apparaîtront pas comme répétés dans l'ensemble. Cool, non?

Compréhension de liste est un sucre de syntaxe pour boucler sur une ligne, habituez-vous-y avec Python, soit vous l'utiliserez beaucoup, soit vous le verrez beaucoup :)

Donc, avec la compréhension de liste, vous itérerez un itérable et renvoyer cet élément. Dans le code ci-dessous, x représente chaque nombre en nombres , x est renvoyé pour faire partie de l ' ensemble . Parce que l ' ensemble gère les doublons ... voilà, votre code est terminé.

numbers = [1, 1, 1, 1, 6, 5, 5, 2, 3]
for x in numbers[:]:
    if numbers.count(x) >= 2:
        numbers.remove(x)
    print(numbers)
print("Final")          
print(numbers)

Une méthode sophistiquée consiste à utiliser collections.Counter:

>>> from collections import Counter
>>> numbers = [1, 1, 1, 1, 6, 5, 5, 2, 3]
>>> c = Counter(numbers)
>>> list(c.keys())
[1, 6, 5, 2, 3]

Cette méthode a une complexité temporelle linéaire ( O (n) ) et utilise une bibliothèque vraiment performante.

Vous pouvez essayer:

from collections import OrderedDict
>>> items = [1, 1, 1, 1, 6, 5, 5, 2, 3]
>>> list(OrderedDict.fromkeys(items))
[1, 2, 0, 3]

ou

from  more_itertools import unique_everseen
items = [1, 1, 1, 1, 6, 5, 5, 2, 3]
list(unique_everseen(items))

plus vous pouvez trouver ici Comment supprimer les doublons d'une liste tout en préservant commande?

Je suppose que l'idée est d'écrire du code vous-même sans utiliser les fonctions de bibliothèque. Ensuite, je suggérerais toujours d'utiliser une structure de jeu supplémentaire pour stocker vos éléments précédents et ne passer qu'une seule fois sur votre tableau:

for x in a[:]:
   if x < 0: a.remove(x)

Si vous souhaitez utiliser votre code, le problème est que vous modifiez la collection dans pour chaque boucle, ce qui est un gros NON NON dans la plupart des langages de programmation. Bien que Python vous permette de le faire, le problème et la solution sont déjà décrits dans cette réponse: Comment supprimer des éléments d'une liste lors d'une itération? :

Remarque: Il y a une subtilité lorsque la séquence est modifiée par la boucle (cela ne peut se produire que pour les séquences mutables, c'est-à-dire les listes). Un compteur interne est utilisé pour garder une trace de l'élément utilisé ensuite, et il est incrémenté à chaque itération. Lorsque ce compteur a atteint la longueur de la séquence, la boucle se termine. Cela signifie que si la suite supprime l'élément actuel (ou un élément précédent) de la séquence, l'élément suivant sera ignoré (puisqu'il obtient l'index de l'élément actuel qui a déjà été traité). De même, si la suite insère un élément dans la séquence avant l'élément en cours, l'élément en cours sera traité à nouveau la prochaine fois dans la boucle. Cela peut conduire à des bugs désagréables qui peuvent être évités en faisant une copie temporaire en utilisant une tranche de la séquence entière, par exemple,

numbers = [1, 1, 1, 1, 6, 5, 5, 2, 3]
unique = set()
for x in numbers:
    if x not in unique:
        unique.add(x)
numbers = list(unique)
print(numbers)