Comment supprimer les doublons d'une liste dans Python

Par : Anna Blake Anna Blake
Hours Le kit de préparation mis à jour

⚡ Résumé intelligent

Suppression des doublons d'un Python La création de listes peut se faire avec plusieurs approches intégrées, notamment set(), dict.fromkeys(), les boucles, les compréhensions de listes et les méthodes de bibliothèque de NumPy et Pandas, chacune équilibrant la préservation de l'ordre et la vitesse.

  • (I.e. Méthode Set : La fonction set() renvoie instantanément des éléments distincts, mais ne conserve pas l'ordre original de la liste.
  • ☑️ Ordre préservé : dict.fromkeys() et OrderedDict suppriment les doublons tout en conservantping l'ordre d'insertion observé en premier.
  • ✅ Contrôle manuel: Une boucle for ou une compréhension de liste avec vérification d'appartenance permet de conserver l'ordre et la lisibilité.
  • 🧪 Méthodes de bibliothèque : Les fonctions `unique()` de NumPy et `unique()` de Pandas dédupliquent les données et renvoient une liste de résultats via la méthode `tolist()`.
  • ️ Limite de hachage : Les clés des ensembles et des dictionnaires nécessitent des éléments hachables, les listes ou les dictionnaires nécessitent donc une approche basée sur une boucle.
  • 🤖 Flux de travail d'IA : Les pipelines d'apprentissage automatique dédupliquent les données d'entraînement avec la fonction drop_duplicates() de Pandas afin d'éviter les biais et les fuites de données.
En savoir plus

Supprimer les doublons d'une liste dans Python

Python supprimer les doublons d'une liste

Une liste est un conteneur qui contient différents Python des objets, qui peuvent être des entiers, des mots, des valeurs, etc. C'est l'équivalent d'un tableau dans d'autres langages de programmation.

Nous allons donc examiner ici différentes manières de supprimer les doublons d'une liste donnée. Python.

Méthode 1) Supprimer les doublons de la liste à l'aide de Set

Pour supprimer les doublons d'une liste, vous pouvez utiliser la fonction intégrée `set()`. La particularité de la méthode `set()` est qu'elle renvoie des éléments distincts.

Nous avons la liste : [1,1,2,3,2,2,4,5,6,2,1]. Cette liste contient de nombreux doublons que nous devons supprimer afin de ne conserver que les éléments distincts. La liste est passée à la fonction intégrée set(). Later La liste finale est affichée à l'aide de la fonction intégrée list().

Le résultat obtenu est constitué d'éléments distincts, tous les éléments dupliqués ayant été éliminés.

Exemple

my_list = [1,1,2,3,2,2,4,5,6,2,1]
my_final_list = set(my_list)
print(list(my_final_list))

Sortie :

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

Méthode 2) Utilisation de la liste temporaire

Pour supprimer les doublons d'une liste, vous pouvez utiliser une liste temporaire vide. Pour cela, vous devrez d'abord parcourir la liste contenant les doublons et ajouter les éléments uniques à la liste temporaire. Later la liste temporaire est affectée à la liste principale.

Exemple

Voici un exemple fonctionnel utilisant une liste temporaire.

my_list = [1, 2, 3, 1, 2, 4, 5, 4 ,6, 2]
print("List Before ", my_list)
temp_list = []

for i in my_list:
    if i not in temp_list:
        temp_list.append(i)

my_list = temp_list

print("List After removing duplicates ", my_list)

Sortie :

List Before  [1, 2, 3, 1, 2, 4, 5, 4, 6, 2]
List After removing duplicates  [1, 2, 3, 4, 5, 6]

Méthode 3) Utiliser Dict

On peut supprimer les doublons d'une liste en important la classe OrderedDict depuis le module collections. Cette classe est disponible à partir de Python 2.7. OrderedDict renvoie les éléments distincts dans l'ordre d'apparition de la clé.

Utilisons une liste et la méthode fromkeys() disponible dans OrderedDict pour obtenir les éléments uniques de la liste.

Pour utiliser la méthode OrderedDict.fromkeys(), vous devez importer OrderedDict depuis collections, comme indiqué ci-dessous :

from collections import OrderedDict

Voici un exemple de suppression des doublons à l'aide de la méthode OrderedDict.fromkeys().

Exemple

from collections import OrderedDict

my_list = ['a','x','a','y','a','b','b','c']

my_final_list = OrderedDict.fromkeys(my_list)

print(list(my_final_list))

Sortie :

['a', 'x', 'y', 'b', 'c']

Dès Python À partir de la version 3.5, on peut utiliser la méthode `dict.fromkeys()` pour obtenir les éléments distincts d'une liste. Cette méthode renvoie des clés uniques et permet d'éliminer les doublons.

Voici un exemple illustrant le fonctionnement de dict.fromkeys() sur une liste pour obtenir les éléments uniques :

Exemple

my_list = ['a','x','a','y','a','b','b','c']
my_final_list = dict.fromkeys(my_list)
print(list(my_final_list))

Sortie :

['a', 'x', 'y', 'b', 'c']

ARTICLES LIÉS

Méthode 4) Utilisation de la boucle for

L'utilisation de boucle for, nous allons parcourir la liste des éléments pour supprimer les doublons.

Commencez par initialiser le tableau à une liste vide : `myFinallist = []`. Dans la boucle `for`, vérifiez si les éléments de la liste existent déjà dans le tableau `myFinallist`. Si ce n'est pas le cas, ajoutez-les au tableau `myFinallist` à l'aide de la méthode `append()`.

Ainsi, lorsqu'un élément en double est rencontré, il sera déjà présent dans le tableau myFinallist et ne sera pas inséré. Vérifions maintenant cela dans l'exemple ci-dessous :

