Comment vérifier si une liste contient des doublons en Python

Introduction

Dans ce laboratoire (lab), nous allons explorer comment vérifier si une liste contient des doublons en Python. Comprendre comment identifier les doublons est crucial pour le nettoyage, l'analyse et l'optimisation des données.

Nous allons aborder deux méthodes principales : comparer la longueur de la liste originale avec celle de sa représentation sous forme d'ensemble (set), et utiliser l'objet collections.Counter. Le laboratoire commence par définir ce que sont les doublons et pourquoi il est important de les identifier, puis fournit des exemples pratiques de code Python pour démontrer chaque méthode, y compris la création d'un fichier duplicates.py et la mise en œuvre d'une fonction pour trouver les doublons dans une liste.

Définir les doublons

Dans cette étape, nous allons explorer ce que sont les doublons dans le contexte de la programmation et comment les identifier en Python. Comprendre les doublons est crucial pour le nettoyage, l'analyse et l'optimisation des données.

Qu'est-ce qu'un doublon ?

Les doublons sont simplement des valeurs répétées dans un ensemble de données ou une collection d'éléments. Par exemple, dans la liste [1, 2, 2, 3, 4, 4, 4], les nombres 2 et 4 sont des doublons car ils apparaissent plus d'une fois.

Pourquoi identifier les doublons ?

Identifier et gérer les doublons est important pour plusieurs raisons :

Précision des données : Les doublons peuvent fausser les résultats d'analyse et conduire à des conclusions erronées.
Efficacité de stockage : Stocker des doublons gaspille de l'espace et des ressources.
Performances : Traiter des doublons peut ralentir les algorithmes et les applications.

Identifier les doublons en Python

Commençons par créer un script Python pour identifier les doublons dans une liste.

Ouvrez votre éditeur VS Code.
Créez un nouveau fichier nommé duplicates.py dans votre répertoire ~/project.
```
~/project/duplicates.py
```
Ajoutez le code suivant au fichier duplicates.py :
```
def find_duplicates(data):
    seen = set()
    duplicates = []
    for item in data:
        if item in seen:
            duplicates.append(item)
        else:
            seen.add(item)
    return duplicates

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
duplicate_numbers = find_duplicates(numbers)
print("Original list:", numbers)
print("Duplicate numbers:", duplicate_numbers)
```
Explication :
- La fonction find_duplicates prend une liste data en entrée.
- Elle utilise un set appelé seen pour suivre les éléments qu'elle a rencontrés jusqu'à présent. Les ensembles (sets) sont utiles car ils ne stockent que des valeurs uniques.
- Elle parcourt la liste data. Si un élément est déjà dans le set seen, cela signifie qu'il est un doublon, il est donc ajouté à la liste duplicates. Sinon, l'élément est ajouté au set seen.
- Enfin, la fonction retourne la liste duplicates.
Exécutez le script en utilisant la commande suivante dans votre terminal :
```
python duplicates.py
```
Vous devriez voir la sortie suivante :
```
Original list: [1, 2, 2, 3, 4, 4, 4, 5]
Duplicate numbers: [2, 4, 4]
```
Cette sortie montre la liste originale et les nombres doublons trouvés dans la liste.

Comparer len() avec len(set())

Dans cette étape, nous allons explorer une méthode plus efficace pour détecter les doublons dans une liste en utilisant la fonction len() et la structure de données set(). Cette méthode exploite le fait que les ensembles (sets) ne stockent que des éléments uniques.

Comprendre len() et set()

len() : Cette fonction retourne le nombre d'éléments dans une liste ou tout autre objet itérable.
set() : Cette fonction convertit une liste (ou tout itérable) en un ensemble (set). Un ensemble est une collection d'éléments uniques, ce qui signifie qu'il supprime automatiquement tous les doublons.

Fonctionnement

L'idée principale est de comparer la longueur de la liste originale avec la longueur de l'ensemble créé à partir de cette liste. Si les longueurs sont différentes, cela signifie qu'il y avait des doublons dans la liste originale.

