01/10/2024

Programmation sous Python

Plan

• Généralité
• Les Collections
• Les Fonctions et exceptions
• Les modules et package python
• Les Fenêtres graphiques
• Le Graphisme
• Les Fichiers
• Programmation Orienté Objet en python

1
 01/10/2024

Compilation et Interprétation
- Langage interprété :

Ce que nous écrirons …

traduction/exécution ligne par ligne.

- Langage compilé :

traduit la totalité du texte

3
source en une fois Avantages ?

Python (interprété)
Certains langages modernes tentent de combiner
les deux techniques afin de garder le meilleur de chacune.
.py .pyc

très facile à interpréter

portable
Avantages:
open-source, multi–plateformes, écrit en C.
puissant et simple à utiliser, exprime des tâches complexes en
utilisant seulement quelques lignes de code.
polyvalent :
- logiciels bureautiques
- applications web
- Calculs scientifiques et numériques complexes 4

2
 01/10/2024

Installation python/windows
1 – Télécharger l’installateur Python directement depuis le site
[Link]. La dernière version le jour d’écriture des slides est :
[Link]

2- Lancer le programme d’installation et cocher « add to path »

C:\> python -V
Python 3.x.z

Installation python/Linux

Sous linux python est préinstallé par défaut. Vérifier votre

version, si c’est pas la version 3 :
$ python --version
Python 2.7.9

Installé par :
# sudo apt-get install python3
# sudo dnf install python3

Sous windows/Linux
#pip install pandas

3
 01/10/2024

IDE python gratuit

Conventions générales
• Un programme en python est nommé nom_prog.py
• Une instruction par ligne
• Un programme python doit être identé

• Un commentaire mono-ligne commence par # (au début de

la ligne ou à la fin de code)

• Un commentaire multi-lignes doit commencer et se terminer

