Travailler avec les ensembles

3.1 Détermination du nombre d'éléments

Tu peux déterminer le nombre d'éléments dans un ensemble en utilisant la fonction len(). Cette fonction renvoie le nombre d'éléments uniques dans l'ensemble.

Exemple d'utilisation de la fonction len()

my_set = {1, 2, 3, 4, 5}
print(len(my_set))  # Affichage: 5
        

Dans cet exemple, l'ensemble my_set contient cinq éléments. La fonction len() renvoie ce nombre.

Vérification si un ensemble est vide

Tu peux utiliser la fonction len() pour vérifier si un ensemble est vide. C'est utile dans les conditions et boucles.

my_set = set()

if len(my_set) == 0:
    print("L'ensemble est vide")
else:
    print("L'ensemble n'est pas vide")
        

3.2 Détermination du type

Si tu ne sais pas exactement si une variable contient un ensemble, tu peux utiliser la fonction type() pour être plus sûr. La fonction type() en Python renvoie le type de l'objet. C'est utile pour vérifier le type de données, surtout quand tu travailles avec des ensembles et d'autres collections de données.

Exemple:

my_set = {1, 2, 3}
print(type(my_set))  # Affichage: <class 'set'>

        

Dans cet exemple, type(my_set) renvoie <class 'set'>, indiquant que my_set est un ensemble.

Vérification du type de données

Tu peux utiliser la fonction type() pour vérifier le type de données avant d'effectuer des opérations. Cela aide à éviter les erreurs liées aux types de données incompatibles.

def add_element(collection, element):
    if type(collection) is set:
        collection.add(element)
    else:
        print("Erreur : la collection fournie n'est pas un ensemble")
        
my_set = {1, 2, 3}
add_element(my_set, 4)  # L'élément sera ajouté
add_element([1, 2, 3], 4)  # Affichera une erreur
        

Dans cet exemple, la fonction add_element() vérifie si la collection fournie est un ensemble avant d'ajouter l'élément.

La fonction type() peut être utile lors de la création de structures de données complexes, qui peuvent contenir de nombreux types de données différents. Elle permet de déterminer dynamiquement le type de données et de les traiter en conséquence.

Exemple:

my_set = {}
print(type(my_set))  # Affichage: <class 'dict'> 
        

Les accolades sont utilisées pour créer un ensemble et pour créer un dictionnaire (la syntaxe diffère légèrement à l'intérieur). Par défaut, s'il n'y a pas d'éléments entre les accolades, un dictionnaire sera créé!

3.3 Ordre des éléments

Les ensembles sont un type particulier de collection de données qui ne stockent que des éléments uniques. L'une des caractéristiques clés des ensembles est qu'ils sont non ordonnés. Cela signifie que les éléments d'un ensemble n'ont pas d'ordre fixe et que l'ordre des éléments peut changer à chaque itération.

Les ensembles en Python sont implémentés sur la base de tables de hachage. Lorsque tu ajoutes un élément à un ensemble, Python calcule sa valeur de hachage et l'utilise pour déterminer la position de l'élément dans la table de hachage. Cette structure de données permet une vérification rapide de l'appartenance, l'ajout et la suppression d'éléments. Cependant, en raison de l'utilisation des valeurs de hachage, l'ordre des éléments n'est pas conservé et ne peut pas être prédit.

Exemple de non-ordonnancement des ensembles

Voici un exemple simple:

my_set = {3, 1, 2}
for item in my_set:
    print(item)
    

Lors de l'exécution de ce code, les éléments peuvent être affichés dans n'importe quel ordre, par exemple, 1 2 3 ou 3 1 2. Cela signifie que l'ordre de sortie des éléments de l'ensemble n'est pas garanti et peut changer à chaque exécution du programme.

Importance de la non-ordonnancement

La non-ordonnancement des ensembles a plusieurs conséquences importantes :

• Absence d'indexation : contrairement aux listes et tuples, les ensembles ne prennent pas en charge l'accès aux éléments par index. Essayer de faire my_set[0] déclenchera une erreur.
• Performance : La non-ordonnancement permet aux ensembles d'être performants, surtout lors de l'ajout et de la suppression d'éléments.
• Unicité des éléments : Les ensembles éliminent automatiquement les doublons, ce qui les rend utiles pour stocker des données uniques.