Comment vérifier si un tuple a des doublons en Python

Introduction

Dans ce labo (LabEx), vous apprendrez à vérifier la présence de doublons dans des tuples Python. Ce labo explore deux méthodes principales : comparer la longueur du tuple avec celle de sa représentation sous forme d'ensemble (set), et utiliser l'objet collections.Counter.

La première étape consiste à comprendre comment les tuples gèrent les éléments dupliqués en créant un tuple contenant des doublons et en y accédant à l'aide d'indexation. Cela démontre que les tuples conservent l'ordre et la fréquence des éléments, y compris les doublons. La deuxième étape, qui est tronquée ici, consistera probablement à comparer la longueur (len()) du tuple avec celle de sa représentation sous forme d'ensemble (set) pour détecter la présence de doublons.

Skills Graph

Comprendre les doublons dans les tuples

Dans cette étape, nous allons explorer comment les tuples gèrent les éléments dupliqués. Les tuples, tout comme les listes, peuvent contenir plusieurs instances de la même valeur. Comprendre comment les doublons sont stockés et accessibles dans les tuples est essentiel pour l'analyse et la manipulation de données.

Commençons par créer un tuple avec des éléments dupliqués :

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
print(my_tuple)

Créez un fichier nommé duplicates.py dans votre répertoire ~/project en utilisant l'éditeur VS Code. Copiez et collez le code ci-dessus dans le fichier.

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

python duplicates.py

Vous devriez voir la sortie suivante :

(1, 2, 2, 3, 4, 4, 4, 5)

Comme vous pouvez le voir, le tuple my_tuple contient des valeurs dupliquées (2 et 4). Les tuples conservent l'ordre et la fréquence des éléments, y compris les doublons.

Maintenant, accédons aux éléments dupliqués en utilisant l'indexation :

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
print(my_tuple[1])
print(my_tuple[2])
print(my_tuple[4])
print(my_tuple[5])
print(my_tuple[6])

Ajoutez ces lignes à votre fichier duplicates.py. Le fichier complet devrait maintenant ressembler à ceci :

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
print(my_tuple)
print(my_tuple[1])
print(my_tuple[2])
print(my_tuple[4])
print(my_tuple[5])
print(my_tuple[6])

Exécutez le script à nouveau :

python duplicates.py

La sortie sera :

(1, 2, 2, 3, 4, 4, 4, 5)
2
2
4
4
4

Cela démontre que vous pouvez accéder à chaque élément dupliqué individuellement en utilisant son index.

Les tuples autorisent les doublons et maintiennent l'ordre dans lequel les éléments ont été initialement ajoutés. Cela diffère des ensembles (sets), qui n'autorisent pas les doublons. Dans l'étape suivante, nous comparerons la longueur d'un tuple avec celle de sa représentation sous forme d'ensemble (set) pour comprendre comment les doublons affectent la taille.

Comparer len() avec len(set())

Dans cette étape, nous allons comparer la fonction len() appliquée à un tuple avec la fonction len() appliquée à la représentation sous forme d'ensemble (set) du même tuple. Cela mettra en évidence la différence de gestion des doublons entre les tuples et les ensembles.

Tout d'abord, rappelons que les tuples autorisent les éléments dupliqués, tandis que les ensembles ne le permettent pas. Un ensemble ne contient que des éléments uniques. Par conséquent, lorsque nous convertissons un tuple en un ensemble, les éléments dupliqués sont supprimés.

Nous allons utiliser le même my_tuple de l'étape précédente :

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
print("Tuple:", my_tuple)
print("Length of tuple:", len(my_tuple))

my_set = set(my_tuple)
print("Set:", my_set)
print("Length of set:", len(my_set))

Ajoutez ces lignes à votre fichier duplicates.py. Le fichier complet devrait maintenant ressembler à ceci :

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
print("Tuple:", my_tuple)
print("Length of tuple:", len(my_tuple))

my_set = set(my_tuple)
print("Set:", my_set)
print("Length of set:", len(my_set))

Exécutez le script :

