Comment vérifier si une variable est un ensemble (set) en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à identifier si une variable est un ensemble (set) en Python. Vous commencerez par comprendre les caractéristiques fondamentales des ensembles, notamment leur nature non ordonnée et l'unicité de leurs éléments. Grâce à des exercices pratiques, vous créerez des ensembles en utilisant à la fois les accolades et le constructeur set(), et explorerez les opérations courantes sur les ensembles telles que l'ajout et la suppression d'éléments, ainsi que la vérification de l'appartenance.

Le laboratoire vous guidera ensuite dans l'utilisation de la fonction type() et de la fonction isinstance() pour déterminer si une variable est bien un ensemble. À la fin de ce laboratoire, vous disposerez des connaissances et des compétences nécessaires pour identifier avec confiance les ensembles dans votre code Python.

Comprendre les ensembles (Sets)

Dans cette étape, vous allez apprendre à propos des ensembles 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 dupliquées et que l'ordre des éléments dans un ensemble n'est pas garanti. Les ensembles sont utiles pour effectuer des opérations mathématiques sur les ensembles telles que l'union, l'intersection et la différence.

Commençons par créer un ensemble. Vous pouvez créer un ensemble en utilisant les accolades {} ou le constructeur set().

Ouvrez l'éditeur VS Code dans l'environnement LabEx.

Créez un nouveau fichier nommé sets_example.py dans le répertoire ~/project.

## Create a set using curly braces
my_set = {1, 2, 3, 4, 5}
print(my_set)

## Create a set using the set() constructor
another_set = set([3, 4, 5, 6, 7])
print(another_set)

Exécutez le script en utilisant la commande python dans le terminal :
```
python ~/project/sets_example.py
```
Vous devriez voir la sortie suivante :
```
{1, 2, 3, 4, 5}
{3, 4, 5, 6, 7}
```

Maintenant, explorons quelques opérations courantes sur les ensembles.

Ajoutez le code suivant à votre fichier sets_example.py :

## Add an element to a set
my_set.add(6)
print(my_set)

## Remove an element from a set
my_set.remove(1)
print(my_set)

## Check if an element is in a set
print(3 in my_set)
print(1 in my_set)

Exécutez le script à nouveau :
```
python ~/project/sets_example.py
```
Vous devriez voir une sortie similaire à celle-ci :
```
{1, 2, 3, 4, 5, 6}
{2, 3, 4, 5, 6}
True
False
```

Les ensembles sont particulièrement utiles pour supprimer les éléments dupliqués d'une liste.

Ajoutez le code suivant à votre fichier sets_example.py :

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

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

Exécutez le script :

python ~/project/sets_example.py

La sortie devrait être :

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
{1, 2, 3, 4}

Comme vous pouvez le voir, l'ensemble unique_elements ne contient que les éléments uniques de la liste originale.

Utiliser la fonction type() pour identifier

Dans cette étape, vous apprendrez à utiliser la fonction type() en Python pour identifier le type de données d'une variable. Comprendre les types de données est crucial pour écrire un code correct et efficace.

La fonction type() renvoie le type d'un objet. Voyons comment elle fonctionne avec différents types de données.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.

Créez un nouveau fichier nommé type_example.py dans le répertoire ~/project.

## Check the type of an integer
x = 10
print(type(x))

## Check the type of a float
y = 3.14
print(type(y))

## Check the type of a string
z = "Hello"
print(type(z))

## Check the type of a boolean
a = True
print(type(a))

## Check the type of a list
b = [1, 2, 3]
print(type(b))

## Check the type of a tuple
c = (1, 2, 3)
print(type(c))

## Check the type of a set
d = {1, 2, 3}
print(type(d))

## Check the type of a dictionary
e = {"name": "Alice", "age": 30}
print(type(e))

Exécutez le script en utilisant la commande python dans le terminal :

python ~/project/type_example.py

Vous devriez voir la sortie suivante :

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>

La sortie montre le type de données de chaque variable. Par exemple, <class 'int'> indique que la variable est un entier, et <class 'str'> indique que la variable est une chaîne de caractères.

