TI1 – Semestre 2

Préparation à la certification Python 2 Ahlem ELHAJ

Chapitre 1 – Les ensembles

En Python, les collections permettent de stocker plusieurs valeurs dans un même objet. A l’instar des
listes, tuples et dictionnaires, les ensembles sont un exemple de collections.
I. Présentation
Un ensemble (set) est une collection d’éléments non ordonnés, où chaque élément est unique et
immuable. Rappelons qu’un objet immuable est un objet qui ne peut pas être modifié après sa
création.
Il s’en suit qu’un élément appartenant à un ensemble peut être simple (float, int, bool), une chaine
(str) ou encore un tuple, mais il ne peut être ni une liste ni un dictionnaire, ni même un autre
ensemble, étant donné qu’un ensemble en lui-même est mutable (c’est-à-dire non immuable) : il
peut être modifié en ajoutant ou en supprimant des éléments.
Les accolades { et } sont utilisés pour les ensembles. La fonction len(s) retourne la taille (nombre
d’éléments) de l’ensemble s. Voici quelques exemples :
fruits = {"pomme", "orange", "poire", "melon"} Exemple d’affichage obtenu :
s = {"chat", (1,2) , "coucou"} {'melon', 'pomme', 'orange', 'poire'}
print(fruits, "\ntaille :", len(fruits)) taille : 4
print(s, "\ntaille :", len(s)) {'coucou', (1, 2), 'chat'}
taille : 3
Il est à noter que l’ordre d’affichage des éléments de l’ensemble est aléatoire, il peut changer d’une
exécution à l’autre. Ceci provient du fait que l’ensemble est une collection non ordonnée, aucun
indice n’est défini pour les éléments.
NB. Les accolades étant aussi utilisés en Python pour les dictionnaires, la différence réside dans le fait
que les éléments d’un dictionnaire se présentent sous la forme de couples clé : valeur.
A. Unicité des éléments
Chaque élément d’un ensemble est unique (pas de doublons). En effet, un objet peut appartenir ou
ne pas appartenir à un ensemble, mais « appartenir à un ensemble n fois » n’a pas de sens. Voici un
exemple qui illustre ce point :
fruits = {"pomme", "orange", "poire", "melon", "pomme", "poire", "poire"}
print(fruits)
Exemple d’affichage obtenu : {'pomme', 'poire', 'melon', 'orange'}
Ainsi, même si en déclarant l’ensemble on inclut un élément plusieurs fois, une seule instance de cet
élément sera gardée.
Il est à noter que 1 et True sont considérés somme une même valeur, et que 0 et False sont
considérés comme une même valeur (ceci est aussi vrai pour les clés d’un dictionnaire). Ceci veut
dire qu’en ne peut pas avoir un ensemble qui contient 1 et True en même temps, ni 0 et False en
même temps. Voici des exemples :
s={1, 2, True} Exemple d’affichage obtenu :
print(s) {1, 2}
s={1, 2, False} {False, 1, 2}
print(s) {False, 2}
s={False, 2, 0}
print(s)
B. Immuabilité des éléments
Comme précisé précédemment, les éléments d’un ensemble doivent être immuables. Les listes, les
dictionnaires et les ensembles sont alors interdits à l’intérieur d’un ensemble, et ce même s’ils sont