python duplicates.py

La sortie sera :

Tuple: (1, 2, 2, 3, 4, 4, 4, 5)
Length of tuple: 8
Set: {1, 2, 3, 4, 5}
Length of set: 5

Comme vous pouvez le voir, la longueur du tuple est de 8 car il contient 8 éléments, y compris les doublons. Cependant, la longueur de l'ensemble est de 5 car il ne contient que les éléments uniques du tuple.

Cette comparaison démontre que len(tuple) compte tous les éléments, y compris les doublons, tandis que len(set(tuple)) ne compte que les éléments uniques. Cette distinction est importante lorsque vous devez analyser la fréquence des éléments dans un ensemble de données.

Dans l'étape suivante, nous utiliserons l'objet collections.Counter pour compter les occurrences de chaque élément dans le tuple.

Utiliser collections.Counter pour les tuples

Dans cette étape, nous allons utiliser l'objet collections.Counter pour compter efficacement les occurrences de chaque élément dans un tuple. La classe Counter est un outil puissant pour l'analyse de fréquence et offre un moyen pratique de déterminer combien de fois chaque élément unique apparaît dans un tuple.

Tout d'abord, vous devez importer la classe Counter depuis le module collections. Ensuite, vous pouvez créer un objet Counter à partir de votre tuple.

Utilisons le même my_tuple des étapes précédentes :

from collections import Counter

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
print("Tuple:", my_tuple)

element_counts = Counter(my_tuple)
print("Element counts:", element_counts)

Ajoutez ces lignes à votre fichier duplicates.py. Le fichier complet devrait maintenant ressembler à ceci :

from collections import Counter

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
print("Tuple:", my_tuple)

element_counts = Counter(my_tuple)
print("Element counts:", element_counts)

Exécutez le script :

python duplicates.py

La sortie sera :

Tuple: (1, 2, 2, 3, 4, 4, 4, 5)
Element counts: Counter({4: 3, 2: 2, 1: 1, 3: 1, 5: 1})

L'objet Counter element_counts stocke maintenant les comptages de chaque élément dans le tuple. Par exemple, 4: 3 indique que le nombre 4 apparaît 3 fois dans le tuple.

Vous pouvez accéder au comptage d'un élément spécifique en utilisant la syntaxe suivante :

from collections import Counter

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
element_counts = Counter(my_tuple)

print("Count of 2:", element_counts[2])
print("Count of 4:", element_counts[4])

Ajoutez ces lignes à votre fichier duplicates.py. Le fichier complet devrait maintenant ressembler à ceci :

from collections import Counter

my_tuple = (1, 2, 2, 3, 4, 4, 4, 5)
print("Tuple:", my_tuple)

element_counts = Counter(my_tuple)
print("Element counts:", element_counts)

print("Count of 2:", element_counts[2])
print("Count of 4:", element_counts[4])

Exécutez le script à nouveau :

python duplicates.py

La sortie sera :

Tuple: (1, 2, 2, 3, 4, 4, 4, 5)
Element counts: Counter({4: 3, 2: 2, 1: 1, 3: 1, 5: 1})
Count of 2: 2
Count of 4: 3

La classe collections.Counter offre un moyen pratique et efficace de compter les occurrences d'éléments dans un tuple, ce qui en fait un outil précieux pour l'analyse et la manipulation de données.

Résumé

Dans ce laboratoire (lab), nous avons commencé par explorer la manière dont les tuples gèrent les éléments dupliqués, démontrant que, contrairement aux ensembles (sets), les tuples peuvent contenir plusieurs instances de la même valeur tout en préservant leur ordre et leur fréquence. Nous avons créé un tuple avec des valeurs dupliquées et avons accédé à ces doublons en utilisant l'indexation, confirmant que chaque élément dupliqué peut être accédé individuellement.

L'étape suivante consistera à comparer la longueur d'un tuple avec la longueur de sa représentation sous forme d'ensemble (set) pour comprendre comment les doublons affectent la taille, ce qui n'a pas été terminé dans le contenu fourni.