Comment vérifier si une liste ne contient que des éléments uniques en Python

Introduction

Dans ce labo (LabEx), vous apprendrez à vérifier si une liste ne contient que des éléments uniques en Python. Ce labo se concentre sur l'utilisation des ensembles (sets) Python pour définir et identifier les éléments uniques au sein d'une liste.

Le labo vous guide dans la création d'un script Python, unique_elements.py, pour démontrer le fonctionnement des ensembles. Vous créerez une liste contenant des éléments dupliqués, la convertirez en un ensemble pour éliminer les doublons, puis afficherez à la fois la liste originale et l'ensemble résultant d'éléments uniques. En comparant la liste originale avec l'ensemble, vous comprendrez comment les ensembles peuvent être utilisés pour identifier et extraire les éléments uniques.

Skills Graph

Définir des éléments uniques

Dans cette étape, vous apprendrez à définir des éléments uniques en utilisant les ensembles (sets) Python. Les ensembles sont une structure de données fondamentale en Python qui ne stockent que des éléments uniques et non ordonnés. Cela signifie que si vous essayez d'ajouter un élément en double à un ensemble, il sera simplement ignoré. Comprendre les ensembles est crucial pour des tâches telles que la suppression des doublons d'une liste ou la vérification de la présence d'un élément dans une collection.

Commençons par créer un script Python pour démontrer le fonctionnement des ensembles.

1. Ouvrez votre WebIDE. Vous devriez voir l'explorateur de fichiers à gauche et un éditeur de texte à droite.

2. Dans l'explorateur de fichiers, accédez à votre répertoire de projet : /home/labex/project.

3. Créez un nouveau fichier nommé unique_elements.py en cliquant avec le bouton droit dans l'explorateur de fichiers et en sélectionnant "Nouveau fichier".

4. Ouvrez unique_elements.py dans l'éditeur et ajoutez le code suivant :

## Create a list with duplicate elements
my_list = [1, 2, 2, 3, 4, 4, 5]

## Convert the list to a set to remove duplicates
my_set = set(my_list)

## Print the original list and the set
print("Original List:", my_list)
print("Set of Unique Elements:", my_set)

Ce script crée d'abord une liste appelée my_list qui contient des éléments en double. Ensuite, il convertit cette liste en un ensemble appelé my_set. La fonction set() supprime automatiquement tous les éléments en double, ne laissant que les valeurs uniques. Enfin, le script affiche à la fois la liste originale et l'ensemble d'éléments uniques.

5. Enregistrez le fichier unique_elements.py.

6. Maintenant, exécutez le script en utilisant la commande suivante dans le terminal :

python unique_elements.py

Vous devriez voir la sortie suivante :

Original List: [1, 2, 2, 3, 4, 4, 5]
Set of Unique Elements: {1, 2, 3, 4, 5}

Comme vous pouvez le voir, l'ensemble my_set ne contient que les éléments uniques de la liste originale my_list. L'ordre des éléments dans l'ensemble peut être différent de celui de la liste originale car les ensembles ne sont pas ordonnés.

Cet exemple démontre l'utilisation de base des ensembles pour définir des éléments uniques en Python. Dans les étapes suivantes, vous explorerez des opérations plus avancées avec les ensembles.

Comparer len() avec len(set())

Dans cette étape, vous apprendrez à utiliser la fonction len() pour déterminer le nombre d'éléments dans une liste et le comparer avec le nombre d'éléments uniques dans un ensemble (set) créé à partir de la même liste. Cette technique est utile pour identifier le nombre d'éléments en double dans une liste.

La fonction len() renvoie le nombre d'éléments dans un objet. Lorsqu'elle est appliquée à une liste, elle renvoie le nombre total d'éléments, y compris les doublons. Lorsqu'elle est appliquée à un ensemble, elle renvoie le nombre d'éléments uniques.

Modifions le script Python de l'étape précédente pour comparer les longueurs de la liste originale et de l'ensemble d'éléments uniques.

1. Ouvrez le fichier unique_elements.py dans votre WebIDE, que vous avez créé à l'étape précédente. Il devrait se trouver dans /home/labex/project.

2. Modifiez le fichier unique_elements.py pour inclure le code suivant :

## Create a list with duplicate elements
my_list = [1, 2, 2, 3, 4, 4, 5]

## Convert the list to a set to remove duplicates
my_set = set(my_list)

## Print the length of the original list and the set
print("Length of Original List:", len(my_list))
print("Length of Set of Unique Elements:", len(my_set))