1
TI1 – Semestre 2
Préparation à la certification Python 2 Ahlem ELHAJ
imbriqués dans un tuple. Voici des exemples de déclarations dont certaines sont correctes et
d’autres sont erronées :
Déclaration Correcte ou erronée
S={(1,2), "Bonjour", True} Correcte (tous les éléments sont immuables)
S={[1,2], "Bonjour", True} Erreur (TypeError) à cause d’un élément mutable (liste)
S={{1,2}, "Bonjour", True} Erreur (TypeError) à cause d’un élément mutable (ensemble)
S={{1 :"a", 2 :"b"}, "Bonjour", True} Erreur (TypeError) à cause d’un élément mutable (dictionnaire)
S={((1,2),3), "Bonjour", True} Correcte (tous les éléments sont immuables)
S={([1,2],3), "Bonjour", True} Erreur (TypeError) à cause d’un élément mutable (tuple
contenant une liste)
Il est à noter qu’à la différence d’un tuple qui est immuable et peut contenir des éléments
quelconques (immuables ou mutables), un ensemble (set) est, lui, mutable mais ne peut contenir que
des éléments immuables.
C. Accès aux éléments
Etant donné qu’il n’existe ni la notion d’indice ni celle de clé sur un ensemble, il n’est pas possible de
faire un accès à un élément particulier d’un ensemble de façon individuelle. L’absence d’un index
rend aussi impossible le découpage (slicing) d’un ensemble.
Cependant, il reste toujours possible de parcourir un ensemble en utilisant une boucle for :
S={1,2,3,4,5} Affichage obtenu :
for elem in S : 12345
print(elem, end=" ")
Il est aussi possible de tester l’appartenance d’un élément à un ensemble en utilisant les opérateurs
in et not in.
II. La fonction set()
Afin de déclarer un ensemble vide, si on procède de la sorte : s={} on obtiendra plutôt un dictionnaire
vide et non un ensemble. Il faut plutôt faire appel à la fonction set() : s=set()
NB. Remarquez la différence entre l’affichage d’un ensemble vide et un dictionnaire vide :
d={} Affichage obtenu :
print(d) {}
s=set() set()
print(s)
La fonction set() permet par ailleurs de créer un ensemble à partir d’un itérable passé en argument.
NB. On appelle itérable tout objet qu’on peut parcourir en utilisant une boucle for (for elem in
iterable). Ainsi, une liste, un tuple, une chaine, un dictionnaire, un ensemble et le résultat de range()
sont des itérables.
La fonction set() construit alors l’ensemble en lui ajoutant les éléments de l’itérable passé en
argument, en enlevant bien sûr les doublons s’il y en a.
Voici un exemple :
S=set(["Fraise","Melon","Pomme","Pomme"]) Exemple d’affichage obtenu :
print(S) {'Pomme', 'Fraise', 'Melon'}
S=set(("Fraise","Melon","Pomme","Pomme")) {'Pomme', 'Fraise', 'Melon'}
print(S) {'l', 'a', 'e', 'g', 'n'}
S=set("blabla") {0, 1, 2, 3, 4}
print(S) {1, 2}
S=range(5)
print(S)
S=set({1 :"a", 2 :"b"})
print(S)

2
TI1 – Semestre 2
Préparation à la certification Python 2 Ahlem ELHAJ
Notez dans cet exemple que si on passe un dictionnaire à la fonction set, ce sont les clés du
dictionnaire qui sont prises en compte pour construire l’ensemble (rappelons qu’une clé de
dictionnaire est déjà immuable).
Attention par contre lors de l’appel à set() en lui passant une itérable liste, tuple ou ensemble : tous
les éléments de l’itérable doivent être immuables. Voici des exemples d’appels corrects et d’autres
incorrects (TypeError) :
Appels corrects à set() Appels incorrects à set() ➔ TypeError
S=set( [1,2,3] ) S=set( [1, [2,3] ] )
S=set( (1,2,3) ) S=set( (1, [2,3] ) )
S=set( {1,2,3} ) S=set( [1, ( [2,3] ) ] )
S=set( [1,(2,3) ] ) S=set( {1,[2,3]} )
S=set( (1,(2,3) ) ) S=set( {1, {2,3} } )
S=set( {1,(2,3)} )
III. Manipulation des ensembles
A. Méthodes pour ajout, suppression et copie
Le tableau suivant énumère les méthodes utilisées pour ajouter ou supprimer des éléments à un
ensemble.
Méthode Description
s.add(elem) Permet d’ajouter elem à l’ensemble s. elem doit être immuable.
s.update(iterable) Permet de mettre à jour l’ensemble s en lui ajoutant tous les éléments de l’itérable
passé en argument (avec élimination des doublons). Tout élément de l’itérable doit
être immuable.
s.discard(elem) Permettent de supprimer l’élément elem de s
s.remove(elem) La différence entre remove() et discard() réside dans leur comportement dans le
cas où elem ne fait pas partie de s : remove() génère une erreur d’exécution alors
que discard() ne fait rien (pas d’erreur, ordre de suppression ignoré)
s.clear() Permet de vider s de tout son contenu (il devient un ensemble vide)
s.copy() Permet d’obtenir une copie superficielle de s
Ainsi, S2=S1.copy() a pour résultat de copier S1 dans S2 : les deux ensembles ont
alors le même contenu mais sont indépendants l’un de l’autres (il ne s’agit pas
d’un même ensemble dans la mémoire)
B. Méthodes et opérateurs pour générer un ensemble à partir d’autres
Opérateur Méthode Ensemble résultant
S1 & S2 S1.intersection(S2) L’intersection des ensembles en entrée : tout
S1 & S2 & S3 … S1.intersection(S2, S3, …) élément appartenant à S1 et à S2 et à S3 …
S1 | S2 S1.union(S2) L’union des ensembles en entrée : tout élément
S1 | S2 | S3 … S1.union(S2, S3, …) appartenant à S1 ou à S2 ou à S3 …
S1 – S2 S1.difference(S2) La différence entre S1 et S2 : tout élément
S1 – S2 – S3 … S1.difference(S2, S3, …) appartenant à S1 mais pas à S2. Cela donne avec
plusieurs ensembles (S1 - S2 - S3 …) : tout élément
de S1 n’appartenant ni à S2, ni à S3 …
S1 ^ S2 S1.symmetric_difference(S2) Différence symétrique : contient tout élément
S1 ^ S2 ^ S3 … Prend exactement un seul argument appartenant à S1 ou à S2 mais pas les deux à la fois
Ceci donne pour plusieurs ensembles (S1, S2, S3 …)
: tout élément qui appartient à l’un des ensembles
en entrée et n’appartenant à aucun des autres
ensembles.

