5 méthodes pour supprimer les éléments en double des listes Python

Dans ce guide, vous allez découvrir comment éliminer les occurrences en double dans les listes Python.

Lorsque vous manipulez des listes avec Python, il est parfois nécessaire de ne travailler qu'avec les éléments uniques, en supprimant les doublons.

Plusieurs approches sont possibles. Nous allons explorer cinq de ces méthodes dans ce tutoriel.

Fondamentaux des listes Python

Commençons par récapituler les bases des listes Python.

Les listes Python sont modifiables. Vous pouvez les changer directement en ajoutant ou en retirant des éléments. De plus, les listes Python sont des regroupements d'éléments qui ne sont pas nécessairement distincts.

Alors, comment conserver uniquement les éléments uniques et retirer les doublons ou répétitions ?

Vous pouvez le faire de différentes manières. Vous pouvez soit créer une nouvelle liste qui ne contient que les éléments uniques de la liste de départ. Ou bien, vous pouvez choisir de modifier la liste d'origine en supprimant les doublons.

Nous allons étudier ces méthodes en détail dans ce tutoriel.

Techniques pour éliminer les doublons des listes Python

Prenons un exemple concret. Imaginez que vous êtes à l'anniversaire d'un ami.🎊🎉

Dans la sélection de bonbons présentée, vous remarquez que certains éléments se répètent. Vous souhaitez maintenant supprimer ces doublons de la liste de bonbons.

Établissons une liste de bonbons contenant tous les éléments de l'image ci-dessus.

sweets = ["cupcake","candy","lollipop","cake","lollipop","cheesecake","candy","cupcake"]

Dans la liste de bonbons ci-dessus, les éléments "bonbon" et "cupcake" apparaissent deux fois. Utilisons cette liste comme exemple pour éliminer les doublons.

Parcourir les listes Python pour supprimer les doublons

La méthode la plus simple consiste à créer une nouvelle liste qui ne contient chaque élément qu'une seule fois.

Examinez le bloc de code ci-dessous :

unique_sweets = []
for sweet in sweets:
  if sweet not in unique_sweets:
    unique_sweets.append(sweet)

print(unique_sweets)

# Résultat
['cupcake', 'candy', 'lollipop', 'cake', 'cheesecake']

Nous commençons par une liste vide appelée unique_sweets.
En parcourant la liste de bonbons, nous accédons à chaque bonbon.
Si un bonbon n'est pas déjà dans la liste unique_sweets, nous l'ajoutons à la fin de cette liste avec la méthode .append().

Supposons que nous rencontrions un élément qui se répète, comme par exemple la deuxième occurrence de "bonbon" dans la liste des bonbons. Celui-ci n'est pas ajouté à la liste unique_sweets car il y est déjà présent. La condition `sweet not in unique_sweets` est évaluée à Faux pour la deuxième occurrence de `cupcake` et de `candy`.

Par conséquent, avec cette méthode, chaque élément ne figure qu'une seule fois dans la liste unique_sweets, sans répétition.

Utiliser la compréhension de liste pour supprimer les doublons

Vous pouvez aussi utiliser la compréhension de liste pour remplir la liste unique_sweets.

Besoin de revoir les bases de la compréhension de liste ?

▶️ Consultez le tutoriel sur la compréhension des listes en Python.

Utilisons l'expression de compréhension de liste : `[sortie for élément in itérable if condition est Vraie]` pour réécrire la boucle précédente de manière plus concise.

unique_sweets = []
[unique_sweets.append(sweet) for sweet in sweets if sweet not in unique_sweets]
print(unique_sweets)

# Résultat
['cupcake', 'candy', 'lollipop', 'cake', 'cheesecake']

Même si vous créez une nouvelle liste, vous ne la remplissez pas avec des valeurs. Cela est dû au fait que la sortie est l'opération `.append()` sur la liste unique_sweets.

Pour supprimer les doublons des listes Python, vous pouvez également utiliser des méthodes de liste intégrées, ce que nous allons aborder dans la section suivante.

Utiliser les méthodes de liste intégrées pour supprimer les doublons

Vous pouvez utiliser les méthodes de liste Python `.count()` et `.remove()` pour supprimer les doublons.

– Avec la syntaxe `list.count(valeur)`, la méthode `.count()` renvoie le nombre de fois que la `valeur` apparaît dans la `liste`. Ainsi, le nombre correspondant aux éléments qui se répètent sera supérieur à 1.

– `list.remove(valeur)` supprime la première occurrence de la `valeur` dans la liste.

En utilisant ce qui précède, nous obtenons le code suivant.

for sweet in sweets:
  # vérifier si le nombre d'occurrences de sweet est > 1 (élément qui se répète)
  if sweets.count(sweet) > 1:
  # si Vrai, supprimer la première occurrence de sweet
    sweets.remove(sweet)

print(sweets)

# Résultat
['cake', 'lollipop', 'cheesecake', 'candy', 'cupcake']

Étant donné que la méthode `.remove()` ne supprime que la première occurrence d'une valeur, vous ne pouvez pas l'utiliser pour éliminer les éléments qui apparaissent plus de deux fois.

Si un élément est dupliqué (apparaît exactement deux fois), cette méthode supprime la première occurrence.
Si un élément est répété K fois, après l'exécution du code ci-dessus, il restera K-1 répétitions.

Mais en général, lorsque l'on parle de doublons, on fait référence à toutes les répétitions.

Pour gérer ce cas, vous pouvez modifier la boucle précédente afin de supprimer toutes les répétitions sauf une. Au lieu d'utiliser une condition `if` pour vérifier le nombre d'un élément particulier, vous pouvez utiliser une boucle `while` pour supprimer plusieurs fois les doublons jusqu'à ce que le nombre de chaque élément de la liste soit égal à 1.

