Python Supprimer les doublons d'une liste

Lors du développement de logiciels, il est fréquent de manipuler des listes qui contiennent des éléments dupliqués. Ces doublons peuvent perturber l'efficacité et la justesse des résultats. Il devient alors indispensable de supprimer ces occurrences redondantes pour obtenir une liste propre, unique et parfois ordonnée.

Python propose plusieurs stratégies pour enlever les doublons. Cet article présente un éventail de méthodes, illustrées par des exemples de code détaillés, et analyse leurs avantages, inconvénients ainsi que leur complexité temporelle.

Techniques pour supprimer les doublons d'une liste en Python

1. Transformation en ensemble

La conversion d'une liste en ensemble est une approche simple et rapide pour éliminer les doublons. Les ensembles, par leur nature, ne peuvent pas contenir d'éléments identiques.

# Liste initiale avec des doublons
ma_liste = [1, 2, 3, 4, 2, 5, 1]

# Conversion de la liste en ensemble pour supprimer les doublons
mon_ensemble = set(ma_liste)

# Reconversion de l'ensemble en liste, qui ne contient donc plus de doublons
ma_liste_unique = list(mon_ensemble)

print(ma_liste_unique) 
# Affichage : [1, 2, 3, 4, 5]

2. Utilisation de la compréhension de liste

La compréhension de liste est une syntaxe concise qui permet de générer une nouvelle liste à partir d'une liste existante. Elle est également utile pour filtrer et éliminer les doublons.

# Liste de départ avec des doublons
ma_liste = [1, 2, 3, 4, 2, 5, 1]

# Création d'une nouvelle liste avec uniquement des éléments uniques
ma_liste_unique = [x for i, x in enumerate(ma_liste) if x not in ma_liste[:i]]

print(ma_liste_unique)
# Affichage : [1, 2, 3, 4, 5]

3. Recours à la méthode dict.fromkeys()

La fonction dict.fromkeys() permet de créer un dictionnaire à partir des éléments d'une liste, en les utilisant comme clés. Comme les dictionnaires ne tolèrent pas les clés dupliquées, cela élimine automatiquement les redondances.

# Liste de départ avec des doublons
ma_liste = [1, 2, 3, 4, 2, 5, 1]

# Création d'un dictionnaire à partir de la liste
mon_dictionnaire = dict.fromkeys(ma_liste)

# Conversion du dictionnaire en liste pour obtenir les éléments uniques
ma_liste_unique = list(mon_dictionnaire)

print(ma_liste_unique)
# Affichage : [1, 2, 3, 4, 5]

4. Combinaison de fonctions lambda et de filter()

La fonction filter(), combinée avec une fonction lambda, permet de filtrer les éléments d'une liste en se basant sur une condition, ici la présence de doublons.

# Liste d'origine avec des doublons
ma_liste = [1, 2, 3, 4, 2, 5, 1]

# Initialisation d'une liste pour stocker les éléments uniques
ma_liste_unique = []

# Filtrage de la liste pour enlever les doublons
ma_liste_unique = list(filter(lambda x: not (x in ma_liste_unique) and ma_liste_unique.append(x), ma_liste))

print(ma_liste_unique)
# Affichage : [1, 2, 3, 4, 5]

5. Utilisation de bibliothèques tierces

Plusieurs bibliothèques externes, comme collections.Counter et pandas, proposent des outils pratiques pour retirer les doublons d'une liste.

# Utilisation de collections.Counter
from collections import Counter

# Liste de départ avec doublons
ma_liste = [1, 2, 3, 4, 2, 5, 1]

# Création d'un compteur à partir de la liste
mon_compteur = Counter(ma_liste)

# Obtention des éléments uniques (clés du compteur)
ma_liste_unique = list(mon_compteur.keys())

print(ma_liste_unique)
# Affichage : [1, 2, 3, 4, 5]

Complexité temporelle des méthodes

La complexité temporelle des différentes méthodes varie selon la taille de la liste et l'algorithme utilisé :

Conclusion

L'élimination des doublons est une tâche courante en programmation Python. Nous avons exploré plusieurs méthodes, chacune avec ses forces et faiblesses.

Pour les grandes listes, la méthode de la conversion en ensemble est la plus performante. Pour les petites listes, la compréhension de liste ou l'emploi de dict.fromkeys() peuvent convenir. Le choix final dépend des spécificités du contexte.

Foire aux questions (FAQ)

1. Quelle distinction y a-t-il entre une liste et un ensemble en Python ?

Une liste est une structure de données ordonnée pouvant contenir des doublons, contrairement à un ensemble qui est non ordonné et ne permet pas les redondances.

2. Pourquoi est-il parfois nécessaire de supprimer les doublons dans une liste ?

L'élimination des doublons assure la création d'une liste unique et ordonnée, améliorant ainsi l'efficacité et la précision des opérations sur la liste.

3. Existe-t-il une méthode intégrée pour supprimer les doublons d'une liste en Python ?

Non, Python ne possède pas de méthode unique intégrée pour cette action. Cependant, plusieurs approches permettent d'atteindre ce but.

4. Quelle méthode parmi celles présentées est la plus performante ?

La transformation en ensemble est la méthode la plus efficace pour de grandes listes, grâce à sa complexité temporelle de O(n).

5. Quelle méthode est la mieux adaptée pour les petites listes ?

Pour les petites listes, la compréhension de liste ou l'usage de dict.fromkeys() sont souvent plus appropriés, leur complexité temporelle étant également de O(n).

6. Existe-t-il des bibliothèques tierces qui peuvent simplifier la suppression de doublons ?

Oui, des bibliothèques comme collections.Counter et pandas offrent des solutions pratiques.

7. Quelle méthode est la plus rapide pour une liste de 10 000 éléments ?

La conversion en ensemble reste la plus rapide pour les grandes listes. Pour 10 000 éléments, elle devrait prendre environ 0,001 seconde.

8. Comment supprimer les doublons tout en conservant l'ordre originel des éléments ?

Vous pouvez utiliser OrderedDict du module collections pour maintenir l'ordre d'insertion. Les éléments seront uniques et apparaîtront dans l'ordre de la liste originale.

from collections import OrderedDict

# Liste de départ avec doublons
ma_liste = [1, 2, 3, 4, 2, 5, 1]

# Création d'un OrderedDict à partir de la liste
ordered_dict = OrderedDict.fromkeys(ma_liste)

# Conversion de l'OrderedDict en liste, conservant l'ordre
ma_liste_unique_ordonnée = list(ordered_dict.keys())

print(ma_liste_unique_ordonnée)
# Affichage : [1, 2, 3, 4, 5]