3
TI1 – Semestre 2
Préparation à la certification Python 2 Ahlem ELHAJ
Remarques importantes :

• L’intersection, l’union et la différence symétrique sont des opérations commutatives : en

changeant l’ordre des opérandes, on obtient le même résultat. Par exemple, S1 & S2 donne
le même résultat que S2 & S1.
• La différence n’est pas commutative : S1 – S2 donne un résultat différent de S2 – S1.
• Les opérateurs doivent être utilisés uniquement entre des ensembles, alors que les
méthodes acceptent des arguments qui sont des itérables (liste, chaine …). Par exemple :
Avec l’opérateur & :
print(set("abc") & set("cbf")) affiche : {'c', 'b'}
print(set("abc") & "cbf") cause une erreur (TypeError: impossible d’utiliser & entre 'set' et 'str')
Avec la méthode intersection() :
print(set("abc").intersection(set("cbf"))) affiche : {'c', 'b'}
print(set("abc").intersection("cbf")) affiche aussi le même ensemble : {'c', 'b'}
C. Méthodes et opérateurs relationnels entre les ensembles
Opérateur Méthode Résultat obtenu
S1 == S2 Retourne True si S1 et S2 sont égaux (ont le même contenu),
False sinon
S1 != S2 Retourne True si S1 et S2 n’ont pas le même contenu, False sinon
S1 <= S2 S1.issubset(S2) Retourne True si S1 est inclus dans S2, False sinon
S1 est inclus dans S2 si et seulement si tout élément de S1
appartient à S2 (c’est-à-dire que S1 est un sous-ensemble de S2)
S1 >= S2 S1.issuperset(S2) Retourne True si S2 est inclus dans S1, False sinon
➔ c’est-à-dire vérifie si S1 est un sur-ensemble de S2
S 1 < S2 Teste si S1 est strictement inclus dans S2
Equivalent à (S1 <= S2 and S1 != S2)
S 1 > S2 Teste si S2 est strictement inclus dans S1
Equivalent à (S1 >= S2 and S1 != S2)
S1.isdisjoint(S2) Retourne True si S1 et S2 sont disjoints, False sinon
Deux ensembles sont disjoints s’ils n’ont aucun élément en
commun (c’est-à-dire leur intersection est vide)
Remarques importantes :
• Dans ce tableau, les opérations <= , >=, < et > ne sont pas commutatives (les autres le sont)
• Comme mentionné dans le paragraphe précédent, les opérateurs doivent être utilisés
uniquement entre des ensembles, alors que les méthodes acceptent des arguments qui sont
des itérables (liste, chaine …).
• Il n’existe pas de relation d’ordre total entre les ensembles, autrement dit nous pouvons
avoir deux ensembles qui, en les comparant avec les trois opérateurs <, > et == on obtient
False comme dans ce cas :
S1={1,2,3,4,5} Résultat obtenu :
S2={6,7} False False False
print(S1>S2, S1<S2, S1==S2)