Langage Python

Les ensembles en Python

Un ensemble est une collection non ordonnée d'éléments. Chaque élément est unique (pas de doublons) et doit être immuable (ce qui ne peut pas être changé).
Cependant, l'ensemble lui-même est mutable. Nous pouvons ajouter ou supprimer des éléments.

Vous pouvez penser à des ensembles comme une liste. Cependant, ils diffèrent d'une liste des manières suivantes:

  • Chaque élément à l'intérieur d'un ensemble doit être unique.
  • Les éléments d'un ensemble ne sont stockés dans aucun ordre particulier.

Si votre application ne se soucie pas de la façon dont les éléments sont stockés, utilisez des ensembles plutôt que des listes, car en ce qui concerne la manipulation des éléments, un ensemble est beaucoup plus efficace qu'une liste.

Les ensembles peuvent être utilisés pour effectuer des opérations d’ensembles mathématiques telles que l’union, l’intersection, la différence symétrique, etc.

Creation d'un ensemble

Un ensemble est créé en plaçant tous les éléments (éléments) entre accolades {}, séparés par une virgule ou en utilisant la fonction intégrée set().

Il peut avoir n'importe quel nombre d'éléments et ils peuvent être de types différents (int, float, tuple, string, etc.). Mais un ensemble ne peut pas avoir un élément mutable, comme une liste, un ensemble ou un dictionnaire.

Exemple 1 :
                                # création d'un ensemble de 4 éléments
                                e1={1,3,5,7}
                                print("le type de e1 est : ",type(e1))
                                print("les éléments de e1 sont : ",e1)

                                e2={"Mostafa", 1.78, 32 }
                                print("e2 : ",e2)

                                # ensemble avec doublons
                                e3 = {3, 5, 7, 2, 3, 5}
                                print("e5 : ", e5)
                            
le type de e1 est : < class 'set'>
les éléments de e1 sont : {1, 3, 5, 7}
e2 : {32, 1.78, 'Mostafa'}
e3 : {2, 3, 5, 7}

Nous pouvons également utiliser la fonction intégrée set() pour créer des ensembles. Voici quelques exemples:

Exemple 2 :
                                # créer un ensemble à partir d'un ensemble
                                e1 = set({77, 23, 91, 271})
                                print("e1 : ",e1)

                                #créer un ensemble à partir d'une chaîne
                                e2 = set("123abc")
                                print("e2 : ",e2)

                                # créer un ensemble à partir d'une liste
                                e3 = set(['Mostafa', 'Sedoki', 'Meknes', 32, 1.78]) 
                                print("e3 : ",e3)

                                #créer un ensemble à partir d'un tuple
                                e4 = set(("Meknes", "Marrakech", "Essaouira"))
                                print("e4 : ",e4)
                            
e1 : {91, 271, 77, 23}
e2 : {'3', 'b', '1', '2', 'a', 'c'}
e3 : {32, 1.78, 'Sedoki', 'Mostafa', 'Meknes'}
e4 : {'Marrakech', 'Essaouira', 'Meknes'}

Modifier un ensemble

Les ensembles sont mutables. Mais comme ils ne sont pas ordonnés, l'indexation n'a pas de sens.
Nous ne pouvons pas accéder à un élément d'un ensemble ni le modifier à l'aide de l'indexation ou du découpage en tranches. Set ne le supporte pas.

Nous pouvons ajouter un seul élément à l'aide de la méthode add() et plusieurs éléments à l'aide de la méthode update(). La méthode update() peut prendre pour argument des tuples, des listes, des chaînes ou d'autres ensembles. Dans tous les cas, les doublons sont évités.

Exemple 3 :
                                e={1,3}

                                # ajouter un élément
                                e.add(5)
                                print("e : ",e)

                                # ajouter une liste
                                e.update([9,4,7])
                                print("e : ",e)

                                # ajouter une liste et un ensemble
                                e.update([50,51],{100,200})
                                print("e : ",e)
                            
