Ecole Supérieure de Gestion, d’Informatique et des Sciences

INTRODUCTION À PYTHON
L3 IRT (SCRIPTS PYTHON)

Dr. Béthel ATOHOUN

MAI 2024
 OBJECTIFS DU COURS
❑ Comprendre les principes de base de la programmation Python
❑ Maîtriser les structures de contrôle
❑ Manipuler différents types de données en Python
❑ Manipuler les fichiers et y extraire des données
❑ Maitriser les bases de la POO en Python
 ENSEIGNEMENT
PLAN DU COURS
1- Les Variables et opérateurs
2- Les Types de données en Python
3- Les entrées/Sorties
4- Les structures de Contrôle
5- Les Séquences
6- Les Modules et les Fonctions
7- Manipuler les fichiers en Python
8- La programmation orientée objet en Python
 ENSEIGNEMENT
DÉROULEMENT DE L’ENSEIGNEMENT
Cours magistral par projection de diapositives
Séances de travaux pratiques individuels ou en groupe
Séances de discussion
 ENSEIGNEMENT
MODE D’ÉVALUATION
Travaux à rendre en ligne mains en différé
Travaux à rentre en ligne et en live
Correction par les paires
 POURQUOI PYTHON
❑ Python est à la fois simple et puissant
❑ Python dispose de nombreuses bibliothèques pour faire simplement des
projets assez complexes
❑ Python est un langage très portable d’une plateforme à une autre
❑ Python a une syntaxe simple, concise et très lisible
❑ Python est le langage le plus utilisé aujourd’hui dans divers domaines
❑ Python dispose d’une très large communauté et support actif
 INFORMATION DE BASE
❑ Python est un langage de programmation interprété
❑ Python est sensible à la casse

❑ Pour installer Python

❖ Sous Linux : faire sudo apt install python3 ou sudo apt-get install python3
Il peut être nécessaire de faire au préalable la commande sudo apt update
❖ Sous Windows : Télécharger la dernière version de Python depuis le lien [Link]/downloads/
suivre les instructions d’installation en prenant la précaution d’ajouter Python au PATH
❑ Pour vérifier l’installation de Python
❑ Il faut taper les commandes respectives sous Windows et sous Linux :
❖ python --version (sous Windows) et python3 --version (sous Linux)
 ENVIRONNEMENT DE DÉVELOPPEMENT
❑ Terminal
❑ IDE
❖ Idle
❖ Pycharm
❖ Thonny
❖ Eclipse
❖ Visual Studio Code
❖ Anakonda

❑ Platformes d’exécution de script Python

❖ Brython : [Link]
❖ python tutor : [Link]
 CONCEPTS DE BASE
LES COMMENTAIRES
Commentaire d’une ligne ou de la fin d’une ligne
❑ On utilise le caractère #

Commenter un bloc de ligne

❑ On utilise trois apostrophes ou double quottes au début et à la fin
 CONCEPTS DE BASE
LES VARIABLES
La syntaxe de création d’une variable est la suivante
nom_de_variable = valeur
nom_de_variable est un identificateur. Donc, alphanumérique mais pas de chiffre au début. Le caractère
sous-tiret (_) est admis aussi.
Exemples

Affichage de la valeur d’une variable

▪ En tapant directement le nom de la variable dans le prompt de Python
▪ A l’aide de la fonction print (On y reviendra)
 CONCEPTS DE BASE