La liste de bonbons contient désormais 2 répétitions de "cupcake" et 3 répétitions de "candy".

sweets = ["cupcake","candy","lollipop","cake","lollipop","candy","cheesecake","candy","cupcake"]

Vous pouvez utiliser une boucle `while` pour supprimer les répétitions, comme ci-dessous. La boucle `while` continue de s'exécuter tant que le nombre de bonbons dans la liste est supérieur à 1. Lorsqu'il ne reste qu'une seule occurrence, la condition `sweets.count(sweet) > 1` devient Fausse et la boucle passe à l'élément suivant.

for sweet in sweets:
  # vérifier si le nombre de sweet est > 1 (élément qui se répète)
  while(sweets.count(sweet) > 1):
  # supprimer plusieurs fois la première occurrence de sweet jusqu'à ce qu'il n'en reste qu'une.
    sweets.remove(sweet)

print(sweets)
# Résultat
['cake', 'lollipop', 'cheesecake', 'candy', 'cupcake']

Mais l'utilisation de boucles imbriquées peut ne pas être très efficace. Vous pouvez donc envisager d'utiliser l'une des autres méthodes décrites si vous travaillez avec de grandes listes.

Jusqu'à présent, nous avons appris les points suivants :

Méthodes pour supprimer les doublons des listes Python en créant de nouvelles listes contenant uniquement les éléments uniques
Méthodes de liste intégrées `.count()` et `.remove()` pour modifier la liste directement

Certaines structures de données intégrées à Python exigent que les valeurs soient toutes uniques, sans répétition. Nous pouvons donc convertir une liste Python en l'une de ces structures de données pour supprimer les doublons. Puis, nous pouvons reconvertir cette structure en une liste. Nous allons découvrir comment faire dans les sections suivantes.

Convertir la liste Python en un ensemble pour supprimer les doublons

Les ensembles Python sont des regroupements d'éléments tous uniques. Par conséquent, le nombre d'éléments présents dans l'ensemble (donné par `len()`) est égal au nombre d'éléments uniques.

Vous pouvez convertir n'importe quel itérable Python en un ensemble en utilisant la syntaxe : `set(itérable)`.

À présent, mettons la liste des bonbons dans un ensemble et examinons le résultat.

set(sweets)
# Résultat
{'cake', 'candy', 'cheesecake', 'cupcake', 'lollipop'}

D'après le résultat du bloc de code ci-dessus, on constate que chaque élément n'apparaît qu'une seule fois et que les doublons ont été éliminés.

Notez aussi que l'ordre des éléments n'est pas forcément le même que dans la liste de bonbons originale. En effet, en plus d'être un regroupement d'éléments uniques, un objet ensemble Python est une collection non ordonnée.

Maintenant que nous avons supprimé les doublons en transformant la liste en un ensemble, nous pouvons la reconvertir en une liste, comme indiqué ci-dessous.

unique_sweets = list(set(sweets))
print(unique_sweets)

# Résultat
['cake', 'cheesecake', 'candy', 'cupcake', 'lollipop']

Utiliser les éléments de la liste comme clés de dictionnaire pour supprimer les doublons

Le dictionnaire Python est un ensemble de paires clé-valeur où les clés identifient de manière unique les valeurs.

Vous pouvez créer un dictionnaire Python en utilisant la méthode `.fromkeys()` avec la syntaxe : `dict.fromkeys(clés, valeurs)`. Ici, les clés et les valeurs sont des itérables contenant respectivement les clés et les valeurs du dictionnaire.

`clés` est un paramètre obligatoire, qui peut être n'importe quel itérable Python correspondant aux clés du dictionnaire.
`valeurs` est un paramètre optionnel. Si vous ne spécifiez pas les valeurs itérables, la valeur par défaut `None` est utilisée.

Sans spécifier les valeurs, `dict.fromkeys(sweets)` renvoie un dictionnaire Python où les valeurs sont définies sur `None`, la valeur par défaut. Le bloc de code ci-dessous illustre cela.

dict.fromkeys(sweets)

# Résultat
{'cake': None,
 'candy': None,
 'cheesecake': None,
 'cupcake': None,
 'lollipop': None}

Comme dans la section précédente, nous pouvons reconvertir le dictionnaire en une liste, comme indiqué ci-dessous.

unique_sweets = list(dict.fromkeys(sweets))
print(unique_sweets)
# Résultat
['cupcake', 'candy', 'lollipop', 'cake', 'cheesecake']

D'après le résultat ci-dessus, on constate que les doublons ont bien été supprimés de la liste de bonbons.

Résumé👩‍🏫

Voici un récapitulatif des différentes méthodes que vous pouvez utiliser pour supprimer les doublons ou les répétitions des listes Python.

Utilisez la méthode de liste Python `.append()` pour ajouter les éléments non répétitifs à une nouvelle liste. La nouvelle liste contient chaque élément de la liste de départ une seule fois, en éliminant toutes les répétitions. Vous pouvez aussi le faire en utilisant la compréhension de liste.
Utilisez les méthodes intégrées `.count()` et `.remove()` pour supprimer les éléments qui apparaissent exactement deux fois. La même chose peut être placée dans une boucle `while` pour supprimer toutes les occurrences supplémentaires.
Transformez une liste Python en un ensemble pour ne conserver que les éléments uniques.
Utilisez `dict.fromkeys(list)` pour supprimer tous les doublons de la liste, car il ne doit pas y avoir de clés dupliquées dans le dictionnaire.

Ensuite, consultez les projets Python pour vous entraîner et apprendre. Ou découvrez comment trouver l'index d'un élément dans les listes Python. Bon apprentissage !