e : {1, 3, 5}
e : {1, 3, 4, 5, 7, 9}
e : {1, 3, 4, 5, 100, 7, 200, 9, 50, 51}

Supprimer un élément d'un ensemble

Un élément particulier peut être supprimé de la série à l’aide des méthodes, discard() et remove().
La seule différence entre les deux est que, tout en utilisant discard() si l'élément n'existe pas dans l'ensemble, il reste inchangé. Mais remove() lève une erreur dans une telle condition.

Exemple 4 :
                                e = {1, 3, 6, 7}

                                e.discard(3)
                                print("e : ", e)
                                    
                                e.remove(7)
                                print("e : ", e)
                                    
                                e.discard(9)
                                print("e : ", e)
                                    
                                e.remove(9)
                                print("e : ", e)
                            
e : {1, 6, 7}
e : {1, 6}
e : {1, 6}
Traceback (most recent call last):
File "prog.py", line 12, in < module>
e.remove(9)
KeyError: 9

De même, nous pouvons supprimer et retourner un élément en utilisant la méthode pop().
Les ensembles n'étant pas ordonnés, il n'y a aucun moyen de déterminer quel élément sera supprimé. C'est complètement arbitraire.
Nous pouvons également supprimer tous les éléments d'un ensemble en utilisant clear().

Exemple 5 :
                                e={2, 4, 90, 100, 30, 32, 1}
                                val=e.pop()
                                print("val : ",val)
                                print("e : ",e)

                                e.clear()
                                print("e : ",e)
                            
val : 32
e : {1, 2, 100, 4, 90, 30}
e : set()

Sous-ensemble et Sur-ensemble

L'ensemble B est un sous-ensemble de A, si tous les éléments de l'ensemble B sont également les éléments de l'ensemble A. Par exemple:

                                A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
                                B = {1, 2, 3}
                            

A est un ensemble de 10 premiers nombres naturels et B est un ensemble de 3 premiers nombres naturels. Tous les éléments de l'ensemble B sont également les éléments de l'ensemble B. Par conséquent, B est un sous-ensemble de A. En d'autres termes, nous pouvons également dire que l'ensemble A est un sur-ensemble de B.

Nous pouvons tester si un ensemble est un sous-ensemble ou un sur-ensemble d'un autre ensemble à l'aide des méthodes issubset() et issuperset().

Exemple 6 :
                                A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
                                B = {1, 2, 3}
                                # tester si B est un sous-ensemble de A
                                if B.issubset(A):
                                    print("B est un sous-ensemble de A")
                                
                                # tester si A est un sur-ensemble de B
                                if A.issuperset(B):
                                    print("A est un sur-ensemble de B")
                            
B est un sous-ensemble de A
A est un sur-ensemble de B

Comparer des ensembles

Exemple 7 :
                                A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
                                B = {1, 2, 3}

                                if B < A):
                                    print("B est un sous-ensemble de A")
                                
                                if A > B:
                                    print("A est un sur-ensemble de B")
                                
                                if A == B:
                                    print("A et B sont identiques")
                                
                                if A>=B:
                                    print("A est sur-ensemble ou égal à B")

                            

Union et intersection

Union

Supposons que nous avons deux ensembles A et B, l’union de A et B est un ensemble composé de tous les éléments de A et tous les éléments de B. Les éléments en double ne seront inclus qu’une seule fois. En mathématiques, nous utilisons le symbole pour désigner l'union. Symboliquement, nous écrivons A union B comme A ∪ B.

Pour effectuer une opération d'union en Python, nous pouvons utiliser la méthode union() ou | opérateur. Par exemple:

Exemple 8 :
                                A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
                                B = {1, 2, 3, 20, 34}

                                C=A.union(B)
                                print("Union : ", C)
                            
Union : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 20}

Intersection

L'intersection des ensembles A et B est un ensemble composé de tous les éléments communs à A et B. Le symbole ∩ indique l'intersection. Symboliquement, une intersection B s'écrit A ∩ B.