par trois guillemets """

• Langage non déclaratif

• Pas de ++ et -- pour incrémenter/décrémenter. Python

incrémente x de 1 par x += 1 ou x = x + 1 .
8

4
 01/10/2024

l‘Indentation
• L'indentation en python n'est pas seulement esthétique mais obligatoire
• Chaque niveau d'indentation représente un nouveau bloc de code.
• Un blocs de code est construit pour les boucles, les conditions, les
fonctions et les classes.
• Il est recommandé d’utiliser quatre espaces pour l'indentation. Sinon
un minimum d'un espace est obligatoire.
• La première ligne de code Python ne peut pas être indentée.
• Ne pas mélanger les tabulations et les espaces pour l'indentation

variables

• En Python, il n’est pas nécessaire de déclarer le type de

variables mais il ne faut pas utiliser une variable à laquelle on a
affecté aucune valeur :
>>> ecole="ensa"
>>> annee=2024
>>> annee=annee+1
>>> jour=jour-1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'jour' is not defined

Pour forcer la déclaration d’une variable :

nomvar : type = val
[bool, int, float, str]
10
Ex: message : str = "Hello World"

5
 01/10/2024

Saisie (input)

x = input("saisir la valeur de x : ")

ATTENTION : la variable lue est toujours de type str. Pour la

convertir en nombre, il faut utiliser la fonction int()ou la
fonction float() :

x = int(input("saisir la valeur de x : "))

11

Affichage (print)
print("nom=",nom, end="")
print("nom=%s \n\t age=%d \n\t note=%f" %(n,a,t))
String Format(): crée variable dynamique par placeholder {}
quantite = 3
article = "ImprimanteHP"
prix = 1800
1 - Nommage
print(“Article {a} coûte {p} dirhams".format(p=prix, a= article))
2- Indexation
cmd=“je commande {2} article {0} pour {1} dirhams"
print([Link](article,prix,quantite))

3- Positionnement
cmd = "je commande{} articles {} pour {:.2f} dirhams."
print([Link](quantite, article, prix))
12

6
 01/10/2024

f-string

f"…{}……"

Les espaces réservés {} peuvent contenir des variables, des

modificateurs, des fonctions et des opérations pour formater
une chaîne.

- Variables:
prix= 59
txt = f“le prix est {prix} dirhams“

f-string

- Modificateur:
Un modificateur est inclus en ajoutant deux points :
suivis d'un type de formatage, comme :
.2f, <,>,b,o,d,h….

prix = 20.123
print(f“{prix:.2f}“)  20.12
print(f'{prix:>8}')  20.123
print(f'{prix :->8}')  --20.123
print(f'{prix :-<8}')  20.123--
print(f'{prix:->15.8f}') ----20.12300000

7
 01/10/2024

f-string

Opérations: calcul ou test

prix = 59
tax = 0.25
txt = f“Le prix est {prix + (prix * tax)} dirhams"
txt = f“Cet artile est {'Chere' if prix>50 else ' Pas chere'}“

Fonctions :
txt = f“La surface est {sqrt(2) * my_fct(30)} mètre au
carré”

test

8
 01/10/2024

range(start, stop, step)

range(5,50,10)

range(10,1,-2)

boucle for for variable in séquence:

9
 01/10/2024

boucle while

Exécution tant qu’une condition est vérifiée. Ecrire un code pour

afficher ceci :

row = 1
while row <= 5:
*
col = 1
**
*** while col <= row:
**** print('*',end='')
****** col += 1
print('')
row +=1

break

Sortie immédiate du bloc for ou while en cours.

Exemple : recherche d'une valeur 9.0 dans une liste

lstvaleurs = [12.3,9.3,18.7,8.1,4.2]
trouve = False
for val in lstvaleurs:
if val == 9.0:
trouve = True
break # Pas la peine de continuer.
if trouve:
print("La valeur est présente")

10
 01/10/2024

Les collections python

1- Tableau array
2- Liste list Séquences
Liste non
modifiable 3-Tuple tuple Ordonnées
index
4- Chaîne string
Ordonné
5- Dictionnaire dict par clé

Sans doublon Pas d’ordre

Ajout (add) 6- Ensemble set sac d’objet

Les tableaux

11
 01/10/2024

tableau

Le tableau ne peut contenir qu'un seul type d'élément. Il est de

longueurs variables. Un tableau est créer par la fonction array()
[Link]()
2 modules
[Link]()

module array

i : int
f : float
d : doule
u : caractère

Exemple(array)

import array as arr

T1 = [Link]('i')
[Link](1)
[Link](2)
[Link] ( [ 30 , 40,30 ])
print([Link](30))
print(T1)
Sortie : 2
array(‘i’, [1, 2,30,40,30])

import array as arr

T1= [Link]('d', [1.0, 1.1, 1.2, 1.3,’ensa’])
print(tableau)
# tous les méthodes de list sont disponibles
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: must be real number, not str

12
 01/10/2024

Module numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A) marice 2x4 de 1 : [[1 1 1 1]
[1 1 1 1]]

Numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A) marice 3x3 de 0 : [[0 0 0]
[0 0 0]
[0 0 0]]

13
 01/10/2024

Numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A) marice identité 3x3 : [[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]

Numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A) marice 3x3 de rand :
[[0.73027733 0.11816261 0.12234324]
[0.08726113 0.52372866 0.18307537]
[0.12085452 0.01354457 0.71866588]]

14
 01/10/2024

Numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
3
print("après redimensionnement de A: ", A) -9
6
0.3333333333333333

numpy
import numpy as np
print("marice 2x4 de 1 : ", [Link]((2,4),dtype=int)) #float par défaut
print("marice 3x3 de 0 : ", [Link]((3,3),dtype=int)) #float par défaut
print("marice identité 3x3 : ", [Link](3,3))
print("marice 3x3 de rand : ", [Link](3, 3)) # entre 0 et 1
A=[Link]([ [2,2,-3], [-2,-1,-9], [6,4,4]])
print([Link](A))
print([Link](A))
print([Link](A))
print([Link](A))
print("A est une matrice de taille :", [Link](A))
print("A est une matrice de dimension :", [Link](A))
[Link]=(1,9)
print("après redimensionnement de A: ", A)
A est une matrice de taille : 9
A est une matrice de dimension : (3, 3)
après redimensionnement de A:
[[ 2 2 -3 -2 -1 -9 6 4 4]]

15
 01/10/2024

array vs numpy
import numpy as np
import array as arr

T1= [Link]('i',[1, 2, 3])

T2 = [Link]('i',[4,5,6]) array('i', [1, 2, 3, 4, 5, 6])
print(T1+T2) array('i', [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6])
print(4*T2)

Tab1 = [Link]([1, 2, 3])

Tab2 = [Link]([4,5,6]) [5 7 9]
print(Tab1+Tab2) [16 20 24]
print(4*Tab2)

array/numpy
import numpy as np
import array as arr

T1= [Link]('i',[1, 2, 3])

T2 = [Link]('i',[4,5,6]) array('i', [1, 2, 3, 4, 5, 6])
print(T1+T2) array('i', [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6])
print(4*T2)

Tab1 = [Link]([1, 2, 3])

Tab2 = [Link]([4,5,6]) [5 7 9]
print(Tab1+Tab2) [16 20 24]
print(4*Tab2)

T3=[Link]([6,8,0,'ensa'])
print(T3) ['6' '8' '0' 'ensa']

16
 01/10/2024

Produit matriciel
import numpy as np
# produit, somme, transposé ...
m1 = [Link]([ [1, 2, 3], [4, 5, 6] ])
m2 = [Link]([ [2, 1, 3], [3, 2, 1] ])
m3 = [Link]([ [4],[2],[1] ])

Taille de m1= 6 de m3= 3

print("taille de m1=",[Link](m1)," de m3=",
[Link](m3))
m1*m2= [[ 2 2 9]
[12 10 6]]
print("m1*m2= ",m1*m2)
[Link](m1,m3)= [[11]
print("[Link](m1,m3)= ",[Link](m1,m3)) [32]]
print("m1@m3=", m1@m3) # python 3.5 m1@m3= [[11]
[32]]
print("transposé de m1=",m1.T) transposé de m1= [[1 4]
[2 5]
[3 6]]

[Link] (Algèbre Linéaire)

m1=[Link]([[2, 1, 3], [3, 2, 1],[4, 2, 1]])
print("det(m1)= " , [Link](m1))
print("inv(m1)= " , [Link](m1))
det(m1)= -5.000000000000001
inv(m1)= [[ 0. -1. 1. ]
[-0.2 2. -1.4]
[ 0.4 0. -0.2]]

A = [Link]([[3,1], [1,2]])
B = [Link]([9,8])
print("solution du système AX=B est : ",[Link](A, B))
solution du système AX=B est : [2. 3.]

17
 01/10/2024

Les Listes

List

18
 01/10/2024

liste (fonction utiles)

liste (fonction utiles)

19
 01/10/2024

liste (fonction utiles)

liste (fonction utiles)

20
 01/10/2024

liste (fonction utiles)

min, max et filter

lst = [15, 9, 55, 41, 35, 20, 62, 49]

print(min(lst),max(lst),sum(lst))

e=filter(lambda x: x % 2 == 0, lst)
print (list(e))
Output : 9 62 286
[20, 62]
Syntaxe : filter(fonction, séquence)
retourne <filter object > qui est un itérable. Nous pouvons utiliser une
fonction comme list() pour créer une liste de tous les éléments renvoyés.

Boucle sur liste

liste = [ ['ensa', 'agadir', '2024'] , ['Cours', 'python', 'version3'] ]

for i in liste :
for j in i :
print(j)

ensa
agadir
2024
Cours
python
version3

21
 01/10/2024

Construction à partir d’une suite

Exemple

Construction à partir d’autres listes

liste=[………]
Listes existantes

Sélection/calcul
sur chaque élément

1ère approche res = [ …………]

Nouvelle liste
liste=[………]
res = [ ]
for elt in liste:
if condition(elt) :
[Link](calcul(elt))

Construction de nouvelle liste des carrés des valeurs impairs :

lst1 = [1,6,9,2,7,4,12,11,21,4]
lst2 = [ ]
for v in lst1:
if v%2==1 :
[Link](v**2)

22
 01/10/2024

Construction à partir d’autres listes

2ème approche
res=[ expression]

res = [ calcul(v) for v in liste if condition(v) ]

Nous pouvons enchaîner les niveaux de boucles...

res = [ calcul(v1,v2) for v1 in liste1 for v2 in Liste2 if condition(v1,V2) ]

Exemple 1

# carrés des nombres de lst1

lst1 = [1,6,9,2,7,4,12,11,21,4]
lst2 = []
for v in lst1:
[Link](v**2)
lst2 = [ v**2 for v in lst1 ]

# carrés des nombres impairs de lst1

lst1 = [1,6,9,2,7,4,12,11,21,4]
lst2 = []
for v in lst1:
if v%2==1:
[Link](v**2)
lst2 = [ v**2 for v in lst1 if v%2==1 ]

23
 01/10/2024

Exemple2

Exemple : produits xy avec x et y de 1 à 4 et x≠y

 Approche 1 : append()
res = []
for x in range(1,5):
for y in range(1,5):
if x!=y:
[Link](x*y)

[2, 3, 4, 2, 6, 8, 3, 6, 12, 4, 8, 12]

 Approche 2: expression

res = [x*y for x in range(1,5) for y in range(1,5) if x!=y]

[2, 3, 4, 2, 6, 8, 3, 6, 12, 4, 8, 12]

Fonction sur liste construite

Calcul de l’ordonnée max d’une liste de points

lstpoints =[(1,3),(9,2),(7,7),(8,4),(6,11),(3,9)]

max( [ pt[1] for pt in lstpoints ] )

Somme des cubes des 20 premiers nombres multiples de 7:

sum( [ x**3 for x in range(7,7*20+1,7)] )

24
 01/10/2024

Tableau vs Liste
Tableau Liste
Besoin d'importer numpy Structure de données intégrée.

Pas d'éléments de types Ok pour éléments de différents

différents. types.
Il faut avoir la même taille de Une imbrication de taille variable
tableau pour l'imbrication. est possible.

peut appliquer des opérations Impossible d'appliquer des

arithmétiques. opérations arithmétiques directes.

Il consomme comparativement Cela consomme plus de mémoire.

moins de mémoire.

string
Les chaînes sont cas particulier des listes (listes de caractères). Une liste
peuvent avoir n'importe quel type

25
 01/10/2024

String
-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
[index]
0 1 2 3 4 5 6 7 8 9 10

(11 éléments)
EnsaAgadir
Slice : [début:fin] [début:fin:pas]
s = "EnsaAgadir"
s[4] "A" s[6:9] "adi" s[::2] "EsAai"
s[:3] "Ens" s[7:] "dir" s[::-1] "ridagAasnE"

mess = "bonjour Le Monde"

print ( "jour" in mess ) # return true or false
if "hour" not in mess:
print("not in")

tuple

Le tuple Python est l’implémentation en lecture seule de la liste :

collection ordonnée non modifiables d’éléments hétérogènes.

Le tuple possède les mêmes méthodes que la liste, à l’exception

de celles permettant une modification.

Les éléments du tuple doivent être emballés entre parenthèses et

délimités par des virgules :
(elem1,elem2, elem3...)
Pour accéder aux éléments du tuple on spécifie les indices
entre crochets [ ] (comme pour les listes)

26
 01/10/2024

Modifier un tuple ???

Pour changer les valeurs d’un tuple, convertir le tuple

en list et après reconvertir la liste en tuple:

x =("ensa", "esta", "encg")

y = list(x)
y [2] = "fsa"
x = tuple (y)
print(x)

Sortie : x=("ensa", "esta", "fsa")

dictionnaire
Le dictionnaire , de type dict en Python associe des valeurs à
des clés.

C'est un type de conteneur comme les list et les tuple mais ce

n'est pas une séquence. Au sens où ses valeurs ne sont pas
indexées.

Les clés peuvent être de type : str, int, float, tuple mais pas
une liste : une liste objet mutable, ne peut pas être une clé de
dictionnaire.

Les valeurs du dictionnaire peuvent être de n'importe quel

type.

À partir d’une clé, on peut alors accéder directement à la valeur

qui lui est associée.

27
 01/10/2024

dictionnaire

On utilise les accolades { } pour définir les éléments du

dictionnaire, c’est-à-dire les paires clé: valeur .

{clé1:valeur1, clé2:valeur2,....}

L’accès à une valeur du dictionnaire s’effectue en lui passant

entre
. crochets [ ] la clé correspondante.

Les dictionnaires n’étant pas ordonnés (non indicés par des entiers
mais par des clés), la technique du slicing n’est pas applicable

dictionnaire
Les méthodes .keys(), .values() et .items() retournent les séquences
des clés, les valeurs et les paires (clés,valeurs) utiles pour les
boucles.

jours={1:"lundi",2:"mardi",3:"mercredi",4:"jeudi",5:"vendredi",6:"samedi",7:"dimanche"}
print ([Link]())
print ([Link]())
print ([Link]())

dict_items([(1, 'lundi'), (2, 'mardi'), (3, 'mercredi'), (4, 'jeudi'), (5, 'vendredi'), (6, 'samedi'), (7, 'dimanche')])

dict_keys([1, 2, 3, 4, 5, 6, 7])

dict_values(['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])

28
 01/10/2024

dictionnaire

Pour ajouter un couple de (clé,valeur) il suffit d'écrire :

d[nouvelle_clef]=nouvelle_valeur

Pour recopier les données d’un dictionnaire dic1 ou d’une

listes:

- on ne fera pas dic2=dic1

(les 2 variables se référant dans ce cas au même objet)!!!

- mais une copie récursive (dans toute la profondeur du

dictionnaire) avec : dic2 = [Link]().
- Ou bien : dic2=[Link](dic1) [nécessitant
l’importation du module copy]

Exemple

jours={1:"lundi",2:"mardi",3:"mercredi",4:"jeudi",5:"vendredi",6:"samedi",
7:"dimanche"}
days=jours
days[2]="monday"
print ([Link]())
print ([Link]())
dict_values(['lundi', 'monday', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])
dict_values(['lundi', 'monday', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])

import copy
jours={1:"lundi",2:"mardi",3:"mercredi",4:"jeudi",5:"vendredi",6:"samedi",
7:"dimanche"}
days=[Link](jours) # ou days=[Link]() [sans import]
days[2]="monday"
print ([Link]())
print ([Link]())
dict_values(['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])
dict_values(['lundi', 'monday', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche'])

29
 01/10/2024

Exercice
On considère le dictionnaire suivant dont les clés sont les noms des élèves et les valeurs
des clés sont les moyennes générales :

etudiants = {"etudiant_1" : 13 , "etudiant_2" : 17 , "etudiant_3" : 9 , "etudiant_4" : 15 ,

"etudiant_5" : 8 , "etudiant_6" : 14 , "etudiant_7" : 16 , "etudiant_8" : 12 ,
"etudiant_9" : 13 , "etudiant_10" : 15 , "etudiant_11" : 14 , "etudiant_112" : 9 ,
"etudiant_13" : 10 , "etudiant_14" : 12 , "etudiant_15" : 13 , "etudiant_16" : 7 ,
"etudiant_17" : 12 , "etudiant_18" : 15 , "etudiant_19" : 9 , "etudiant_20" : 17}

Ecrire un programme Python qui partitionne ce dictionnaire en deux sous dictionnaires:

etudiantAdmis dont les clés sont les étudiants admis et les moyennes obtenues
(moyenne supérieurs ou égales à 10 ).

etudiantNonAdmis dont les clés sont les étudiants non admis et les moyennes obtenues
(moyenne inférieur ou égale à 10).

correction
etudiants = {"etudiant_1" : 13 , "etudiant_2" : 17 , "etudiant_3" : 9 , "etudiant_4" : 15 ,
"etudiant_5" : 8 , "etudiant_6" : 14 , "etudiant_7" : 16 , "etudiant_8" : 12 ,
"etudiant_9" : 13 , "etudiant_10" : 15 , "etudiant_11" : 14 , "etudiant_112" : 9 ,
"etudiant_13" : 10 , "etudiant_14" : 12 , "etudiant_15" : 13 , "etudiant_16" : 7 ,
"etudiant_17" : 12 , "etudiant_18" : 15 , "etudiant_19" : 9 , "etudiant_20" : 17}

Admis = dict({})
Ajournes = dict({})

for key , valeur in [Link]():

if(valeur < 10):
Ajournes[key] = valeur
else:
Admis[key] = valeur

print("Les etudiants admis : " , Admis)

print("Les etudiants non admis : " , Ajournes)

30
 01/10/2024

set

set est une collection non ordonnée, ittérable, mutable (méthode add() et
pas append()) et ne comporte aucun doublant.

L’intérêt de set réside dans le fait qu’on peut appliquer à ces objets des
opérations propres aux ensembles (union, intersection, différence…), d’où
le nom de sets (ensembles).

Ce ne sont pas des séquences (les éléments ne sont pas ordonnés, donc non
accessibles par des indices entiers), mais ils supportent l’itération (l’ordre
n’étant cependant pas significatif).

On crée un set avec la fonction set(iterable) ou en énumérant les

éléments entre accolades {elem1, elem2, elem3...}.

Pour réellement copier les données d’un set s1, on ne fera pas s2=s1
(les 2 variables pointant dans ce cas sur le même objet),
mais s2=[Link]() ou s2=set(s1)

set
[Link](B) : Renvoie un set contenant tous les éléments des deux
ensembles, les doublons sont exclus : opérateur |
[Link](B) : Revoie l’intersection: opérateur &
[Link](B) : crée un set avec tous les éléments uniquement compris
dans A mais pas dans B : opérateur -
A.symmetric_difference(B) : différence symétrique entre deux ensembles A
et B. Inclut tous les éléments de A et B sans les éléments communs.
Opérateur ^
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z={"apple"}
r = [Link](y,z) # t= x | y | z
s=[Link](y,z) # s= x & y & z
t=[Link](y,z) # t= x-y-z
p=x.symmetric_difference(y) # p= x ^ y

r {'banana', 'microsoft', 'apple', 'google', 'cherry'}

S {'apple'}
t {'banana', 'cherry'}
P {'banana', 'microsoft', 'cherry', 'google'}

31
 01/10/2024

Comparaison

LIST TUPLE DICTIONNAIRE SET

Autorise les Autorise les Pas de doublons Pas de doublons

doublons doublons

modifiable Pas modifiable modifiable Pas modifiable

juste ajout

ordonnée ordonnée Non ordonnée Non ordonnée

[] () {} {}

32