## Calculate the number of duplicate elements
num_duplicates = len(my_list) - len(my_set)
print("Number of Duplicate Elements:", num_duplicates)

Dans ce script, nous avons ajouté du code pour calculer et afficher les longueurs de la liste originale et de l'ensemble d'éléments uniques. Ensuite, nous calculons le nombre d'éléments en double en soustrayant la longueur de l'ensemble de la longueur de la liste.

3. Enregistrez le fichier unique_elements.py.

4. Exécutez le script en utilisant la commande suivante dans le terminal :

python unique_elements.py

Vous devriez voir la sortie suivante :

Length of Original List: 7
Length of Set of Unique Elements: 5
Number of Duplicate Elements: 2

Cette sortie montre que la liste originale a 7 éléments, tandis que l'ensemble d'éléments uniques en a 5. La différence entre ces longueurs (7 - 5 = 2) indique qu'il y a 2 éléments en double dans la liste originale.

Cet exemple démontre comment utiliser la fonction len() en conjonction avec les ensembles pour identifier et quantifier les éléments en double dans une liste.

Vérification par conversion en ensemble (set)

Dans cette étape, vous apprendrez à vérifier si une liste ne contient que des éléments uniques en la convertissant en un ensemble (set) et en comparant les longueurs. C'est une méthode concise et efficace pour déterminer s'il y a des éléments en double dans une liste.

L'idée principale est que si une liste contient des éléments en double, sa conversion en un ensemble réduira le nombre d'éléments car les ensembles ne stockent que des valeurs uniques. Si la longueur de la liste originale est la même que celle de l'ensemble créé à partir d'elle, alors la liste ne contient que des éléments uniques.

Modifions le script Python des étapes précédentes pour vérifier si une liste ne contient que des éléments uniques en utilisant la conversion en ensemble.

1. Ouvrez le fichier unique_elements.py dans votre WebIDE, que vous avez créé dans les étapes précédentes. Il devrait se trouver dans /home/labex/project.

2. Modifiez le fichier unique_elements.py pour inclure le code suivant :

## Create a list with or without duplicate elements
my_list = [1, 2, 3, 4, 5]  ## Example with unique elements
## my_list = [1, 2, 2, 3, 4, 5]  ## Example with duplicate elements

## Convert the list to a set
my_set = set(my_list)

## Check if the list contains only unique elements
if len(my_list) == len(my_set):
    print("The list contains only unique elements.")
else:
    print("The list contains duplicate elements.")

Dans ce script, nous définissons d'abord une liste my_list. Vous pouvez choisir d'utiliser l'exemple avec des éléments uniques ou l'exemple avec des éléments en double en commentant/décommentant les lignes correspondantes. Ensuite, nous convertissons la liste en un ensemble et comparons les longueurs de la liste et de l'ensemble. Si les longueurs sont égales, nous affichons un message indiquant que la liste ne contient que des éléments uniques ; sinon, nous affichons un message indiquant que la liste contient des éléments en double.

3. Enregistrez le fichier unique_elements.py.

4. Exécutez le script en utilisant la commande suivante dans le terminal :

python unique_elements.py

Si vous utilisez l'exemple avec des éléments uniques (my_list = [1, 2, 3, 4, 5]), vous devriez voir la sortie suivante :

The list contains only unique elements.

Si vous utilisez l'exemple avec des éléments en double (my_list = [1, 2, 2, 3, 4, 5]), vous devriez voir la sortie suivante :

The list contains duplicate elements.

Cet exemple démontre comment utiliser la conversion en ensemble pour vérifier efficacement si une liste ne contient que des éléments uniques. Cette technique est souvent utilisée dans les tâches de traitement et de validation des données.

Résumé

Dans ce laboratoire (lab), vous avez appris à définir des éléments uniques en utilisant les ensembles (sets) Python. Le laboratoire consistait à créer un script Python nommé unique_elements.py pour démontrer le fonctionnement des ensembles. Vous avez créé une liste avec des éléments en double, puis l'avez convertie en un ensemble à l'aide de la fonction set(), qui supprime automatiquement tous les éléments en double, ne laissant que les valeurs uniques.

Le script a ensuite affiché à la fois la liste originale et l'ensemble d'éléments uniques, montrant comment les ensembles peuvent être utilisés pour extraire les valeurs uniques d'une liste. Vous avez observé que l'ordre des éléments dans l'ensemble peut différer de celui de la liste originale en raison de la nature non ordonnée des ensembles.