Comment vérifier si un ensemble ne contient que des nombres en Python

Introduction

Dans ce laboratoire, vous apprendrez à vérifier si un ensemble ne contient que des nombres en Python. Le laboratoire se concentre sur la définition d'ensembles numériques, y compris les ensembles vides, les ensembles d'entiers, les ensembles de nombres à virgule flottante et les ensembles mixtes contenant à la fois des entiers et des nombres à virgule flottante. Vous explorerez également la manière dont les ensembles gèrent les valeurs en double, garantissant l'unicité.

Le laboratoire vous guide dans la création d'un fichier Python nommé numeric_sets.py, l'ajout de code pour définir et afficher différents ensembles, et l'exécution du script pour observer la sortie. Vous apprendrez à utiliser le constructeur set() et à comprendre comment les ensembles éliminent automatiquement les valeurs en double, démontrant les propriétés fondamentales des ensembles en Python.

Skills Graph

Définir des ensembles numériques

Dans cette étape, vous apprendrez à définir des ensembles contenant des nombres en Python. Les ensembles sont des collections non ordonnées d'éléments uniques. Cela signifie qu'un ensemble ne peut pas contenir de valeurs en double. Nous allons nous concentrer sur la création d'ensembles d'entiers et de nombres à virgule flottante.

Tout d'abord, créons un fichier Python nommé numeric_sets.py dans votre répertoire ~/project en utilisant l'éditeur VS Code.

## Create an empty set
empty_set = set()
print("Empty Set:", empty_set)

## Create a set of integers
integer_set = {1, 2, 3, 4, 5}
print("Integer Set:", integer_set)

## Create a set of floats
float_set = {1.0, 2.5, 3.7, 4.2, 5.9}
print("Float Set:", float_set)

## Create a mixed set (integers and floats)
mixed_set = {1, 2.0, 3, 4.5, 5}
print("Mixed Set:", mixed_set)

Enregistrez le fichier sous le nom numeric_sets.py dans votre répertoire ~/project. Maintenant, exécutez le script en utilisant la commande suivante dans le terminal :

python numeric_sets.py

Vous devriez voir la sortie suivante :

Empty Set: set()
Integer Set: {1, 2, 3, 4, 5}
Float Set: {1.0, 2.5, 3.7, 4.2, 5.9}
Mixed Set: {1, 2.0, 3, 4.5, 5}

Notez que l'ordre des éléments dans l'ensemble peut ne pas être le même que l'ordre dans lequel ils ont été définis. Cela est dû au fait que les ensembles sont des collections non ordonnées. De plus, les ensembles éliminent automatiquement les valeurs en double.

Maintenant, ajoutons quelques exemples supplémentaires à votre fichier numeric_sets.py pour démontrer l'unicité des ensembles :

## Create a set with duplicate values
duplicate_set = {1, 2, 2, 3, 4, 4, 5}
print("Duplicate Set:", duplicate_set)

## Create a set from a list with duplicate values
duplicate_list = [1, 2, 2, 3, 4, 4, 5]
unique_set = set(duplicate_list)
print("Unique Set from List:", unique_set)

Enregistrez les modifications et exécutez le script à nouveau :

python numeric_sets.py

Vous devriez voir la sortie suivante :

Empty Set: set()
Integer Set: {1, 2, 3, 4, 5}
Float Set: {1.0, 2.5, 3.7, 4.2, 5.9}
Mixed Set: {1, 2.0, 3, 4.5, 5}
Duplicate Set: {1, 2, 3, 4, 5}
Unique Set from List: {1, 2, 3, 4, 5}

Comme vous pouvez le voir, l'ensemble duplicate_set et l'ensemble unique_set ne contiennent que des valeurs uniques, même si nous avons essayé de les créer avec des valeurs en double.

Utiliser all() avec isinstance()

Dans cette étape, vous apprendrez à utiliser la fonction all() en combinaison avec la fonction isinstance() pour vérifier si tous les éléments d'un ensemble sont d'un type numérique spécifique. Cela est utile pour valider le contenu d'un ensemble avant d'effectuer des opérations sur celui-ci.

La fonction all() renvoie True si tous les éléments d'un itérable (comme un ensemble) sont vrais. La fonction isinstance() vérifie si un objet est une instance d'une classe ou d'un type spécifié.

Modifions le fichier numeric_sets.py que vous avez créé à l'étape précédente pour inclure ces vérifications. Ouvrez numeric_sets.py dans l'éditeur VS Code et ajoutez le code suivant :

def check_if_all_are_integers(input_set):
  """Checks if all elements in the set are integers."""
  return all(isinstance(x, int) for x in input_set)

def check_if_all_are_floats(input_set):
  """Checks if all elements in the set are floats."""
  return all(isinstance(x, float) for x in input_set)

## Example usage:
integer_set = {1, 2, 3, 4, 5}
float_set = {1.0, 2.5, 3.7, 4.2, 5.9}
mixed_set = {1, 2.0, 3, 4.5, 5}