Pour effectuer une opération d'intersection en Python, nous utilisons la méthode intersection() ou l'opérateur &. Par exemple:

Exemple 9 :
                                A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
                                B = {1, 2, 3, 20, 34}

                                C=A.intersection(B)
                                print("Intersection : ", C)
                            
Intersection : {1, 2, 3}

Différence et différence symétrique

Différence

La différence des ensembles A et B est un ensemble d'éléments qui contient tous les éléments de l'ensemble A mais pas de B. Comme d'habitude, nous utilisons le symbole - pour désigner l'opération de différence. Symboliquement, A moins B s'écrit A - B.

En Python, nous utilisons la méthode difference() ou l'opérateur - pour effectuer la différence définie.

Exemple 10 :
                                A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
                                B = {1, 2, 3, 20, 34}

                                C=A.difference(B)
                                print("A - B : ", C)
                            
A - B : {4, 5, 6, 7, 8, 9, 10}

Différence symétrique

La différence symétrique de deux ensembles A et B est un ensemble constitué d'éléments qui sont dans un ensemble mais pas dans les deux. Le symbole △ indique une différence symétrique.

En Python, nous utilisons la méthode symmetric_difference() ou l'opérateur ^ pour effectuer cette opération.

Exemple 11 :
                                A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
                                B = {1, 2, 3, 20, 34}

                                C=A.symmetric_difference(B)
                                print("Différence symétrique : ", C)
                            
Différence symétrique : {34, 4, 5, 6, 7, 8, 9, 10, 20}

Différentes méthodes d'ensembles

Il existe de nombreuses méthodes, dont certaines ont déjà été utilisées précédemment. Voici une liste de toutes les méthodes disponibles avec les ensemble.

MéthodeDescription
add()Ajoute un élément à l'ensemble
clear()Supprime tous les éléments de l'ensemble
copy()Renvoie une copie de l'ensemble
difference()Différence en deux ensembles
discard()Supprime un élément de l'ensemble
intersection()Intersection de deux ensembles
isdisjoint()Renvoie True si deux ensembles ont une intersection nulle
issubset()sous-ensemble
issuperset()sur-ensemble
pop()Supprime et retourne un élément arbitraire de l'ensemble.
remove()Supprime un élément de l'ensemble.
symmetric_difference()différence symétrique de deux ensembles
union()union de deux ensemble
update()Met à jour l'ensemble
all()renvoie True si tous les éléments de l'ensemble sont vrais (ou si l'ensemble est vide).
any()renvoie True si un élément de l'ensemble est vrai. Si l'ensemble est vide, renvoie False.
enumerate()Renvoie un objet énumérer. Il contient l'indice et la valeur de tous les éléments de l'ensemble sous forme de paire.
len()la taille
max()le maximum
min()le minimum d'un ensemble
sorted()Renvoie une nouvelle liste triée à partir des éléments de l'ensemble (ne permet pas de trier l'ensemble lui-même)
sum()Somme de tous les éléments.

Frozenset

Frozenset est une nouvelle classe qui présente les caractéristiques d'un ensemble, mais ses éléments ne peuvent pas être modifiés une fois affectés. Les tuples sont des listes immuables, les frozensets sont des ensembles immuables.

Les ensembles étant mutables sont unhashable, donc ils ne peuvent pas être utilisés comme des clés de dictionnaires. D'autre part, frozensets sont hashable et peuvent être utilisés comme clés d'un dictionnaire.

Les Frozensets peuvent être créés en utilisant la fonction frozenset().

Ce type de données prend en charge des méthodes telles que copy(), difference(), intersection(), isdisjoint(), issubset(), issuperset(), symmetric_difference() et union(). Étant immuable, il n’a pas de méthode pour ajouter ou enlever des éléments

Exemple 12 :
                                A = frozenset([1, 2, 3, 4])
                                B = frozenset([3, 4, 5, 6])
                            

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :