Supprimer les doublons en Python : guide complet

Les valeurs dupliquées dans une liste Python sont fréquentes lors de la collecte de données saisies par l'utilisateur, de la fusion de jeux de données ou de la lecture de fichiers. Ce guide présente cinq techniques pratiques pour supprimer les doublons — chacune offrant un compromis différent entre vitesse, préservation de l'ordre et lisibilité.

Utiliser set() pour supprimer les doublons

Convertir une liste en set est la méthode la plus rapide et la plus concise pour dédupliquer. Un set ne stocke que des valeurs uniques et hachables, de sorte que les doublons sont automatiquement écartés.

Résultat (l'ordre peut varier) :

[1, 2, 3, 4, 5]

Quand l'utiliser : l'ordre n'a pas d'importance et la liste ne contient que des éléments hachables (nombres, chaînes, tuples).

Attention : les sets ne sont pas ordonnés. Même si les sets de petits entiers s'affichent souvent dans l'ordre trié, vous ne pouvez pas vous y fier. Si l'ordre est important, utilisez l'une des méthodes ci-dessous.

Utiliser dict.fromkeys() pour préserver l'ordre

dict.fromkeys() crée un dictionnaire dont les clés sont les éléments de la liste. Comme les clés d'un dictionnaire sont uniques et, depuis Python 3.7, ordonnées par ordre d'insertion, cette méthode supprime les doublons tout en conservant l'ordre d'origine.

Résultat :

[1, 2, 3, 4, 5]

C'est la formule idiomatique en une ligne pour la déduplication avec préservation de l'ordre en Python moderne (3.7+). Elle est également légèrement plus rapide qu'une boucle explicite, car les opérations sur le dictionnaire sont effectuées en C.

Utiliser une boucle for avec un ensemble seen

Lorsque vous souhaitez un contrôle total — par exemple pour journaliser les doublons ignorés ou appliquer une logique d'égalité personnalisée — une boucle explicite est l'approche la plus claire.

def remove_duplicates(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(remove_duplicates(my_list))

Résultat :

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

Cette méthode préserve l'ordre d'insertion et s'exécute en O(n) — la vérification in sur un set est O(1). Comparez cela avec if item not in result, qui est O(n) par élément et rend la fonction entière O(n²).

Utiliser la compréhension de liste

Vous pouvez écrire le même motif avec un ensemble seen en une seule ligne grâce à une compréhension de liste. L'astuce est que set.add() retourne toujours None (falsy), donc not (x in seen or seen.add(x)) est True uniquement la première fois que chaque valeur apparaît.

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
seen = set()
unique = [x for x in my_list if not (x in seen or seen.add(x))]
print(unique)

Résultat :

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

Cette écriture est compacte mais repose sur un effet de bord à l'intérieur de la compréhension, ce qui peut surprendre les lecteurs. La boucle for explicite ci-dessus est souvent préférable dans le code d'équipe.

Utiliser Counter pour identifier les valeurs dupliquées

Il est parfois nécessaire de savoir quelles valeurs apparaissent plus d'une fois plutôt que de simplement les supprimer. collections.Counter compte les occurrences et facilite cette tâche.

from collections import Counter

my_list = [1, 2, 2, 3, 4, 4, 5, 5, 5]
counts = Counter(my_list)
print(counts)

duplicates = [item for item, count in counts.items() if count > 1]
print("Duplicated values:", duplicates)

Résultat :

Counter({5: 3, 2: 2, 4: 2, 1: 1, 3: 1})
Duplicated values: [2, 4, 5]

Pour obtenir une liste dédupliquée à partir d'un Counter, utilisez list(counts.keys()) — les clés préservent l'ordre d'insertion en Python 3.7+.

Supprimer les doublons d'un DataFrame avec Pandas

Si vous travaillez avec des données tabulaires, la bibliothèque Pandas fournit DataFrame.drop_duplicates(). Elle offre un contrôle précis grâce à ses paramètres.

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob'],
    'score': [90, 85, 90, 78, 85],
}
df = pd.DataFrame(data)
df_unique = df.drop_duplicates()
print(df_unique)

Résultat :

      name  score
0    Alice     90
1      Bob     85
3  Charlie     78

Paramètres clés :

• subset — un nom de colonne ou une liste de noms de colonnes à prendre en compte. Les doublons ne sont détectés que dans ces colonnes.
• keep — 'first' (par défaut) conserve la première occurrence ; 'last' conserve la dernière ; False supprime toutes les lignes ayant des doublons.
• inplace=True — modifie le DataFrame en place plutôt que de retourner un nouveau DataFrame.

# Keep only the last occurrence of each name
df_last = df.drop_duplicates(subset='name', keep='last')
print(df_last)

Résultat :

      name  score
2    Alice     90
3  Charlie     78
4      Bob     85

Choisir la bonne méthode

• Le plus rapide, l'ordre n'a pas d'importance — set().
• L'ordre est important, en une ligne — dict.fromkeys().
• Logique personnalisée ou journalisation — boucle for explicite avec un ensemble seen.
• Données tabulaires — pandas.DataFrame.drop_duplicates().
• Besoin d'inspecter quelles valeurs sont dupliquées — collections.Counter.

Pour en savoir plus sur les listes, consultez le chapitre Python Lists et la référence complète des méthodes de liste. Pour en apprendre davantage sur les sets et leurs opérations, voir Python Sets et Set Methods.