print("Are all elements in integer_set integers?", check_if_all_are_integers(integer_set))
print("Are all elements in float_set floats?", check_if_all_are_floats(float_set))
print("Are all elements in mixed_set integers?", check_if_all_are_integers(mixed_set))
print("Are all elements in mixed_set floats?", check_if_all_are_floats(mixed_set))

Enregistrez le fichier et exécutez-le en utilisant la commande suivante :

python numeric_sets.py

Vous devriez voir la sortie suivante :

Are all elements in integer_set integers? True
Are all elements in float_set floats? True
Are all elements in mixed_set integers? False
Are all elements in mixed_set floats? False

La sortie montre que integer_set ne contient que des entiers, float_set ne contient que des nombres à virgule flottante, et mixed_set contient un mélange d'entiers et de nombres à virgule flottante, donc les vérifications renvoient False pour les vérifications d'entiers et de nombres à virgule flottante.

Maintenant, ajoutons une fonction pour vérifier si tous les éléments sont soit des entiers, soit des nombres à virgule flottante (c'est-à-dire numériques) :

def check_if_all_are_numeric(input_set):
  """Checks if all elements in the set are either integers or floats."""
  return all(isinstance(x, (int, float)) for x in input_set)

print("Are all elements in mixed_set numeric?", check_if_all_are_numeric(mixed_set))

string_set = {"a", "b", "c"}
print("Are all elements in string_set numeric?", check_if_all_are_numeric(string_set))

Enregistrez le fichier et exécutez-le à nouveau :

python numeric_sets.py

Vous devriez voir la sortie suivante :

Are all elements in integer_set integers? True
Are all elements in float_set floats? True
Are all elements in mixed_set integers? False
Are all elements in mixed_set floats? False
Are all elements in mixed_set numeric? True
Are all elements in string_set numeric? False

Cela démontre comment utiliser all() et isinstance() pour valider les types des éléments dans un ensemble.

Gérer les ensembles vides

Dans cette étape, vous apprendrez à gérer les ensembles vides lorsque vous utilisez les fonctions all() et isinstance(). Les ensembles vides sont un cas particulier car ils ne contiennent aucun élément. Comprendre le comportement de ces fonctions avec les ensembles vides est crucial pour écrire un code robuste.

Considérons ce qui se passe lorsque vous utilisez all() avec un ensemble vide. La fonction all() renvoie True si tous les éléments de l'itérable sont vrais. Étant donné qu'un ensemble vide n'a aucun élément, on peut soutenir que "tous" ses éléments sont vrais, simplement parce qu'il n'y a aucun élément qui puisse être faux.

Modifions le fichier numeric_sets.py pour démontrer cela. Ouvrez numeric_sets.py dans l'éditeur VS Code et ajoutez le code suivant :

def check_if_all_are_integers(input_set):
  """Checks if all elements in the set are integers."""
  return all(isinstance(x, int) for x in input_set)

## Example with an empty set:
empty_set = set()
print("Is empty_set all integers?", check_if_all_are_integers(empty_set))

Enregistrez le fichier et exécutez-le en utilisant la commande suivante :

python numeric_sets.py

Vous devriez voir la sortie suivante :

Is empty_set all integers? True

Ce résultat peut sembler contre-intuitif au premier abord. Cependant, il est cohérent avec la définition de all().

Maintenant, considérons un scénario où vous souhaitez gérer explicitement les ensembles vides différemment. Vous pouvez ajouter une vérification pour un ensemble vide avant d'utiliser all() :

def check_if_all_are_integers_safe(input_set):
  """Checks if all elements in the set are integers, handling empty sets explicitly."""
  if not input_set:
    return False  ## Or True, depending on your desired behavior for empty sets
  return all(isinstance(x, int) for x in input_set)

empty_set = set()
print("Is empty_set all integers (safe)?", check_if_all_are_integers_safe(empty_set))

integer_set = {1, 2, 3}
print("Is integer_set all integers (safe)?", check_if_all_are_integers_safe(integer_set))

Enregistrez le fichier et exécutez-le à nouveau :

python numeric_sets.py

Vous devriez voir la sortie suivante :

Is empty_set all integers (safe)? False
Is integer_set all integers (safe)? True

Dans cet exemple, la fonction check_if_all_are_integers_safe renvoie False pour un ensemble vide. Vous pouvez modifier la valeur de retour dans le bloc if not input_set: pour répondre à vos besoins spécifiques. Gérer explicitement les ensembles vides peut éviter des comportements inattendus dans votre code.

Résumé

Dans ce laboratoire (lab), vous avez appris à définir des ensembles contenant des nombres en Python, y compris des ensembles vides, des ensembles d'entiers, des ensembles de nombres à virgule flottante (floats) et des ensembles mixtes contenant à la fois des entiers et des nombres à virgule flottante. Vous avez également observé que les ensembles sont des collections non ordonnées et qu'ils éliminent automatiquement les valeurs en double.

Le laboratoire a démontré comment créer des ensembles directement et à partir de listes contenant des valeurs en double, mettant en évidence la propriété des ensembles de ne conserver que des éléments uniques. Les exemples ont fourni une compréhension pratique de la façon dont les ensembles gèrent différents types numériques et éliminent les redondances.