Exemple

my_list = [1,2,2,3,1,4,5,1,2,6]
myFinallist = []
for i in my_list:
    if i not in myFinallist:
myFinallist.append(i)
print(list(myFinallist))

Sortie :

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

Méthode 5) Utiliser la compréhension de liste

Les compréhensions de listes sont Python fonctions utilisées pour créer de nouvelles séquences (telles que des listes, des dictionnaires, etc.) à l'aide de séquences déjà créées. Cela vous aide à réduire les boucles plus longues et à rendre votre code plus facile à lire et à maintenir.

Utilisons la compréhension de liste pour supprimer les doublons de la liste donnée.

Exemple

my_list = [1,2,2,3,1,4,5,1,2,6]
my_finallist = []
[my_finallist.append(n) for n in my_list if n not in my_finallist]
print(my_finallist)

Sortie :

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

Méthode 6) Utilisation de la méthode unique() de NumPy

La méthode unique() du module NumPy peut nous aider à supprimer les doublons de la liste donnée.

Pour utiliser NumPy, commencez par importer le module numpy :

Étape 1) Importer le module NumPy

import numpy as np

Étape 2) Utilisez votre liste contenant les doublons dans la méthode `unique()`. Le résultat est reconverti en liste à l'aide de la méthode `tolist()`.

myFinalList = np.unique(my_list).tolist()

Étape 3) Enfin, imprimez la liste :

print(myFinalList)

Le code final avec sortie est le suivant :

import numpy as np
my_list = [1,2,2,3,1,4,5,1,2,6]
myFinalList = np.unique(my_list).tolist()
print(myFinalList)

Sortie :

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

Méthode 7) Utilisation des méthodes Pandas

Le module Pandas a une méthode unique() qui nous donnera les éléments uniques de la liste donnée.

Pour utiliser le module Pandas :

Étape 1) Module d'importation de pandas

import pandas as pd

Étape 2) Utilisez votre liste contenant des doublons dans la méthode unique() :

myFinalList = pd.unique(my_list).tolist()

Étape 3) Imprimer la liste :

print(myFinalList)

Le code final avec sortie est le suivant :

import pandas as pd

my_list = [1,2,2,3,1,4,5,1,2,6]
myFinalList = pd.unique(my_list).tolist()
print(myFinalList)

Sortie :

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

Méthode 8) Utilisation d'enumerate() et de la compréhension de liste

Nous utilisons ici la combinaison de la compréhension de liste et de la fonction `enumerate()` pour supprimer les doublons. `enumerate()` renvoie un objet contenant un compteur pour chaque élément de la liste. Par exemple : `(0,1), (1,2), etc.`. La première valeur est l'index et la seconde, l'élément de la liste.

Chaque élément est vérifié pour voir s'il existe dans la liste, et si c'est le cas, il est supprimé de la liste.

Exemple

my_list = [1,2,2,3,1,4,5,1,2,6]
my_finallist = [i for j, i in enumerate(my_list) if i not in my_list[:j]]
print(list(my_finallist))

Sortie :

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

FAQ

Non. Un ensemble est une collection non ordonnée ; la méthode `set()` peut donc renvoyer des éléments dans un ordre différent. Pour supprimer les doublons tout en préservant l'ordre, utilisez `dict.fromkeys()` ou une boucle qui n'ajoute que les éléments non encore rencontrés.

Pour les grandes listes, `set()` est la méthode la plus rapide lorsque l'ordre n'a pas d'importance, car les vérifications d'appartenance sont en O(1). Lorsque l'ordre est important, `list(dict.fromkeys(my_list))` est presque aussi rapide et conserve l'ordre de première occurrence sur une seule ligne.

Les fonctions `set()` et `dict.fromkeys()` nécessitent des éléments hachables ; elles échouent donc avec les listes et les dictionnaires. Parcourez la liste et ajoutez les éléments manquants, ou convertissez chaque élément en tuple ou en chaîne JSON pour l'utiliser comme clé temporaire.

Utilisez list(dict.fromkeys(my_list)). Puisque Python Les dictionnaires 3.7 conservent l'ordre d'insertion, les clés restent donc dans l'ordre de leur première apparition. Pour les versions antérieures, utilisez `collections.OrderedDict.fromkeys()` pour obtenir le même résultat.

Non. Les méthodes telles que `set()`, `dict.fromkeys()`, les compréhensions et `unique()` de NumPy ou Pandas créent une nouvelle liste sans modifier la source. Réaffectez le résultat à la même variable si vous souhaitez la remplacer.

Utilisez `numpy.unique()` ou `pandas.unique()` lorsque les données sont déjà stockées dans des tableaux ou une Series, ou lors de l'analyse des données. Notez que `numpy.unique()` trie également les valeurs, tandis que `pandas.unique()` conserve l'ordre de première apparition. Appelez `tolist()` pour obtenir une liste simple.

Les pipelines d'apprentissage automatique suppriment les lignes dupliquées avant l'entraînement afin d'éviter que les échantillons répétés ne biaisent le modèle ou ne se retrouvent entre les ensembles d'entraînement et de test. La fonction `drop_duplicates()` de Pandas est couramment utilisée pour nettoyer les jeux de données tabulaires.

Oui. GitHub Copilot et les assistants IA d'agentic génèrent du code set(), dict.fromkeys() ou de déduplication Pandas à partir d'un commentaire, suggèrent l'option de préservation de l'ordre et refactorisent les boucles, même s'il est toujours conseillé de vérifier les cas limites comme les éléments non hachables.

Résumez cet article avec :