Comprendre le type de données d'une variable est important car cela détermine les opérations que vous pouvez effectuer sur cette variable. Par exemple, vous pouvez effectuer des opérations arithmétiques sur les entiers et les nombres à virgule flottante, mais pas sur les chaînes de caractères.

Voyons un exemple de comment la fonction type() peut être utilisée pour vérifier si une variable est d'un type spécifique avant d'effectuer une opération.

Ajoutez le code suivant à votre fichier type_example.py :

## Check if a variable is an integer before adding 5 to it
num = 10
if type(num) == int:
    result = num + 5
    print(result)
else:
    print("Variable is not an integer")

## Check if a variable is a string before concatenating it with another string
text = "Hello"
if type(text) == str:
    greeting = text + ", World!"
    print(greeting)
else:
    print("Variable is not a string")

Exécutez le script à nouveau :
```
python ~/project/type_example.py
```
Vous devriez voir la sortie suivante :
```
15
Hello, World!
```

Dans cet exemple, la fonction type() est utilisée pour vérifier si la variable num est un entier et si la variable text est une chaîne de caractères avant d'effectuer respectivement les opérations d'addition et de concaténation.

Confirmer avec isinstance()

Dans cette étape, vous apprendrez à utiliser la fonction isinstance() en Python pour confirmer si un objet est une instance d'une classe ou d'un type particulier. C'est une méthode plus robuste et recommandée pour vérifier les types de données par rapport à l'utilisation de type().

La fonction isinstance() prend deux arguments : l'objet à vérifier et la classe ou le type à comparer. Elle renvoie True si l'objet est une instance de la classe ou du type spécifié, et False sinon.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.

Créez un nouveau fichier nommé isinstance_example.py dans le répertoire ~/project.

## Check if a variable is an integer
x = 10
print(isinstance(x, int))

## Check if a variable is a float
y = 3.14
print(isinstance(y, float))

## Check if a variable is a string
z = "Hello"
print(isinstance(z, str))

## Check if a variable is a boolean
a = True
print(isinstance(a, bool))

## Check if a variable is a list
b = [1, 2, 3]
print(isinstance(b, list))

## Check if a variable is a tuple
c = (1, 2, 3)
print(isinstance(c, tuple))

## Check if a variable is a set
d = {1, 2, 3}
print(isinstance(d, set))

## Check if a variable is a dictionary
e = {"name": "Alice", "age": 30}
print(isinstance(e, dict))

Exécutez le script en utilisant la commande python dans le terminal :
```
python ~/project/isinstance_example.py
```
Vous devriez voir la sortie suivante :
```
True
True
True
True
True
True
True
True
```

Toutes les variables sont des instances des types que nous avons vérifiés, donc isinstance() a renvoyé True dans chaque cas.

isinstance() est particulièrement utile lorsqu'il s'agit d'héritage. Si une classe hérite d'une autre classe, un objet de la sous-classe est également considéré comme une instance de la classe mère.

Ajoutez le code suivant à votre fichier isinstance_example.py :

class Animal:
    pass

class Dog(Animal):
    pass

my_dog = Dog()

## Check if my_dog is an instance of Dog
print(isinstance(my_dog, Dog))

## Check if my_dog is an instance of Animal
print(isinstance(my_dog, Animal))

Exécutez le script à nouveau :
```
python ~/project/isinstance_example.py
```
Vous devriez voir la sortie suivante :
```
True
True
```

Dans cet exemple, Dog hérite de Animal. Par conséquent, my_dog est une instance à la fois de Dog et d'Animal.

L'utilisation de isinstance() est généralement préférée à celle de type() car elle gère correctement l'héritage et est plus flexible.

Résumé

Dans ce laboratoire, vous avez appris à connaître les ensembles (sets) en Python, qui sont des collections non ordonnées d'éléments uniques. Vous avez créé des ensembles en utilisant les accolades {} et le constructeur set(), et vous avez effectué des opérations courantes sur les ensembles, telles que l'ajout et la suppression d'éléments.

En outre, vous avez exploré comment les ensembles peuvent être utilisés pour supprimer les éléments en double d'une liste en convertissant la liste en ensemble. Vous avez également appris à vérifier l'appartenance à un ensemble en utilisant l'opérateur in.