Exemple

Modifions le fichier duplicates.py que nous avons créé à l'étape précédente pour utiliser cette approche.

Ouvrez le fichier duplicates.py dans votre répertoire ~/project avec VS Code.
Modifiez le code comme suit :
```
def has_duplicates(data):
    return len(data) != len(set(data))

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
if has_duplicates(numbers):
    print("The list contains duplicates.")
else:
    print("The list does not contain duplicates.")
```
Explication :
- La fonction has_duplicates compare simplement la longueur de la liste originale data avec la longueur de l'ensemble créé à partir de data.
- Si les longueurs sont différentes, la fonction retourne True (ce qui signifie qu'il y a des doublons), sinon elle retourne False.
Exécutez le script en utilisant la commande suivante dans votre terminal :
```
python duplicates.py
```
Vous devriez voir la sortie suivante :
```
The list contains duplicates.
```
Si vous changez la liste numbers en [1, 2, 3, 4, 5], la sortie sera :
```
The list does not contain duplicates.
```

Cette méthode est plus concise et souvent plus efficace que la méthode précédente, en particulier pour les grandes listes.

Utiliser collections.Counter

Dans cette étape, nous allons explorer une méthode encore plus puissante et plus « pythonique » pour compter les doublons en utilisant la classe collections.Counter. Cette classe est spécialement conçue pour compter la fréquence des éléments dans une liste ou tout autre itérable.

Comprendre collections.Counter

La classe collections.Counter est une sous - classe de dict spécialement conçue pour compter les objets hachables (hashable). Elle stocke les éléments en tant que clés de dictionnaire et leurs occurrences en tant que valeurs de dictionnaire.

Fonctionnement

collections.Counter compte automatiquement le nombre d'occurrences de chaque élément dans une liste. Vous pouvez ensuite facilement accéder aux comptages pour identifier les doublons.

Exemple

Modifions le fichier duplicates.py dans votre répertoire ~/project pour utiliser collections.Counter.

Ouvrez le fichier duplicates.py dans votre répertoire ~/project avec VS Code.
Modifiez le code comme suit :
```
from collections import Counter

def find_duplicates_counter(data):
    counts = Counter(data)
    duplicates = [item for item, count in counts.items() if count > 1]
    return duplicates

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
duplicate_numbers = find_duplicates_counter(numbers)
print("Original list:", numbers)
print("Duplicate numbers:", duplicate_numbers)
```
Explication :
- Nous importons la classe Counter du module collections.
- La fonction find_duplicates_counter crée un objet Counter à partir de la liste d'entrée data. Cela compte automatiquement le nombre d'occurrences de chaque élément.
- Nous utilisons ensuite une compréhension de liste pour créer une liste d'éléments dont le nombre d'occurrences est supérieur à 1 (c'est - à - dire les doublons).
Exécutez le script en utilisant la commande suivante dans votre terminal :
```
python duplicates.py
```
Vous devriez voir la sortie suivante :
```
Original list: [1, 2, 2, 3, 4, 4, 4, 5]
Duplicate numbers: [2, 4]
```
Cette sortie montre la liste originale et les nombres doublons trouvés dans la liste. Notez que l'approche Counter ne retourne que les valeurs doublons uniques, pas toutes les occurrences des doublons.

Résumé

Dans ce laboratoire (lab), nous avons commencé par définir les doublons comme des valeurs répétées dans un ensemble de données et mis en évidence leur impact sur l'exactitude des données, l'efficacité de stockage et les performances. Nous avons ensuite créé un script Python pour identifier les doublons dans une liste en utilisant une fonction find_duplicates.

La fonction parcourt la liste d'entrée, en utilisant un ensemble (set) appelé seen pour suivre les éléments rencontrés. Si un élément est déjà présent dans seen, il est identifié comme un doublon et ajouté à la liste duplicates. Cette approche exploite la propriété des ensembles de ne contenir que des valeurs uniques pour détecter efficacement les doublons.