LES OPÉRATEURS
Les opérateurs arithmétiques
+ L’addition
- La soustraction
* La multiplication
/ La division réelle (c’est-à-dire dont le résultat est du type float)
// La division entière tronquée
** L’exponentiation (appelée également puisance
% Le modulo
 CONCEPTS DE BASE
LES OPÉRATEURS Les opérateurs de comparaison
== égal à
> Supérieur à
>= Supérieur ou égal à
< Inférieur à
<= Inférieur ou égal à
!= Différent de

Les opérateurs logiques

and Et logique
or OU logique
not Non logique
 CONCEPTS DE BASE
LES OPÉRATEURS
Les opérateurs associatifs d’affectation
*= Multiplie une valeur par une autre
+= Incrémente une valeur par une autre
-= Décrémente une valeur par une autre
/= Divise une valeur par une autre

Les opérateurs d’appartenance

in Vérifie l’existence d’une valeur au sein d’une séquence d’objets
not in La valeur n’existe pas au sein de la séquence d’objets
 CONCEPTS DE BASE
QUELQUES OPÉRATIONS DEPUIS UN TERMINAL

Addition Division
>>> 8+5 >>> 100/4
13 25.0

Soustraction Modulo
>>> 1-10 >>> 10%4
-9 2

Multiplication Exposant
>>> 2*10 >>> 2**3
20 8
 CONCEPTS DE BASE
QUELQUES OPÉRATIONS DEPUIS UN TERMINAL

Affectations multiples >>> a = b = 15

>>> a
15
>>> b
15
Affectations parallèles >>> a, b = 6, 12.5
>>> a
6
>>> b
12.5
Permutation >>> a, b = b,a
 CONCEPTS DE BASE
LES TYPES
Les types de données représentent les différents types de valeurs que les variables peuvent prendre.
En Python, le typage est dynamique : c’est-à-dire que le type n'est pas lié à la variable qui référence
l'objet mais est lié a l'objet. La variable peut changer de type durant l'exécution d'un programme
❑ Entier (int) : Représente les nombres entiers sans décimales. Par exemple : 10, -5, 0.
❑ Flottant (float) : Représente les nombres décimaux. Par exemple : 3.14, -2.5, 0.0.
❑ Chaîne de caractères (str) : Représente une séquence de caractères encadrée par des guillemets
simples ('') ou des guillemets doubles (""). Par exemple : "Bonjour", 'Python', "42".
❑ Booléen (bool) : Représente une valeur de vérité, soit True (vrai) ou False (faux). Il est utilisé pour les
opérations logiques et de contrôle de flux.
 CONCEPTS DE BASE
LES TYPES
❑ Liste (list) : Représente une collection ordonnée et modifiable d'éléments. Les éléments
peuvent être de différents types. Par exemple : [1, 2, 3], ['a', 'b', 'c'], [1, "Python", True].
❑ Tuple (tuple) : Représente une collection ordonnée et immuable d'éléments. Les éléments
peuvent être de différents types. La principale différence avec les listes est que les tuples ne
peuvent pas être modifiés une fois créés. Par exemple : (1, 2, 3), ('a', 'b', 'c'), (1, "Python", True).
❑ Dictionnaire (dict) : Représente une collection non ordonnée de paires clé-valeur. Chaque
élément est associé à une clé unique qui permet d'accéder à sa valeur correspondante. Par
exemple : {'nom': 'John', 'âge': 30, 'ville': 'Paris’}.
❑ Ensemble (set) : Représente une collection non ordonnée d'éléments uniques. Il est utilisé pour
effectuer des opérations ensemblistes telles que l'union, l'intersection et la différence entre
ensembles. Par exemple : {1, 2, 3}, {'a', 'b', 'c'}.
 CONCEPTS DE BASE
LE TYPAGE DYNAMIQUE
Pour connaitre le type d'une variable, vous pouvez utiliser la fonction type()
La fonction id() est utilisée pour obtenir l'identifiant unique d'un objet. Cet identifiant est un nombre entier
qui représente l'emplacement mémoire de l'objet. Chaque objet en Python a un identifiant unique qui lui est
attribué lorsqu'il est créé, et cet identifiant ne change pas pendant la durée de vie de l'objet.

>>> A=15
>>> B=15
A et B pointent vers la même adresse mémoire et référence donc le même objet. La fonction id nous nous retourne l’adresse
mémoire
>>> print(id(A))
1475702384
>>> print(id(B))
1475702384
 CONCEPTS DE BASE
LES CHAINES DE CARACTÈRES
Une chaine de caractères est un ensemble de caractères entre de simples côtes ou entre doubles côtes.
>>> 'Bonjour'
>>>"c’est simple"
>>>'c\’est simple'
Concaténation : On utilise l’opérateur +
>>> "Ecole " + "de Télécommunication"
'Ecole de Télécommunication‘
Répétition : Il est possible de multiplier une chaine de caractère à l’aide de l’opérateur *
>>> "Etudiant"*3
'EtudiantEtudiantEtudiant'
 CONCEPTS DE BASE
LES CHAINES DE CARACTÈRES : MISE EN FORME (FORMATAGE)
❑ Les f-string : On utilise le caractère f ainsi que les accolades
>>> nom = 'Adjokè'
>>> f"Bonjour {nom}"
'Bonjour Adjokè'

>>>a = 5
>>>b = 10
>>>f"Le produit de {a} et de {b} est : {a * b}"

Nota : Ne sont utilisable qu’à partir de la version 3.6 de Python

 CONCEPTS DE BASE
LES CHAINES DE CARACTÈRES : MISE EN FORME (FORMATAGE)
❑ La méthode format : On utilise ici aussi les accolades mais on a recours à la méthode format qui
est une méthode applicable aux chaines de caractères.
>>> age = 26
>>> phrase = "J'ai {} ans".format(age)
>>> phrase
"J'ai 26 ans"

Voici d’autre variantes

>>> phrase = "J'ai {a} ans".format(a=age)
On peut aussi faire
>>> phrase = "J'ai {0} ans, et {0} ce n’est pas vieux".format(age)
 CONCEPTS DE BASE
LES CHAINES DE CARACTÈRES : MISE EN FORME (FORMATAGE)
❑ Le spécificateur de format : On utilise ici le % comme en C ou en PHP mais avec une autre façon de
faire le formatage.
Cette façon de faire est obsolète mais on continue de la retrouver dans de nombreux scripts Python.
>>> age = 26
>>>phrase= "J'ai %d ans."%age
>>> phrase
"J'ai 26 ans"

>>> age = 26
>>> nom = "Moussa"
>>> « Je suis %s et j'ai %d ans." %(nom, age)
>>> phrase
"Je suis Moussa et j'ai 26 ans"
 CONCEPTS DE BASE
LES ENTRÉES / SORTIES
Les entrées : input()
La fonction input permet d’afficher le prompt pour que l’utilisateur saisisse une donnée.
La fonctionne input retourne une chaine de caractères.
Pour obtenir des nombres en sortie, il faudra lui associer par exemple la fonction float() ou int()

>>> taille = int(input("Entrez votre taille s’il vous plait : "))

>>> Entrez votre taille s’il vous plait : 12
>>> 12

Les sorties : print()

L’instruction principale est print qui permet de rediriger le flux de données vers la sortie standard
(clavier).
 CONCEPTS DE BASE
Les chaines de caractères : méthodes
help : Lire l’aide sur le type str help(str)
dir : Lister les méthodes d’un objet dir(str)
split : découper une chaine en se basant sur un séparateur et 'ab-cd-ef-gh'.split('-')
donne en retour une liste ['ab' , 'cd', 'ef', 'gh']
join : transformer une liste en chaine de caractères avec un "-".join(['ab', 'cd', 'ef', 'gh'])
séparateur 'ab-cd-ef-gh'
replace : pour remplacer une sous chaine par une autre 'le balcon'.replace('con', 'lon')
'le ballon'
'xyabcxyabcxy'.replace('xy','ef',2)
'efabcefabcxy'

strip : Enlever les espaces ou les occurrences d’un caractère dans ' Bonjour'.strip()
une chaine 'Bonjour'
 CONCEPTS DE BASE
LES CHAINES DE CARACTÈRES : MÉTHODES
index permet de rechercher l’indice mais lève une exception ‘xyabcxyabcxy’.index(‘xy’)
quand la chaine n’existe pas 0
in vérifier si une chaine est dans une chaine ‘xy’ in ‘xyabcxyabcxy’
True

count compter le nombre d’occurrence d’une sous-chaine ‘xyabcxyabcxy’.count(‘xy’)

3

find Rechercher l’indice de la première occurrence d’une ‘xyabcxyabcxy’.find(‘xy’)

sous-chaine. Si la chaine n’existe pas le resultat est -1 0
 CONCEPTS DE BASE
LES STRUCTURES DE CONTRÔLE
Les Structures conditionnelles
La condition if Remarquez la présence de l’indentation du code en bas du if .
L’indentation est un mécanisme très important (capital) en
Syntaxe :
Python. C’est cette mise en forme qui permet de reconnaitre
if condition : (délimiter) les instructions qui appartiennent à un même bloc.
instruction 1
instruction 2 Une indentation peut se faire par tabulation ou par des espaces
(4 espaces en général)

Exemple :
Voir page suivante
 CONCEPTS DE BASE
LES STRUCTURES DE CONTRÔLE
Exemple :

age = 20
langage = "Python"

if age >= 18:

print("Vous êtes majeur !")
if langage == "Python":
print("Vous pouvez rentrer")

print("Le script est terminé")

 CONCEPTS DE BASE
LES STRUCTURES DE CONTRÔLE : Structure conditionnelle
La condition if avec else ou encore if avec elif et else

Exemples : utilisateur = "root"

if utilisateur == "admin":
age = 15
print("Accès autorisé !")
if age >= 18:
elif utilisateur == "root":
print("Vous êtes majeur")
print("Accès autorisé !")
else:
else:
print("Vous êtes mineur")
print("Accès refusé...")
 CONCEPTS DE BASE
LES STRUCTURES DE CONTRÔLE : Structures itératives
Les boucles : for et les boucles while
Syntaxe de la boucle for Syntaxe de la boucle while
for <variables> in <sequence> : while <condition> :
<bloc d’instructions> <bloc d’instructions>

Exemples : Exemple :
for n in [1,2,3] : compteur = 1
print(n) while compteur <= 10 :
print("Compteur = ", compteur)
for c in "abcd": compteur += 1
print(c)
 CONCEPTS DE BASE
LES STRUCTURES DE CONTRÔLE : Structures itératives
Nota : Il n’existe pas de boucle do … while en python. On peut juste la simuler comme suit :

while True:
# Code à exécuter à chaque itération
if condition:
break
 CONCEPTS DE BASE
LES MODULES
Un module est un fichier Python qui contient des fonctions qu’on peut manipuler (appeler).
Pour utiliser un module ou les fonctions qu’elle contient, il faut l’importer.
Syntaxe :
import nom_du_module
Exemple : import random

Pour utiliser une fonction contenue dans un module qu’on a importé, il faut la préfixée du nom du
module.
Exemple : [Link](0,5) #va retourner un nombre aléatoire compris entre 0 et 5 exclut
Recherche à faire : chercher à quoi servent les fonction uniform et randrange
 CONCEPTS DE BASE
LES MODULES
Les Modules os et pathlib
Le module os permet d’interagir avec le système d'exploitation sur lequel le programme Python
s'exécute, en mettant à disposition des méthodes pour accéder à des fonctionnalités spécifiques
au système d'exploitation, telles que la gestion des fichiers, des répertoires, des processus, des
variables d'environnement, des chemins de fichiers, etc.

Le module pathlib est un module intégré à partir de la version Python 3.4. Il fournit une
interface orientée objet pour manipuler les chemins de fichiers et les systèmes de fichiers. Il
simplifie la manipulation des chemins de fichiers en offrant une syntaxe plus intuitive et
expressive que les méthodes traditionnelles basées sur des chaînes de caractères.
 CONCEPTS DE BASE
LES MODULES
Exemple : module os
import os
chemin = "/users/dossier_etudiants"
sous_dossier = [Link](chemin, "nouveau_dossier")
[Link](sous_dossier) #on peut utiliser mkdir() mais c’est limité

#une variante plus correcte qui ne crée le dossier que si ça n’existe pas
if not [Link](sous_dossier):
[Link](sous_dossier)
#ou encore
[Link](sous_dossier, exist_ok=True)
 CONCEPTS DE BASE
LES MODULES
Exemple : module pathlib
import pathlib
dossier_parent = [Link]("/chemin/dossier_parent")
nom_sous_dossier = "nouveau_sous_dossier"
# Chemin complet du sous-dossier
chemin_sous_dossier = dossier_parent / nom_sous_dossier
if chemin_sous_dossier.exists():
print("Le sous-dossier existe déjà.")
else:
chemin_sous_dossier.mkdir()
print("Le sous-dossier a été créé avec succès.")
 CONCEPTS DE BASE
LES MODULES
Au lieu d’importer un module, on peut aussi importer directement une fonction depuis un module.
La syntaxe est la suivante :

from nom_du_module import nom_de_la_fonction

De cette façon on n’a plus besoin de précéder le nom de la fonction par celui du module.
Exemple :
from random import randint
nombre = randint(3,10)

Note : On verra au cours comment créer ses propres modules

 CONCEPTS DE BASE
LES SÉQUENCES
En Python, une séquence est une collection ordonnée et indexable d'éléments. Les séquences sont des
types de données intégrés qui permettent de stocker et de manipuler des ensembles d'éléments de
différentes manières. Les types de séquences les plus couramment utilisés en Python sont les suivants :
Chaînes de caractères, Listes, Tuples.
Le slicing est une opération permettant d'extraire une sous-séquence à partir d'une séquence (comme
une chaîne de caractères, une liste ou un tuple) en utilisant des indices.
Syntaxe :
sequence[debut:fin:pas]
debut est l'indice de départ (inclus) de la sous-séquence. Si omis, le slicing commence depuis le début
de la séquence.
fin est l'indice de fin (exclus) de la sous-séquence. Si omis, le slicing va jusqu'à la fin de la séquence.
pas est l'incrément utilisé pour sélectionner les éléments. Si omis, le pas par défaut est de 1.
 CONCEPTS DE BASE
LES SÉQUENCES
Opérations de slicing Résultat
s[i] i-ème élément de s
s[i:j] Sous-séquence de s constituée des éléments entre le i-ème (inclus) et le
j-ème (exclus)
s[i:j:k] Sous-séquence de s constituée des éléments entre le i-ème (inclus) et le
j-ème (exclus) pris avec un pas de k
 CONCEPTS DE BASE
LES SÉQUENCES
Opérations Résultat
x in s Teste si x appartient à s
x not in s Teste si x n’appartient pas à s
s+t Concaténation de s et t
s * n où n est un entier Concaténation de n copies de s
len(s) Nombre d’éléments de s
min(s) Plus petit élément de s
max(s) Plus grand élément de s
[Link](x) Nombre d’occurences de x dans s
[Link](x) Indice de x dans s
 CONCEPTS DE BASE
LES SÉQUENCES : LISTES
Les listes font parties des quatre grandes structures de données qui existent en Python.
C’est une structure de données muable et ordonnée dans laquelle on peut stocker n'importe
quel type d'objet appelé élément.

Une liste se définit comme une collection d'éléments séparés par des virgules, l'ensemble
étant enfermé dans des crochets.
Une liste peut stocker n’importe quel type d’objet. En réalité, elle ne stocke pas les objets mais
plutôt les références vers les objets.
Création d’une liste
Liste = [1, 2, 3] #pour une liste vide, on peut faire Liste=[ ] ou encore Liste=list()
 CONCEPTS DE BASE
LES SÉQUENCES : LISTES
Afficher un item d'une liste Agrandir une liste par une liste : extend
>>>a=5 >>> y = [1,2,3,’c’]
>>> liste = [a,’ananas’,3.2] >>> [Link](y) # On complète liste par y
>>> liste[0] >>> liste
5 [5, ’ananas’,’b’,3.2,’ok’,1,2,3,’c’]
>>> liste[-1] # dernière élément
3.2 modifier les valeurs
>>> liste[0]=6
>>> liste
Ajouter des valeurs à la liste [6, ’ananas’,’b’,3.2,’ok’1,2,3,’c’]
[Link]("ok") # On ajoute à la fin >>> liste[3]=liste[3]+10
>>> liste >>>liste
[5, ’ananas’,3.2,’ok’] [6, ’ananas’,’b’,13.2,’ok’,1,2,3,’c’]
>>> [Link](2, ‘b’) # On insère ‘b' à l'indice 2 >>>liste[1:3]=[5,4]
[5, ’ananas’,’b’,3.2,’ok’] >>>liste
[6, 5,4,13.2,’ok’,1,2,3,’c’]
 CONCEPTS DE BASE
LES SÉQUENCES : LISTES
Supprimer les éléments d’une liste Trouver l'index d'une valeur
>>> del liste[3] >>> liste=[6,1,2,3,’c’]
>>> liste >>>[Link](‘c’)
[6, 5,4,’ok’,1,2,3,’c’] 4
>>>liste[1:3]=[] >>> liste[:] # Affiche toutes les occurrences
>>>liste
[6,’ok’,1,2,3,’c’] Copier une liste qui sera indépendante
>>> [Link](‘ok’) >>> L = [10,20,40]
>>> liste >>> s = L[:]
>>> s[0] = 5
[6,1,2,3,’c’]
>>> s
>>> liste[:] = [] # vide la liste
[5,20,40]
Trier une liste s=[10,12,1,5,17] >>> L
>>>[Link]() [10,20,40]
>>>s
[1,5,10,12,17]
 CONCEPTS DE BASE
LES SÉQUENCES : LISTES
Pour savoir si un élément est dans une liste Transformer une liste en Chaine
>>> liste = [10,20,40] On utilise la méthode join.
>>> 20 in liste
True >>>"-".join(['ab', 'cd', 'ef', 'gh'])
>>> 6 in liste 'ab-cd-ef-gh'
False >>>"".join(['ab', 'cd', 'ef', 'gh'])
'abcdefgh'
La fonction range : génère une liste composée
d'une simple suite arithmétique. Transformer une chaine en liste
>>>L= list(range(10)) On utilise la méthode split
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # affiche le contenu de L >>> 'ab-cd-ef-gh'.split(‘-')
[‘ab’ , ‘cd’, ’ef’, ‘gh’]
 CONCEPTS DE BASE
LES LISTES
Pour savoir si un élément est dans une liste Pour récupérer l'index, on peut utiliser la
>>> liste = [10,20,40] fonction enumerate.
>>> 20 in liste >>> for val in enumerate(liste):
True ... print val
>>> 6 in liste (0, 5)
False (2, ‘yes')
(3,10)
Boucler sur une liste
>>> liste = [5,"yes",10]
>>> for lettre in liste:
... print (lettre)
5
yes
10
 CONCEPTS DE BASE
LES SÉQUENCES : TUPLE
Les tuples sont des listes immuables (qu'on ne peut modifier). Un tuple est écrit comme une
liste de valeurs, séparées par des virgules, encadrée de parenthèses.
Le tuple est toujours affiché avec des parenthèses. Un tuple à un seul élément doit être terminé
par une virgule ; un tuple sans élément s’écrit avec des parenthèses vides.
On peut accéder aux éléments d’un tuple par un index positionnel.
Création d’un tuple
>>> montuple = () #pour un tuple vide, on peut faire montuple=tuple()
>>>montuple
>>>()
 CONCEPTS DE BASE
LES SÉQUENCES : TUPLE
>>> tup = ('a', 'b', 'c', 'd', 'e') # ou encore tup = 'a', 'b', 'c', 'd', 'e'
>>> print(tup)
('a', 'b', 'c', 'd', ‘e’)

>>> tup = (9, ) # ou encore tup = 9, Nota : Il faut remarquer la présence de la virgule
>>> tup
>>>(9,)
 CONCEPTS DE BASE
LES SÉQUENCES : TUPLE
Opérations sur les tuples
tup = ('a', 'b', 'c', 'd', 'e')
>>> tup[1:3] = ('x', 'y’) ==> ***** erreur ! Car immuable *****
tup = ('Andre',) + tup[1:] ==> ***** Marche parce que nouveau tuple *****
>>> tup
('Andre', 'b', 'c', 'd', 'e’)

Nota : Pour s’en convaincre, il suffit de vérifier le id(tup) avant et après la modification pour voir
qu’il s’agit de deux tuples différents. Par contre en faisant la même chose avec les listes, l’id ne
change pas.
 CONCEPTS DE BASE
LES SET (OU ENSEMBLE)
Les ensembles sont des collections mutables (modifiables), non ordonnées d’objets uniques et
immutables (non modifiables). Les ensembles prennent en charge les opérations mathématiques
qui leur sont propres telles que : union, intersection et différence.
Les ensembles ne sont pas vraiment des séquences (ils ne sont pas ordonnés), mais ils prennent
en charge l’itération. On ne peut accéder aux éléments d’un ensemble que par itération (utilisation de
l’opérateur in) et non pat un index positionnel.
Création d’un ensemble
>>> monens = set() #pour un un ensemble vide. monens = {} ne marche pas
>>> monens = {1,3, "msg", 8,15}
>>> [Link]("merci")
 CONCEPTS DE BASE
LES SET (OU ENSEMBLE)
Opérations sur les ensembles
Opération Opérateur Fonction Commentaire
Appartenance in Pour voir si un élément appartient à un ensemble
Différence - difference() Ensemble formé des éléments du premier
ensemble qui ne sont pas le second
Union | union() Union de deux ensembles
Intersection & intersection() Ensemble des éléments commun à deux ensembles
Inclusion <= issubset() Inclusion du 1er ensemble dans le 2nd
Inclusion >= superset() Inclusion du 2nd ensemble dans le 1er
Différence ^ symmetric_difference Ensemble d’éléments appartenant exclusivement
symétrique au 1er ou au 2nd mais pas aux deux.
Nota : Il y a aussi les opérateurs < , > , |= ainsi que quelques autres fonctions : copy(), add(), remove()
 CONCEPTS DE BASE
LES DICT (OU DICTIONNAIRE)
Un dictionnaire est un objet mutable qui contient les données sous la forme de paires clé :valeur.
Comme les listes, les dictionnaires sont des objets pouvant en contenir d’autres. Cependant, au
lieu d’héberger des informations dans un ordre précis, ils associent chaque objet contenu à une
clé. Habituellement la clé est une chaîne de caractères, mais ce n’est pas une contrainte. On peut
des clés qui sont des entiers, des réels, des chaînes de caractères, et même des tuples.
Propriétés des dictionnaires :
— Non ordonné : Pas de possibilité d’accès via index. Les dictionnaires ne sont donc pas des
séquences.
— Modifiable : on peut modifier, ajouter ou supprimer des éléments
— Clé unique : on ne peut pas avoir deux éléments avec la même clé.
Création d’un dictionnaire : On peut créer un dictionnaire vide et y ajouter par la suite des
éléments, comme on peut créer directement un dictionnaire en l’initialisant avec des éléments.
 CONCEPTS DE BASE
LES DICT (OU DICTIONNAIRE)
Exemple :
>>>frToEng = {}
>>>frToEng
{}
>>>voiture = {"marque": "Ford", "modèle": "Mustang", "année": 1964}
>>>voiture
{'marque': 'Ford', 'modèle': 'Mustang', 'année': 1964}
 CONCEPTS DE BASE
LES DICT (OU DICTIONNAIRE)
Pour accéder à un champ d’un dictionnaire on procède comme pour les index, sauf que ici il n’y a pas
d’indice mais de clé qui est le plus souvent une chaine de caractères.
Pour ajouter par exemple une paire clé:valeur, on peut procéder comme suit :
>>> nom_dictionnaire["nouvelle_clé"]= "Nouvelle valeur"
Nota : La valeur associée à une clé peut être n’importe quoi.

Exemple :
>>> voiture["couleurs"] = ["rouge", "vert", "bleu"] #ajout d’une paire clé:valeur à voiture
>>> voiture
{'marque': 'Ford', 'modèle': 'Mustang', 'année': 1964, 'couleurs': ['rouge', 'vert', 'bleu']}
 CONCEPTS DE BASE
LES DICT (OU DICTIONNAIRE)
Exemple :
>>> frToEng = {}
>>> frToEng['ordinateur'] = 'computer'
>>> frToEng['souris'] ='mouse'
>>> frToEng['keyboard'] ='clavier’
>>> frToEng
{'ordinateur': 'computer', 'souris': 'mouse', 'keyboard': 'clavier’}
>>> frToEng['souris']
'mouse'
 CONCEPTS DE BASE
LES DICT (OU DICTIONNAIRE)
Opérations sur les dictionnaires :
En dehors de l’utilisation des clés comme dans les tableaux pour accéder aux valeurs du
dictionnaire, on peut utiliser les fonctions suivantes qu’on connait déjà pour les avoir vu :
❑len, del.
De même pour les test d’appartenance, on peut utiliser l’opérateur in
On peut aussi invoquer certaines méthodes sur les dictionnaires, à savoir :
❑keys() pour lister les clés d’un dictionnaire
>>> [Link]()
dict_keys(['marque', 'modèle', 'année', 'couleurs'])
 CONCEPTS DE BASE
LES DICT (OU DICTIONNAIRE)
Opérations sur les dictionnaires :
❑values() pour lister les valeurs associées aux différentes clés d’un dictionnaire
>>> [Link]()
dict_values(['Ford', 'Mustang', 1964, ['rouge', 'vert', 'bleu’]])

❑Items pour lister tous les couples clé:valeur du dictionnaire sous forme de liste de tuples
(clé,valeur)
>>> [Link]()
dict_items([('marque', 'Ford'), ('modèle', 'Mustang'), ('année', 1964), ('couleurs', ['rouge', 'vert',
'bleu'])])
 CONCEPTS DE BASE
LES DICT (OU DICTIONNAIRE)
Opérations sur les dictionnaires :
❑copy() pour faire une vraie copie d’un dictionnaire dans un nouveau
Nota : La simple affectation d’un dictionnaire à un autre ne fait que transférer la référence d’un
objet, d’une variable à une autre. Donc, c’est comme un alias.

>>> magasin = [Link]()

 CONCEPTS DE BASE
LES DICT (OU DICTIONNAIRE)
Opérations sur les dictionnaires : Petit tableau récapitulatif de méthodes
Méthode Description
clear() Supprime tous les éléments du dictionnaire
copy() Renvoie une copie du dictionnaire
fromkeys() Renvoie un dictionnaire avec les clés et la valeur spécifiées
get() Renvoie la valeur de la clé spécifiée
items() Renvoie une liste contenant un tuple pour chaque paire clé : valeur

keys() Renvoie une liste contenant les clés du dictionnaire

pop() Supprime l’élément avec la clé spécifiée

popitem() Supprime la dernière paire clé-valeur insérée

setdefault() Renvoie la valeur de la clé spécifiée. Si la clé n’existe pas : insérez la clé, avec la valeur spécifiée

update() Met à jour le dictionnaire avec les paires clé-valeur spécifiées

values() Renvoie une liste de toutes les valeurs du dictionnaire

 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS
L’une des puissance de python est la richesse de sa bibliothèque. Il existe de très nombreuses
bibliothèques spécialisées en Python qui mettent à disposition un grand nombre de fonctions pour
faire des traitements allant des plus simples aux plus complexes.
De même, possibilité est donnée à l’utilisateur de créer très facilement ses propres bibliothèques.
En Python, toutes ces bibliothèques sont appelées des modules.

IMPORTER UN MODULE
Pour utiliser certaines fonctions prédéfinies de Python, il faut importer soit la bibliothèque qui la
contient, soit importer directement la fonction depuis la bibliothèque qui la contient.
Pour importer un module, on utilise le mot clé import
>>>import nom_bibliothèque
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES MODULES
Exemples :
>>> import os
>>> [Link]('cls') #Pour effacer l’écran du terminal sous windows
Pour importer plusieurs modules à la fois, on les sépare par des virgules
>>>import module1, module2, Module3

On peut renommer un module lors de son importation pour en faciliter la manipulation.

>>>import nom_module as nouveau_nom #Généralement le nouveau nom est très court
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES MODULES
Au lieu d’importer tout un module, on peut importer juste une fonction ou certaines fonction. Pour
cela, on utilise le mot clé from couplé avec le mot clé import.
Exemple :
>>>from nom_module import nom_fonction
Ou
>>>from nom_module import nom_fonction1, nom_fonction2, nom_fonction3
On peut aussi importer toutes les fonctions d’un module (même si c’est déconseillé pour des
raisons de possibilité de conflits)
>>>from nom_module import *
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES MODULES
Exemples :
import math
alpha=[Link]/3
print(’Tangente de pi/3 = ’,[Link](alpha))

from random import randint

aleaval=randint(10, 20)
porint(aleaval)

import math as mt
print([Link](1))
print([Link](1) )
print(mt.log10(10))
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES MODULES
PACKAGE ou LIBRAIRIE : Regroupement de plusieurs modules liés entre eux, dans un
dossier et/ou des sous dossiers, pour fournir des fonctionnalités données et organiser les codes
des modules en sous-dossiers et créer une hiérarchies de modules.
Pour créer un package :
❖ on crée un dossier portant le nom de votre package
❖ à l’intérieur de ce dossier, on ajoute un fichier nommé __init__.py; nécessaire pour que
Python reconnaisse ce dossier comme un package
Pour importer un module d’un package :
❖ on utilise la syntaxe suivante : import nom_package.nom_module
Le vichier __init__.py peut être vide comme on peut y importer des modules spécifiques, définir
des variables globales ou exécuter des actions d’initialisation.
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
Une fonction est un bloc de code défini avec un nom et destinée à réaliser un traitement spécifique.
Les fonctions permettent la modularité du code.
Comme presque tous les langages de programmation, Python intègre des fonctions prédéfinies,
mais offre aussi la possibilité à l’utilisateur de créer ses propres fonctions.
Syntaxe de déclaration d’une fonction : On utilise le mot clé def
Nota :
def nom_fonction([liste_parametres]) : ✔ Remarquer la présence de : ainsi que l’indentation du
corps de la fonction
#corps de la fonction ✔ Les paramètres sont optionnels. Donc, la fonction peut ne
:::::: pas en avoir
✔ La fonction peut retourner, comme peut ne pas retourner
:::::: de valeur. Quand elle en retourne, elle peut en retourner
#[return expression] même plusieurs séparées par des virgules.
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
Exemples:
Pour appeler ces fonctions, on met seulement leurs noms avec
def salutation():
les paramètres au besoin.
print("Bonjour à la M1 IRT") salutation()
salut("Moussa", 17)
def salut(nom, age):
print("Bonjour ",nom) Et le résultat sera respectivement :
print("Vous avez ",age," ans.")
Bonjour à la M1 IRT
Bonjour Moussa
Vous avez 17 ans
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
Valeur de retour : Pour appeler pour appeler cette fonction, on peut par exemple
faire :
def calcul(a, b):
add = a + b
sous=a-b x,y,z = calcul(10,8)
print("somme =", x, ", différence =", y, ", produit =", z)
mult=a*b
# renvoi les 3 résultats Ce qui va donner comme résultat :
return add,sous,mult
somme = 18 , différence = 2 , produit = 80
Mot clé : pass
Permet de définir un bloc syntaxiquement vide (donc qui ne fait rien).
def addition(num1, num2):
pass
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
Docstrings :
Un docstring est un commentaire mais qui en réalité est une chaine de documentation d’une
fonction lorsqu’on en fait usage dans la fonction. Ça permet d’expliquer le fonctionnement de la
fonction et d’en facilité la maintenance éventuelle.
Il est déclaré en utilisant des guillemets simples triples (''') ou des guillemets doubles triples (""")
au début et à la fin de ce qu’on veut mettre comme documentation.
Pour accéder au docstring, on utilise l’attribut doc (__doc__).
def factorielle(x):
"""Calcul de x!"""
pass
print(factorielle.__doc__) #va donner comme résultat : Calcul de x!
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
Arguments d’une fonction :
Une fonction peut avoir ou peut ne pas avoir d’arguments.
Lorsqu’elle en a, lors de l’appel, ces arguments sont fournis dans leur ordre positionnel par défaut,
de la gauche vers la droite. On dira que les arguments sont positionnels.
Mais lors de l’appel d’une fonction, on peut ne pas passer tous les arguments. On peut même
sous certaines conditions, les passer dans le désordre. Ci-dessous, quelques précisions sur cet
état de choses. On parlera de :
— Argument avec valeur par défaut
— Arguments avec étiquettes OU Arguments nommés
— Nombre variable d’arguments
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
— Argument avec valeur par défaut
Lors de la définition d’une fonction, on peut donner des valeurs par défaut à tous ou certains de
ces arguments. Mais dans le cas où tous les arguments n’ont pas de valeurs par défaut, on liste
en premier les arguments sans valeur par défaut et on termine avec ceux ayant de valeurs par
défaut.
def salutation(civilite, nom='MOUSSA', prenom='Jacques'):
print(f"Bonjour {civilite} {nom} {prenom}, comment allez-vous ?")
#print("Agréable journée à vous") Le code ci-contre va afficher pour les différents appels :

salutation("M.") Bonjour M. MOUSSA Jacques, comment allez-vous ?

Bonjour Mme AGBAKO Jacques, comment allez-vous ?
salutation("Mme", "AGBAKO") Bonjour Mme AGBAKO Maridath, comment allez-vous ?
salutation("Mme", "AGBAKO", "Maridath")
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
— Arguments avec étiquettes OU Arguments nommés
Python permet, lors de l’appel d’une fonction, de passer les arguments dans en désordre pour peu
qu’on respecte une certaine syntaxe. Pour cela les noms des paramètres sont utilisés comme
étiquettes pour spécifier pour quel paramètre la valeur en argument doit utilisée.
Pour le fonction salutation de la page précédente, on peut alors avoir ceci :
salutation(prenom="Maridath",civilite="Mme", nom="AGBAKO"),

On aura exactement le même résultat :

Bonjour Mme AGBAKO Maridath, comment allez-vous ?
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
— Nombre variable d’arguments
Comme dans un certain nombre de langages de programmation, il est possible en Python de
créer un nombre variable de paramètres. Pour ce faire, on place un astérisque (*) avant
l’argument de longueur (nombre) variable.
def somprod(opera, *nbrs): En appelant cette fonction avec les deux exemples
som,prod=0,1 ci-dessous
for nb in nbrs : somprod("add",3,6,8,9)
if opera=='add': somprod("mult",3,6,8,9)
som+=nb
elif opera=='mult’: On obtient
add (3, 6, 8, 9) = 26
prod*=nb
mult (3, 6, 8, 9) = 1296
if opera=='add':print(opera, nbrs, '=',som)
if opera=='mult':print(opera, nbrs, '=', prod)
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
— Nombre variable d’arguments mais nommés
Il peut arriver que pour une raison spécifique, qu’une ait besoin de nommer tous les arguments
d’une fonction ayant un nombre variable d’arguments.
Dans ce cas, on utilise ** à la place * avant l’argument lors de la définition de la fonction. Puis lors
de l’appel de la fonction, passer des paramètres dont les valeurs sont nommées.
Cela crée un dictionnaire de clé:valeur pour chaque paramètre passé. SI un paramètre est passé
sans être nommé, une clé générique lui ai associée.

Voir la page suivante pour l’exemple.

 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS : LES FONCTIONS
Exemple :

def loto(combinaison=(12,6,5,17,42),**numeros):
if len(numeros)==5 and combinaison == (numeros['n1'],numeros['n2'],numeros['n3'],numeros['n4'],numeros['n5']):
print("Vous avez gagné votre mise fois", 5**5)
elif len(numeros)>=3 and combinaison[:3] == (numeros['n1'],numeros['n2'],numeros['n3']):
print("Vous avez gagné votre mise fois", 3**5)
elif len(numeros)>=1 and combinaison[0] == (numeros['n1']):
print("Vous ne gagnez pas mais vous reprenez votre mise !")
else: Cet exemple donne comme résultat après les appels :
print("Dommage, vous avez perdu. Du courage !!!")

loto(n1=21, n4=6,n2=9,n3=17,n5=10) Dommage, vous avez perdu. Du courage !!!

loto(n1=12, n4=17,n2=6,n3=5,n5=42) Vous avez gagné votre mise fois 3125
loto(n1=12, n2=10,n3=7) Vous ne ganez pas mais vous reprenez votre mise !
loto(n1=12, n4=1,n2=6,n3=5,n5=2) Vous avez gagné votre mise fois 243
loto(n1=12,n2=6,n3=5) Vous avez gagné votre mise fois 243
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS
Variable local et variable globale:
Une variable définie à l’intérieur du corps d’une fonction, n’est accessible qu’à l’intérieur de la
fonction. On parle de variable locale. Elle n’est pas vu à l’extérieur de la fonction.
Une variable globale est une variable qui est définie en dehors de toute fonction. Elle est visible
partoutdans le code (y compris dans les fonctions) à partir de l’instant de sa définition.
Toutefois, si la fonction contient une variable locale du même nom, la variable globale n’est plus
visible dans la fonction.

Pour lever toute ambigüité, on doit utiliser le mot clé global dans la fonction pour imposer à la
fonction de considérer la variable comme globale et non locale.
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS
Variable local et variable globale: Exemples
def fon2(): def fon3:
def fon(): global x
print(x) x=3
print(x) x,y=3,10
x=10 print(x,y)
fon() x=10
fon2() x,y = 10, 5
print(x) fon3()
L’exécution donne : print(x,y)
L’exécution donne : L’exécution donne :
10 #variable globale
3 #variable locale ds fonc2 10 10 # x globale, y local
#La variable globale est 10 #variable globale dehors 10 5 # x et y globales
#vu dans la fonction #variable globale non vue #x globale vue dans fon3
#ds la fonction car masquée #y globale non vue dans fon3
#par la variable locale #mais x,y globales vues dehors
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS
Les Fonctions: Fonction lambda
Il arrive parfois qu’on ait besoin de manipuler des fonctions sans nom ou encore des fonctions
anonymes. En python, on parle de fonction lambda.
Les fonctions lambda sont pratiques pour des tâches simples, des opérations sur des collections
de données et des expressions courtes.
Syntaxe :
nom_de_variable = lambda liste_arguments : expression
Exemples :
som = lambda x,y:return x+y
est_pair = lambda x: x % 2 == 0
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS
Les Fonctions: Fonction lambda
Appel : pour l’appel de la fonction, il suffit de passer, au besoin, les paramètres à la variable à
laquelle on a affecté la fonction.
print (som(17,9)) # Ce qui va afficher : 26
print(est_pair(73)) # Va afficher : False

Nota : on peut aussi appeler directement une fonction lambda en même temps qu’on la crée.
Nous allons voir quelques exemples d’application avec les fonctions map et filter
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS
La Fonction: map
La fonction map() est utilisée pour appliquer une ou plusieurs fonctionnalités à chaque élément
présent dans la séquence donnée et générer une nouvelle série avec la modification résultant de
l’application de cette fonctionnalité.
Pour cette raison, on utilise très souvent une fonction lambda pour définir cette fonctionnalité.
Syntaxe d’utilisation : map(function,sequence)
Exemple 1 :
list1 = [2, 3, 4, 8, 9]
list2 = list(map(lambda x: x**3, list1)) #equivalent à list2=list([x*2 for x in list1])
print(list2) #ce qui va donner [8, 27, 64, 512, 729]
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS
La Fonction: filter
La fonction filter() est utilisée pour extraire d’une séquence, les valeurs répondant à un critère.
Donc, comme son l’indique, cette fonction permet de filtrer des données.
Syntaxe d’utilisation : filter(function,sequence)
Exemple 1 :
list1 = [2, 3, 4, 8, 9]
list2 = list(filter(lambda x: x%2==0, list1))
print(list2) #va afficher [2, 4, 8] qui est la liste des éléments pairs de list1
 CONCEPTS DE BASE
LES MODULES ET LES FONCTIONS
Docstrings :
Le docstring est une chaine de documentation écrite par un programmeur dans le code source
d’une fonction pour décrire (faire savoir aux autres) ce que fait la fonction..
Il est déclaré en utilisant des guillemets simples triples (''') ou des guillemets doubles triples (""").
def factorielle(x):
"""Calcul de x!"""
pass #le mot clé pass permet d’écrire une instruction vide (qui ne fait rien)

Accès à la docstring
print(factorielle.__doc__) #Va afficher : Calcul de x!
 TRAITEMENTS SUR LES FICHIERS
LES FICHIERS
La Fonction: open
La fonction de base pour travailler sur les fichiers en Python est la fonction open().
L’appel à open() s’assure de l’existence du fichier à ouvrir (le crée dans certains cas), crée un objet
correspondant au fichier, s’il arrive à l’ouvrir, met la position du curseur à 0 (début du fichier).
La lecture, l’écriture, la fermeture doivent être effectuées séparément et explicitement grâce à
l’utilisation de méthodes spécifiques de traitement de fichiers en fonction du type de fichier traité.
Syntaxe : f = open (nom_fichier, mode)
o nom=fichier est une chaine de caractères représentant le chemin vers le fichier
o mode est une chaine de caractères représentant le mode d’ouverture (r,w,a,x). Elle peut inclure la
lettre b en plus, dans le cas de fichier binaire (rb, wb, ab, xb).
o Il peut y avoir d’autres options comme paramètre de la fonction open. Par exemple encoding =
'utf-8'
 TRAITEMENTS SUR LES FICHIERS
LES FICHIERS TEXTE OU ASCII
La méthode: close
Tout fichier ouvert doit être fermé.
Pour fermer un fichier ouvert par la fonction open(), on invoque la méthode close() sur l’objet
associé à ce fichier après son ouverture.

f = open ("[Link]", "r")

#Les traitements
[Link]()
 TRAITEMENTS SUR LES FICHIERS
LES FICHIERS TEXTE OU ASCII
Lecture du contenu d’un fichier
Il existe plusieurs fonctions pour lire le contenu d’un fichier texte, suivant qu’on veut lire tout son
contenu en une fois, lire son contenu ligne par ligne, ou lire son contene en une fois mais en
mettant chaque ligne comme un élément d’une liste.
La méthode read()
f = open("D:\\mondossier\\[Link]", "r") #ouvre le fichier, s’il existe
contenu = [Link]() #il faut s’assurer que le fichier existe avant
print(contenu)
[Link]()

Nota : On peut lire juste quelques caractères (n) à chaque fois en faisant : [Link](n)
 TRAITEMENTS SUR LES FICHIERS
LES FICHIERS TEXTE OU ASCII
Lecture du contenu d’un fichier
La méthode readline() : permet de lire une ligne du fichier et positionner le curseur en début de la
ligne suivante si elle existe.

f = open("D:\\mondossier\\[Link]", "r")
contenu = [Link]()
print(contenu)
[Link]()

Nota : Pour lire tout le contenu du fichier avec cette méthode, il faut mettre en place une boucle.
 TRAITEMENTS SUR LES FICHIERS
LES FICHIERS TEXTE OU ASCII
Lecture du contenu d’un fichier
On peut aussi faire la lecture ligne par ligne de manière plus simple

f= open("[Link]", "r")
for x in f:
print(x)
[Link]()
 TRAITEMENTS SUR LES FICHIERS
LES FICHIERS TEXTE OU ASCII
Lecture du contenu d’un fichier
La méthode readlines() : La méthode readlines() est utilisée pour lire toutes les lignes d’un fichier
texte et les stocker sous forme d’une liste de chaînes de caractères. Chaque élément de la liste
correspond à une ligne du fichier.
nom_fichier = "[Link]" #[Link]
f = open(nom_fichier, "r", encoding='utf-8') une ligne
contenu = [Link]() une autre ligne
print(contenu) une troisième
[Link]() une quatrième ligne

Ce code va afficher : ['une ligne\n', 'une autre ligne\n', 'une troisième \n', 'une quatrième ligne']
 TRAITEMENTS SUR LES FICHIERS
LES FICHIERS TEXTE OU ASCII
Lecture du contenu d’un fichier
On peut aussi faire la lecture ligne par ligne de manière plus simple

f= open("[Link]", "r")
for x in f:
print(x)
[Link]()
 TRAITEMENTS SUR LES FICHIERS
LES FICHIERS TEXTE OU ASCII

La suite vient