Programmation Orientée Objets (Python) : CONCEPTS, PRATIQUES ET APPLICATIONS

Support de cours
2025
Programmation Orientée Objets (Python)
CONCEPTS, PRATIQUES ET APPLICATIONS
FILIÈRE LICENCE SIIA, SEMESTRE 6

Youssouf EL ALLIOUI
FPK – USMS
[email protected]

© 2024-2025

Avant-propos
Ce support de cours a été élaboré dans le cadre du module « Programmation orientée objets
en Python » destiné aux étudiants de 3ème année (S6) de la Licence Système d’Information et
Intelligence Artificielle (SIIA) de la Faculté Polydisciplinaire de Khouribga (FPK).
L’objectif de ce document est de fournir une introduction complète et structurée à la
programmation orientée objets avec Python. À travers ce support, les étudiants découvriront
non seulement les fondamentaux du langage Python, mais également les concepts et pratiques
spécifiques à la programmation orientée objets. La pédagogie adoptée vise à instaurer un
équilibre entre théorie et pratique, en proposant des explications détaillées, des exemples
concrets et des exercices qui encouragent l’expérimentation et le développement d’une pensée
algorithmique.
Chaque section de ce cours a été pensée pour permettre une progression pédagogique cohérente,
en partant des bases jusqu’aux applications avancées, afin de préparer les étudiants à relever les
défis technologiques actuels et futurs dans le domaine de l’informatique. Ce support se veut
également être un guide méthodologique qui accompagne l’apprenant dans l’acquisition de
compétences essentielles en programmation et en conception orientée objets.
Je souhaite que ce cours suscite curiosité et motivation, tout en fournissant aux étudiants des
outils et des connaissances indispensables pour exceller dans leurs projets académiques et
professionnels. Je vous encourage vivement à explorer, expérimenter et questionner les notions
présentées afin d’enrichir continuellement votre compréhension et votre expertise.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 1 / 111
Remerciements
Ce support de cours est le fruit d’un travail construit au fil des séances de TP animées avec
passion et engagement, dans le cadre du module de Programmation Orientée Objet avec
Python destiné aux étudiants et étudiantes des filières SMI et SIIA de la Faculté
Polydisciplinaire de Khouribga.
Je tiens à exprimer ma plus sincère gratitude aux étudiantes et étudiants qui ont suivi ce
module avec assiduité, enthousiasme et persévérance. Leur présence régulière, leur curiosité
intellectuelle, ainsi que la richesse de leurs interventions ont largement contribué à faire évoluer
ce support bien au-delà du descriptif initial du module.
Chaque séance a été l’occasion d’un échange dynamique, dans un cadre où la pratique a été
au cœur de l’apprentissage: chaque concept a été présenté, illustré et expérimenté directement
dans la salle de TP. Cette approche pragmatique, soutenue par une série d’exercices variés, a
permis de transformer chaque session en un espace vivant d’exploration, de découverte et de
maîtrise progressive des paradigmes orientés objets.
C’est l’énergie positive, la motivation et l’esprit de collaboration de ces étudiants qui m’ont
porté et motivé à chaque déplacement, parfois exigeant, pour dispenser ce cours. Grâce à eux,
ce support n’est pas seulement un document pédagogique : il est le reflet d’une aventure
humaine et académique collective, ancrée dans le respect mutuel et le goût de l’excellence.
Je leur adresse donc un merci chaleureux, avec l’espoir que ce document continue d’être une
ressource précieuse pour eux, ainsi que pour tout apprenant désireux de renforcer ses
compétences en programmation orientée objets avec Python.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 2 / 111
Table des matières
AVANT-PROPOS .................................................................................................................................... 0
REMERCIEMENTS ............................................................................................................................... 1
TABLE DES MATIÈRES ....................................................................................................................... 2
INTRODUCTION GÉNÉRALE ............................................................................................................. 4
CHAPITRE 1 : PREMIERS PAS AVEC PYTHON .............................................................................. 6
QU'EST-CE QUE PYTHON ? .................................................................................................... 6
QUE PEUT FAIRE PYTHON ? ................................................................................................... 6
POURQUOI CHOISIR PYTHON ? ............................................................................................... 7
BON À SAVOIR ................................................................................................................... 7
PYTHON VS AUTRES LANGAGES DE PROGRAMMATION ............................................................... 7
DÉMARRAGE AVEC PYTHON ................................................................................................. 7
SYNTAXE PYTHON .............................................................................................................. 8
CONCLUSION ................................................................................................................... 10
CHAPITRE 2 : BASES DE LA PROGRAMMATION ....................................................................... 11
VARIABLES EN PYTHON ..................................................................................................... 11
LES TYPES DE DONNÉES EN PYTHON .................................................................................... 13
LES NOMBRES EN PYTHON ................................................................................................. 14
CHAÎNES DE CARACTÈRES (STRINGS) ................................................................................... 16
LES OPÉRATEURS EN PYTHON ............................................................................................. 20
LES STRUCTURES CONDITIONNELLES ET ITÉRATIVES EN PYTHON .............................................. 22
FONCTIONS EN PYTHON ..................................................................................................... 25
SAISIE UTILISATEUR EN PYTHON ......................................................................................... 32
FORMATAGE DE CHAÎNES EN PYTHON .................................................................................. 32
CONCLUSION ................................................................................................................... 35
CHAPITRE 3 : STRUCTURES DE DONNÉES EN PYTHON ......................................................... 37
LISTES EN PYTHON ........................................................................................................... 38
TUPLES EN PYTHON .......................................................................................................... 40
ENSEMBLES EN PYTHON .................................................................................................... 43
DICTIONNAIRES EN PYTHON ............................................................................................... 48
CONCLUSION ................................................................................................................... 53

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 3 / 111
CHAPITRE 4 : CONCEPTS AVANCÉS DE PROGRAMMATION .................................................. 55
LA PROGRAMMATION ORIENTÉE OBJET EN PYTHON ................................................................ 55
CLASSES ET OBJETS EN PYTHON .......................................................................................... 55
L’HÉRITAGE EN PYTHON ................................................................................................... 58
POLYMORPHISME EN PYTHON ............................................................................................. 61
PORTÉE EN PYTHON .......................................................................................................... 64
ITÉRATEURS EN PYTHON .................................................................................................... 66
MODULES EN PYTHON ....................................................................................................... 68
CONCLUSION ................................................................................................................... 71
CHAPITRE 5 : OUTILS ET BIBLIOTHÈQUES STANDARDS ...................................................... 72
DATES EN PYTHON ........................................................................................................... 72
MATHÉMATIQUES EN PYTHON ............................................................................................ 75
LES EXPRESSION RÉGULIÈRE ............................................................................................... 76
PIP EN PYTHON ................................................................................................................ 80
CONCLUSION ................................................................................................................... 82
CHAPITRE 6 : PERSISTANCE SIMPLE - MANIPULATION DE FICHIERS ET DONNÉES ... 83
LES FICHIERS EN PYTHON ................................................................................................... 83
JSON EN PYTHON ............................................................................................................. 87
GESTION DES EXCEPTIONS AVEC TRY/EXCEPT EN PYTHON ....................................................... 91
CONCLUSION ................................................................................................................... 93
CHAPITRE 7 : PERSISTANCE AVANCÉE - MANIPULATION DE BASES DE DONNÉES
MYSQL EN PYTHON .......................................................................................................................... 94
CRÉATION DE LA CONNEXION ............................................................................................. 94
L’OBJET CURSOR .............................................................................................................. 95
CRÉATION D'UNE BASE DE DONNÉES MYSQL EN PYTHON ....................................................... 96
CRÉATION DE TABLE EN MYSQL AVEC PYTHON .................................................................... 97
INSERTION DE DONNÉES DANS UNE TABLE MYSQL AVEC PYTHON ............................................ 98
SÉLECTION DE DONNÉES .................................................................................................. 100
FILTRER LES RÉSULTATS .................................................................................................. 101
TRI DES RÉSULTATS ........................................................................................................ 103
SUPPRESSION DE DONNÉES ............................................................................................... 104
SUPPRESSION D'UNE TABLE .............................................................................................. 105
MISE À JOUR DES DONNÉES .............................................................................................. 105
LIMITATION DU NOMBRE DE RÉSULTATS ............................................................................ 106
JOINTURE DE TABLES ...................................................................................................... 107
CONCLUSION ................................................................................................................. 109
CONCLUSION GÉNÉRALE ET PERSPECTIVES ......................................................................... 110

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 4 / 111
Introduction générale
Au cours des dernières années, le langage Python a connu un essor remarquable dans les
communautés académiques, industrielles et technologiques. Ce succès repose sur plusieurs
facteurs clés : sa syntaxe simple et lisible, sa grande expressivité, ainsi que la richesse de son
écosystème de bibliothèques. Utilisé à la fois pour l’enseignement, la recherche, l’analyse de
données, l’intelligence artificielle, l’ingénierie logicielle et le développement web, Python
constitue aujourd’hui un outil fondamental pour toute personne évoluant dans les domaines
scientifiques et techniques.
Le présent support de cours s’adresse principalement aux étudiants de licence, notamment dans
les filières Sciences Mathématiques et Informatiques (SMI) et Sciences Informatiques
pour l’Ingénierie et l’Analyse (SIIA). Il vise à introduire de manière progressive et rigoureuse
les bases du langage Python, tout en développant chez l’étudiant une capacité à raisonner en
termes algorithmiques et à résoudre des problèmes informatiques variés.
L’objectif principal de ce document est d'accompagner l'apprenant dans un parcours
structuré, partant des fondements du langage jusqu’à des applications plus complexes,
notamment en manipulation de fichiers, gestion des exceptions, et interaction avec des bases de
données. L’approche pédagogique adoptée repose sur une articulation entre :
• des explications théoriques claires et concises,
• des exemples de code contextualisés,
• des exercices pratiques pour tester les acquis,
• et des liens progressifs entre les chapitres afin d'assurer la continuité pédagogique.
L’ensemble du contenu est conçu pour être utilisé dans un cadre universitaire, mais peut
également convenir aux auto-apprenants, développeurs débutants, ou enseignants souhaitant
structurer leurs propres supports.
Le support est articulé autour de cinq chapitres complémentaires, chacun consacré à un volet
fondamental du développement en Python :
Chapitre 1 – Découverte de Python et mise en route
Ce chapitre introduit l’environnement de développement Python, la syntaxe de base et les
caractéristiques fondamentales du langage. Il répond à des questions telles que : Qu’est-ce que
Python ? Pourquoi l’utiliser ? Il prépare le terrain pour écrire et exécuter ses premiers scripts.
Chapitre 2 – Bases de la programmation
Ce chapitre explore les fondements de la programmation avec Python : les variables, les types
de données (nombres, chaînes de caractères), les opérateurs, les structures conditionnelles, les

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 5 / 111
boucles, les fonctions, la saisie utilisateur et le formatage de chaînes. Il constitue la pierre
angulaire pour comprendre les constructions de base d’un programme.
Chapitre 3 – Structures de données
Ce chapitre présente les principales structures de données intégrées à Python : listes, tuples,
ensembles, et dictionnaires. Il introduit les opérations courantes de manipulation, les
particularités de chaque structure et leur pertinence dans différents contextes.
Chapitre 4 – Concepts avancés de programmation
On entre ici dans la programmation orientée objet (POO), avec des notions de classes, objets,
héritage, polymorphisme, portée des variables, itérateurs et modules. Ce chapitre initie à des
paradigmes plus robustes et modulaires pour structurer efficacement le code.
Chapitre 5 – Outils et bibliothèques standards
Ce chapitre explore quelques outils pratiques fournis par les bibliothèques standards de Python
: gestion des dates, fonctions mathématiques, expressions régulières, et le gestionnaire de
paquets pip. Il illustre comment tirer profit des modules prêts à l’emploi pour développer plus
rapidement.
Chapitre 6 – Persistance simple : Manipulation de fichiers et données
Ce chapitre traite de la lecture et écriture de fichiers, de l’utilisation du format JSON, et de la
gestion des exceptions avec les blocs try/except. Il met en lumière les mécanismes de
persistance des données simples, essentiels pour tout programme manipulant des
entrées/sorties.
Chapitre 7 – Persistance avancée : Manipulation de bases de données MySQL
Le dernier chapitre aborde l’interaction entre Python et les bases de données MySQL :
connexion, création de bases et tables, insertion, sélection, mise à jour, suppression, jointures,
tri, filtrage, etc. Il initie à l’utilisation de Python dans des contextes orientés données.
Conclusion générale et perspectives
La conclusion revient sur les notions clés couvertes dans le cours, propose des pistes
d’approfondissement (Data Science, IA, Web, automatisation), et donne des conseils pour
continuer à progresser avec Python à travers des projets réels et l’utilisation de bibliothèques
spécialisées (Pandas, Flask, NumPy, etc.).

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 6 / 111
Chapitre 1 : Premiers Pas avec Python
Ce premier chapitre pose les fondations nécessaires à l’apprentissage du langage Python. Il
vise à familiariser les étudiants avec les origines, les caractéristiques principales et les
avantages de ce langage devenu incontournable dans le paysage informatique. Le chapitre
présente également les étapes initiales de prise en main de l’environnement Python, ainsi que
les premières lignes de code pour illustrer la syntaxe simple et lisible du langage. Une attention
particulière est portée à la comparaison de Python avec d’autres langages afin de situer son
positionnement et ses domaines d’application privilégiés.

Qu'est-ce que Python ?
Python est un langage de programmation populaire. Il a été créé par Guido van Rossum et lancé
en 1991.
Il est utilisé pour :
• le développement web (côté serveur),
• le développement logiciel,
• les mathématiques,
• le scripting système.
Que peut faire Python ?
• Python peut être utilisé sur un serveur pour créer des applications web.
• Il peut être employé avec d'autres logiciels afin de créer des chaînes de traitement
(workflows).
• Il permet de se connecter à des systèmes de gestion de bases de données et de lire ou
modifier des fichiers.
• Python est capable de gérer de grandes quantités de données et d'effectuer des calculs
mathématiques complexes.
• Il est adapté au prototypage rapide ainsi qu'au développement de logiciels destinés à la
production.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 7 / 111
Pourquoi choisir Python ?
• Python fonctionne sur de multiples plateformes (Windows, Mac, Linux, Raspberry Pi,
etc.).
• Sa syntaxe simple, proche de l'anglais, facilite l'apprentissage et la rédaction du code.
• La concision de sa syntaxe permet d'écrire des programmes avec moins de lignes
qu'avec certains autres langages.
• Fonctionnant via un interpréteur, Python exécute le code dès qu'il est écrit, ce qui
accélère le prototypage.
• Il peut être utilisé en programmation procédurale, orientée objet ou fonctionnelle.
Bon à savoir
La version majeure la plus récente est Python 3, que nous utiliserons dans ce cours. Cependant,
Python 2, bien qu'il ne reçoive plus que des mises à jour de sécurité, reste encore assez
populaire.
Dans ce tutoriel, Python sera écrit dans un éditeur de texte, même s'il est également possible
d'utiliser un environnement de développement intégré (IDE) tel que Thonny, PyCharm,
NetBeans ou Eclipse, particulièrement utile pour gérer de grandes collections de fichiers
Python.
Python vs autres langages de programmation
Python a été conçu pour être très lisible et présente des similitudes avec l'anglais, avec une
influence notable des mathématiques.
Contrairement à d'autres langages qui utilisent souvent des points-virgules ou des parenthèses
pour terminer une instruction, Python se contente d'un retour à la ligne.
De plus, Python utilise l'indentation (les espaces) pour définir la portée des blocs de code
(comme ceux des boucles, fonctions ou classes), alors que d'autres langages recourent
généralement aux accolades.
Démarrage avec Python
Installation de Python
De nombreux PC et Mac ont déjà Python installé.
Pour vérifier si Python est installé sur un PC Windows, recherchez « Python » dans la barre de
démarrage ou exécutez la commande suivante dans l'invite de commandes (cmd.exe) :
C:\Users\Votre Nom>python --version
Pour vérifier si Python est installé sur Linux ou Mac, ouvrez le terminal (ou la ligne de
commande sur Linux) et tapez :

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 8 / 111
python --version
Si vous constatez que Python n'est pas installé sur votre ordinateur, vous pouvez le télécharger
gratuitement depuis le site officiel : python.org.
Démarrage rapide avec Python
Python est un langage de programmation interprété, ce qui signifie qu'en tant que développeur,
vous écrivez vos fichiers Python (extension .py) dans un éditeur de texte, puis vous les faites
exécuter par l'interpréteur Python.
Pour exécuter un fichier Python depuis la ligne de commande, utilisez la syntaxe suivante :
C:\Users\Votre Nom>python helloworld.py
Ici, "helloworld.py" correspond au nom de votre fichier Python.
Créons notre premier fichier Python, nommé helloworld.py. Vous pouvez le faire avec
n'importe quel éditeur de texte. Par exemple, le contenu de helloworld.py pourrait être :
print("Hello, World!")
C'est aussi simple que cela. Enregistrez le fichier, ouvrez votre invite de commandes, naviguez
jusqu'au répertoire où il se trouve, puis exécutez :
C:\Users\Votre Nom>python helloworld.py
Vous devriez voir s'afficher :
Hello, World!
Félicitations, vous venez d'écrire et d'exécuter votre premier programme en Python !
Syntaxe Python
Indentation en Python
L'indentation correspond aux espaces placés au début d'une ligne de code.
Dans la plupart des langages de programmation, l'indentation est utilisée uniquement pour
améliorer la lisibilité du code ; en Python, elle est cruciale car elle délimite les blocs de code.
Exemple :
if 5 > 2:
print("Five is greater than two!")
NB : Python générera une erreur si l'indentation est omise :
Exemple – Erreur de syntaxe :
if 5 > 2:
print("Five is greater than two!")
NB : Le nombre d'espaces est laissé à la discrétion du programmeur, bien que l'usage
courant soit d'utiliser quatre (4) espaces, et il faut en utiliser au moins un.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 9 / 111
Exemples valides :
if 5 > 2:
print("Five is greater than two!")
ou
if 5 > 2:
print("Five is greater than two!")
Cependant, il est impératif d'utiliser le même nombre d'espaces dans un même bloc de code.
Dans le cas contraire, Python générera une erreur :
Exemple – Erreur de syntaxe :
if 5 > 2:
print("Five is greater than two!")
print("Five is greater than two!")
Variables en Python
En Python, les variables sont créées dès que vous leur assignez une valeur. Il n’existe pas de
commande spécifique pour déclarer une variable.
Exemple :
# Variables en Python :
x = 5
y = "Hello, World!"
Vous en apprendrez davantage sur les variables dans la section dédié aux variables en Python.
Commentaires
Python permet d'ajouter des commentaires dans le code afin de faciliter sa compréhension et sa
maintenance. Les commentaires servent à documenter le code, à améliorer sa lisibilité ou à
désactiver temporairement des lignes lors des tests.
Les commentaires commencent par le symbole #, et Python ignore le reste de la ligne.
Exemple :
# Ceci est un commentaire.
print("Hello, World!")
print("Hello, World!") # Ceci est un commentaire
#print("Hello, World!")
print("Cheers, Mate!")
• Les commentaires peuvent être placés en début de ligne ou à la fin d'une ligne de code
• Les commentaires peuvent également servir à désactiver l'exécution de certaines lignes
de code
Commentaires sur plusieurs lignes
Python ne dispose pas d'une syntaxe officielle pour les commentaires multilignes. Pour
commenter plusieurs lignes, vous pouvez insérer un # au début de chaque ligne :
Exemple :
# Ceci est un commentaire

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 10 / 111
# écrit sur plusieurs lignes
print("Hello, World!")
Alternativement, il est possible d'utiliser une chaîne de caractères multilignes (délimitée par des
triples quotes) qui n'est pas affectée à une variable. Python ignore ces chaînes de caractères, ce
qui permet de les utiliser comme commentaires :
Exemple :
"""
Ceci est un commentaire
écrit sur plusieurs lignes
"""
print("Hello, World!")
Conclusion
En guise de premier contact avec Python, ce chapitre a permis de saisir l’essentiel de ses atouts,
de ses usages et de son positionnement stratégique dans l’écosystème du développement
logiciel. Il a aussi jeté les bases nécessaires pour aborder plus sereinement les éléments
fondamentaux de la programmation. La suite du cours approfondira ces bases à travers une
étude systématique des structures de données, des types primitifs et des opérations
élémentaires, dans le chapitre 2 consacré aux Bases de la programmation.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 11 / 111
Chapitre 2 : Bases de la Programmation
Ce chapitre constitue le cœur des fondements de la programmation en Python. Il introduit les
variables, les types de données courants, les opérations arithmétiques et logiques, ainsi que les
structures de contrôle conditionnelles et itératives. Ces éléments sont essentiels pour toute
construction algorithmique, et leur maîtrise est indispensable avant d’aborder des structures
plus complexes. Le chapitre met également l’accent sur les fonctions, la saisie utilisateur et le
formatage de chaînes, qui permettent de structurer et personnaliser les programmes.

Variables en Python
Définition
Les variables sont des conteneurs utilisés pour stocker des valeurs. En Python, une variable est
créée dès qu'on lui assigne une valeur, sans qu'il soit nécessaire de la déclarer explicitement.
Création et affectation
Exemple d'affectation d'une valeur à une variable :
x = 5
y = "Youssouf"
print(x) # Affiche 5
print(y) # Affiche Youssouf
Changement de type
Une variable peut changer de type selon la valeur qui lui est assignée :
Exemple
x = 4 # x est de type entier (int)
x = "Sally" # x devient de type chaîne (str)
print(x) # Affiche Sally
Conversion (casting)
Pour forcer une valeur à être d’un type spécifique, utilisez les fonctions de conversion :
x = str(3) # x devient la chaîne '3'
y = int(3) # y reste l'entier 3
z = float(3) # z devient le flottant 3.0

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 12 / 111
Vérifier le type
Utilisez la fonction type() pour connaître le type d'une variable :
print(type(x))
Chaînes de caractères
Les chaînes peuvent être définies avec des guillemets simples ou doubles :
nom = "Youssouf"
# est équivalent à
nom = Youssouf
Sensibilité à la casse
Les noms de variables sont sensibles à la casse. Par exemple, a et A représentent deux variables
différentes.
Règles de nommage
• Le nom d'une variable doit commencer par une lettre ou un underscore (_).
• Il ne peut pas commencer par un chiffre.
• Seuls les caractères alphanumériques et l'underscore sont autorisés.
• Les noms sont sensibles à la casse et ne doivent pas être des mots réservés de Python.
Noms composés
Pour améliorer la lisibilité des noms composés, plusieurs styles sont possibles :
• Camel Case : maVariable
• Pascal Case : MaVariable
• Snake Case : ma_variable
Affectation multiple
Vous pouvez affecter plusieurs valeurs à plusieurs variables en une seule ligne :
x, y, z = "Orange", "Banana", "Cherry"
Ou assigner la même valeur à plusieurs variables :
x = y = z = "Orange"
Décomposition d'une collection
Il est possible de décomposer (unpack) une collection dans des variables :
fruits = ["apple", "banana", "cherry"]
a, b, c = fruits

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 13 / 111
Affichage des variables : print()
La fonction print() permet d’afficher les valeurs. On peut séparer les variables par une
virgule, ce qui gère automatiquement les différents types :
print(x, y, z)
Variables globales et locales
• Une variable définie en dehors d'une fonction est dite globale et accessible partout.
• Une variable définie à l'intérieur d'une fonction est locale et n'est accessible qu'à
l'intérieur de cette fonction.
Pour modifier une variable globale à l'intérieur d'une fonction, utilisez le mot-clé global :
x = "Youssouf"
def ma_fonction():
global x
x = "Leila"
ma_fonction()
print("Python is " + x) # Affiche "Python is Leila"
Les Types de Données en Python
Types de Données Intégrés
En programmation, le type de données est un concept essentiel.
Une variable peut stocker des données de différents types, et chaque type possède ses propres
caractéristiques et opérations.
Python propose plusieurs types de données intégrés, classés comme suit :
Catégorie Types de données
Type Texte str
Types Numériques int, float, complex
Types de Séquence list, tuple, range
Type de Mappage dict
Types d'Ensemble set, frozenset
Type Booléen bool
Types Binaires bytes, bytearray, memoryview
Type Null NoneType
Obtenir le Type d'une Variable
On peut vérifier le type d'une variable en utilisant la fonction type() :
x = 5
print(type(x)) # Affichera <class 'int'>

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 14 / 111
Définition des Types de Données
Python attribue automatiquement un type de données à une variable en fonction de la valeur
affectée :
Exemple Type
x = "Bonjour" str
x = 20 int
x = 20.5 float
x = 1j complex
x = ["pomme", "banane", "cerise"] list
x = ("pomme", "banane", "cerise") tuple
x = range(6) range
x = {"nom": "Jean", "age": 36} dict
x = {"pomme", "banane", "cerise"} set
x = frozenset({"pomme", "banane", "cerise"}) frozenset
x = True bool
x = b"Hello" bytes
x = bytearray(5) bytearray
x = memoryview(bytes(5)) memoryview
x = None NoneType
Spécifier un Type Précis
On peut définir explicitement le type d'une variable en utilisant les fonctions constructrices :
x = str("Bonjour")
x = int(20)
x = float(20.5)
x = complex(1j)
x = list(("pomme", "banane", "cerise"))
x = tuple(("pomme", "banane", "cerise"))
x = dict(nom="Jean", age=36)
x = set(("pomme", "banane", "cerise"))
x = bool(5)
x = bytes(5)
x = bytearray(5)
x = memoryview(bytes(5))
Les Nombres en Python
Python gère trois types de nombres :
Type Description
int Nombres entiers positifs ou négatifs, sans décimales, de longueur illimitée
float Nombres à virgule flottante, incluant les nombres en notation scientifique
complex Nombres complexes avec une partie imaginaire notée j

Exemples :
x = 1 # int
y = 2.8 # float
z = 1j # complex

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 15 / 111
print(type(x))
print(type(y))
print(type(z))
Conversion de Type
On peut convertir un type numérique en un autre avec int(), float() et complex() :
x = 1 # int
y = 2.8 # float
z = 1j # complex
a = float(x) # Convertir int en float
b = int(y) # Convertir float en int
c = complex(x) # Convertir int en complex
print(type(a))
print(type(b))
print(type(c))
NB : Il est impossible de convertir un nombre complexe en un autre type numérique.
Génération de Nombres Aléatoires
Python ne possède pas de fonction random() native, mais le module random permet de générer
des nombres aléatoires :
import random
print(random.randrange(1, 10))
Le Casting en Python
Il est parfois nécessaire de définir explicitement le type d'une variable, ce que l'on appelle le
"casting". Python utilise des fonctions constructrices pour cela :
Fonction Description
int() Convertit en entier (supprime la partie décimale si présente)
float() Convertit en nombre à virgule flottante
str() Convertit en chaîne de caractères

Exemples :
x = int(1) # x vaut 1
y = int(2.8) # y vaut 2
z = int("3") # z vaut 3
x = float(1) # x vaut 1.0
y = float(2.8) # y vaut 2.8
z = float("3") # z vaut 3.0
w = float("4.2") # w vaut 4.2
x = str("s1") # x vaut 's1'
y = str(2) # y vaut '2'
z = str(3.0) # z vaut '3.0'

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 16 / 111
Chaînes de Caractères (Strings)
Définition et Affichage
Les chaînes en Python sont entourées soit de guillemets simples, soit de guillemets doubles.
Ainsi,
'hello'
est identique à :
"hello"
Pour afficher une chaîne, on utilise la fonction print() :
print("Hello")
print('Hello')
Citations dans une Chaîne
Il est possible d’utiliser des guillemets à l’intérieur d’une chaîne, à condition qu’ils diffèrent de
ceux qui encadrent la chaîne.
Exemples :
print("It's alright")
print("He is called 'Johnny'" )
print('He is called "Johnny"' )
Affecter une Chaîne à une Variable
L’affectation se fait en plaçant le nom de la variable, suivi d’un signe égal et de la chaîne.
Exemple :
a = "Hello"
print(a)
Chaînes Multilignes
Pour définir une chaîne sur plusieurs lignes, utilisez trois guillemets doubles ou simples.
a = """Le Maroc est un pays de l'hémisphère nord
situé au nord-ouest de l'Afrique et
dont le territoire est positionné à 32° nord et 5° ouest. """
print(a)
b = '''Le Maroc est un pays de l'hémisphère nord
situé au nord-ouest de l'Afrique et
dont le territoire est positionné à 32° nord et 5° ouest. '''
print(a)
NB : les sauts de ligne apparaîtront dans le résultat exactement comme dans le code.
Les Chaînes comme Tableaux
En Python, une chaîne est une séquence (tableau) de caractères.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 17 / 111
NB : Python ne possède pas de type « caractère » distinct ; un caractère est simplement
une chaîne de longueur 1.
Pour accéder à un caractère, utilisez les crochets [] en indiquant l’index (le premier caractère
a l’index 0).
Exemple :
a = "Hello, World!"
print(a[1]) # Affiche 'e'
Parcourir une Chaîne avec une Boucle
On peut parcourir une chaîne caractère par caractère avec une boucle for :
Exemple :
for x in "banana":
print(x)
Longueur d'une Chaîne
La fonction len() retourne le nombre de caractères d’une chaîne.
Exemple :
a = "Hello, World!"
print(len(a)) # Affiche 13
Vérifier la Présence d'un Sous-texte
Pour vérifier si une chaîne contient un mot ou un caractère, utilisez l’opérateur in (ou not
in pour vérifier l'absence).
Exemples :
txt = "The best things in life are free!"
print("free" in txt) # Retourne True
if "free" in txt:
print("Yes, 'free' is present." )
print("expensive" not in txt) # Retourne True
if "expensive" not in txt:
print("No, 'expensive' is NOT present." )
Slicing (Découper une Chaîne)
Le découpage (slicing) permet d’extraire une partie d’une chaîne en spécifiant l’index de
début et l’index de fin (NB : l’index de fin n’est pas inclus).
Description Code Résultat
Caractères de l’index 2 à 4 print(b[2:5]) Extrait positions 2 à 4
Du début jusqu’à l’index 4 print(b[:5]) Extrait les 5 premiers caractères
De l’index 2 jusqu’à la fin print(b[2:]) Extrait du 3ᵉ caractère à la fin
Utilisation d’index négatifs print(b[-5:-2]) Extrait une tranche depuis la fin

Exemple :
b = "Hello, World!"

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 18 / 111
print(b[2:5]) # Affiche 'llo'
print(b[:5]) # Affiche 'Hello'
print(b[2:]) # Affiche 'llo, World!'
print(b[-5:-2]) # Affiche 'orl'
Modifier des Chaînes
Python propose plusieurs méthodes intégrées pour manipuler les chaînes.
Opération Méthode Exemple d’utilisation
Mettre en majuscules upper() print(a.upper())
Mettre en minuscules lower() print(a.lower())
Supprimer les espaces strip() print(a.strip()) # retire les
espaces avant et après
Remplacer une sous-chaîne replace() print(a.replace("H", "J"))
Séparer la chaîne split() print(a.split(",")) # coupe la
chaîne aux virgules

Exemples :
a = "Hello, World!"
print(a.upper()) # 'HELLO, WORLD!'
print(a.lower()) # 'hello, world!'
print(a.strip()) # Si a = " Hello, World! ", affiche "Hello, World!"
print(a.replace("H", "J")) # Remplace 'H' par 'J'
print(a.split(",")) # Retourne ['Hello', ' World!']
Concaténation de Chaînes
Pour combiner (concaténer) deux chaînes, utilisez l’opérateur +.
Exemples :
a = "Hello"
b = "World"
c = a + b
print(c) # Affiche 'HelloWorld'
# Pour ajouter un espace :
c = a + " " + b
print(c) # Affiche 'Hello World'
Formatage de Chaînes
Problème de Base
On ne peut pas combiner directement chaînes et nombres, par exemple :
age = 36
# Ceci provoque une erreur :
txt = "My name is Youssouf, I am " + age
Utiliser les f-strings (Python 3.6+)
Les f-strings permettent d’insérer des variables et des expressions directement dans une chaîne
en plaçant un f devant la chaîne et en utilisant des accolades {}.
Exemples :

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 19 / 111
age = 99
txt = f"My name is Youssouf, I am {age}"
print(txt) # Affiche 'My name is Youssouf, I am 36'
price = 59
txt = f"The price is {price:.2f} dollars"
print(txt) # Affiche 'The price is 59.00 dollars'
# Avec une opération mathématique :
txt = f"The price is {20 * 59} dollars"
print(txt)
Caractères d’Échappement
Les caractères d’échappement permettent d’insérer des caractères spéciaux dans une chaîne,
grâce au caractère antislash \.
Exemple :
txt = "We are the so-called \"good developers\" from Morocco."
print(txt)
Tableau récapitulatif des caractères d’échappement :
Code Résultat Exemple dans le code
\' Guillemets simples 'It\'s alright'
\\ Antislash "C:\\Program Files"
\n Nouvelle ligne "Première ligne\nDeuxième ligne"
\r Retour chariot

\t Tabulation "Nom:\tYoussouf"
\b Retour arrière

\f Saut de page

\ooo Valeur octale

\xhh Valeur hexadécimale

Méthodes de Chaînes (String Methods)
Python met à disposition de nombreuses méthodes pour manipuler les chaînes. Toutes renvoient
une nouvelle chaîne sans modifier l’originale.
Tableau récapitulatif de quelques méthodes utiles :
Méthode Description
capitalize() Met en majuscule la première lettre
casefold() Convertit la chaîne en minuscules
center() Centre la chaîne dans un espace donné
count() Compte le nombre d’occurrences d’une sous-chaîne
encode() Encode la chaîne
endswith() Retourne True si la chaîne se termine par la valeur spécifiée
find() Recherche une sous-chaîne et retourne son index
index() Similaire à find(), mais génère une erreur si la sous-chaîne n'est pas trouvée
isalnum() Retourne True si tous les caractères sont alphanumériques
isalpha() Retourne True si tous les caractères sont alphabétiques
isdigit() Retourne True si la chaîne contient uniquement des chiffres
islower() Retourne True si la chaîne est en minuscules

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 20 / 111
isupper() Retourne True si la chaîne est en majuscules
join() Joint les éléments d’un itérable à l’aide de la chaîne
lstrip() Supprime les espaces à gauche
rstrip() Supprime les espaces à droite
split() Découpe la chaîne en une liste selon un séparateur donné
strip() Supprime les espaces en début et fin
swapcase() Inverse la casse (majuscules ↔ minuscules)
title() Met en majuscule la première lettre de chaque mot
upper() Convertit la chaîne en majuscules
zfill() Complète la chaîne avec des zéros au début pour atteindre une largeur donnée
Les Opérateurs en Python
Les opérateurs sont utilisés pour effectuer des opérations sur des variables et des valeurs.
Par exemple, l’opérateur + permet d’additionner deux nombres :
print(10 + 5)
Python classe les opérateurs en plusieurs catégories :
• Les opérateurs arithmétiques
• Les opérateurs d’affectation
• Les opérateurs de comparaison
• Les opérateurs logiques
• Les opérateurs d’identité
• Les opérateurs d’appartenance
• Les opérateurs binaires (bitwise)
Les opérateurs arithmétiques
Ils servent à effectuer des opérations mathématiques :
Opérateur Nom Exemple
+ Addition x + y
- Soustraction x - y
* Multiplication x * y
/ Division x / y
% Modulo (reste) x % y
** Exponentiation x ** y
// Division entière x // y
Les opérateurs d’affectation
Ces opérateurs permettent d’attribuer une valeur à une variable :
Opérateur Exemple Équivaut à
= x = 5 x = 5
+= x += 3 x = x + 3

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 21 / 111
-= x -= 3 x = x - 3
*= x *= 3 x = x * 3
/= x /= 3 x = x / 3
%= x %= 3 x = x % 3
//= x //= 3 x = x // 3
**= x **= 3 x = x ** 3
Les opérateurs de comparaison
Ils sont utilisés pour comparer deux valeurs :
Opérateur Nom Exemple
== Égalité x == y
!= Différent x != y
> Supérieur x > y
< Inférieur x < y
>= Supérieur ou égal x >= y
<= Inférieur ou égal x <= y
Les opérateurs logiques
Ces opérateurs permettent de combiner des conditions :
Opérateur Description Exemple
and Retourne True si les deux conditions sont vraies x < 5 and x < 10
or Retourne True si au moins une condition est vraie x < 5 or x < 4
not Inverse le résultat (True devient False et inversement) not(x < 5 and x < 10)
Les opérateurs d’identité
Ils permettent de vérifier si deux objets sont identiques en mémoire :
Opérateur Description Exemple
is Retourne True si les variables pointent vers le même objet x is y
is not Retourne True si les variables ne pointent pas vers le même objet x is not y
Les opérateurs d’appartenance
Ils permettent de vérifier si une valeur fait partie d’un ensemble (liste, tuple, chaîne de
caractères, etc.) :
Opérateur Description Exemple
in Retourne True si l’élément est présent x in y
not in Retourne True si l’élément est absent x not in y
Les opérateurs binaires (bitwise)
Ces opérateurs travaillent au niveau binaire (bits) :
Opérateur Nom Description Exemple
& ET binaire Met à 1 les bits communs à 1 x & y
` ` OU binaire Met à 1 les bits à 1 dans x ou y
^ XOR binaire Met à 1 les bits différents entre x et y x ^ y

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 22 / 111
~ NON binaire Inverse les bits ~x
<< Décalage gauche Décale les bits vers la gauche en ajoutant
des 0
x << 2
>> Décalage droit Décale les bits vers la droite x >> 2
Ordre de priorité des opérateurs en Python
L’ordre de priorité des opérateurs indique quelle opération est effectuée en premier lorsqu'il y
a plusieurs opérateurs dans une même expression.
Exemples :
# Les parenthèses sont prioritaires :
print((6 + 3) - (6 + 3)) # Résultat : 0
# La multiplication * est prioritaire sur l’addition + :
print(100 + 5 * 3) # Résultat : 115
Voici le classement des opérateurs du plus prioritaire au moins prioritaire :
Ordre Opérateur Description
1 () Parenthèses
2 ** Exponentiation
3 +x, -x, ~x Opérateurs unaires (+, -, ~)
4 *, /, //, % Multiplication, division, division entière et modulo
5 +, - Addition et soustraction
6 <<, >> Décalage binaire gauche et droit
7 & ET binaire
8 ^ XOR binaire
9 ` `
10
==, !=, >, <, >=, <=, is, is not, in, not
in
Comparaisons, opérateurs d’identité et
d’appartenance
11 not NON logique
12 and ET logique
13 or OU logique
NB : Si deux opérateurs ont la même priorité, l'évaluation se fait de gauche à droite.
Exemple :
print(5 + 4 - 7 + 3) # Résultat : 5
Les Structures Conditionnelles et Itératives en Python
Ce chapitre aborde les structures de contrôle de flux en Python, qui se répartissent en deux
grandes catégories :
1. Les instructions de test (structures conditionnelles) permettant d'exécuter un bloc de
code en fonction d'une condition donnée.
2. Les instructions de répétition (structures itératives) permettant de répéter un bloc de
code tant qu'une condition est vérifiée ou de parcourir des séquences de données.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 23 / 111
Les Instructions de Test
Les instructions conditionnelles sont essentielles pour la prise de décision dans un programme.
En Python, plusieurs structures conditionnelles permettent d’orienter l’exécution du code en
fonction de conditions précises.
La Structure Conditionnelle if
L’instruction if est la plus couramment utilisée pour exécuter un bloc de code lorsque la
condition spécifiée est vraie. Il est fréquent de la combiner avec les clauses elif et else pour
couvrir plusieurs cas.
Exemple :
x = 10
if x > 0:
print("x est positif")
elif x == 0:
print("x est nul")
else:
print("x est négatif")
Explications :
• if x > 0:
Cette condition teste si la variable x est strictement supérieure à 0. Si c’est le cas, le message
"x est positif" est affiché.
• elif x == 0:
Si la première condition n’est pas satisfaite, Python vérifie si x est égal à 0. Dans ce cas, il
affiche "x est nul".
• else:
Si aucune des conditions précédentes n’est remplie (donc si x est négatif), le message "x est
négatif" est affiché.
La Structure Conditionnelle match-case (équivalent du switch)
Depuis Python 3.10, l’instruction match-case offre une alternative plus expressive aux
instructions if-elif-else pour traiter des cas spécifiques, à la manière d’un switch dans
d’autres langages.
Exemple :
status = 2
match status:
case 1:
print("En attente")
case 2:
print("En cours")
case 3:
print("Terminé")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 24 / 111
case _:
print("Statut inconnu")
Explications :
• match status:
Cette instruction compare la variable status avec différentes valeurs ou motifs.
• case 1:, case 2:, case 3:
Chaque clause case teste la valeur de status. Lorsqu’un cas correspond, le bloc de code
associé est exécuté.
• case _:
Le caractère _ est utilisé pour capturer tous les autres cas non spécifiés, agissant ainsi comme
une clause default.
Les Instructions de Répétition
Les structures itératives permettent de répéter l’exécution d’un bloc de code soit sur la base
d’une condition, soit en parcourant des éléments d’une séquence.
La Boucle for
La boucle for en Python est utilisée pour parcourir des séquences (listes, tuples, chaînes de
caractères, etc.) ou pour itérer sur des plages de nombres à l’aide de la fonction range().
Exemple avec une liste :
for i in [1, 2, 3, 4, 5]:
print(i)

Exemple avec range() :
for i in range(5): # i varie de 0 à 4
print(i)

Exemple avec enumerate() :
fruits = ["pomme", "banane", "cerise"]
for index, fruit in enumerate(fruits):
print(f"Index {index}: {fruit}")
Explications :
• Dans le premier exemple, la boucle itère directement sur les éléments de la liste.
• La fonction range(5) génère une séquence de nombres de 0 à 4, ce qui est utile pour
répéter un bloc de code un nombre défini de fois.
• enumerate() permet de récupérer à la fois l’index et la valeur lors du parcours d’une
séquence, ce qui facilite la référence à la position de chaque élément.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 25 / 111
La Boucle while
La boucle while exécute un bloc de code tant qu’une condition est vraie. Il est crucial
d’implémenter une condition d’arrêt pour éviter les boucles infinies.
Exemple de base :
x = 0
while x < 5:
print(x)
x += 1 # Incrémentation pour éviter une boucle infinie

Exemple avec l’instruction break :
x = 0
while x < 10:
if x == 5:
break # Sort de la boucle lorsque x vaut 5
print(x)
x += 1

Exemple avec l’instruction continue :
x = 0
while x < 5:
x += 1
if x == 3:
continue # Ignore l'itération lorsque x vaut 3
print(x)
Explications :
• Boucle while de base :
La boucle continue tant que la condition x < 5 est vraie. L’incrémentation de x est essentielle
pour garantir que la condition finisse par devenir fausse.
• Instruction break :
L’instruction break permet de sortir immédiatement de la boucle, quel que soit le reste de la
condition. Ici, lorsque x atteint 5, la boucle se termine.
• Instruction continue :
L’instruction continue permet de passer directement à l’itération suivante de la boucle, en
ignorant les instructions restantes pour l’itération courante. Dans l’exemple, lorsque x vaut 3,
l’instruction print(x) n’est pas exécutée pour cette itération.
Fonctions en Python
Une fonction est un bloc de code qui ne s'exécute que lorsqu'elle est appelée.
Vous pouvez lui transmettre des données, appelées paramètres, et elle peut renvoyer des
données en guise de résultat.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 26 / 111
Création d'une fonction
En Python, une fonction se définit à l'aide du mot-clé def :
Exemple
def ma_fonction():
print("Bonjour depuis une fonction" )
Appeler une fonction
Pour appeler une fonction, il suffit d'utiliser son nom suivi de parenthèses :
Exemple
ma_fonction()
Arguments
Les données peuvent être transmises aux fonctions sous forme d'arguments. Ces arguments sont
spécifiés après le nom de la fonction, à l'intérieur des parenthèses. Vous pouvez en ajouter
autant que nécessaire, en les séparant par des virgules.
L'exemple suivant présente une fonction avec un argument (nom). Lorsqu'on appelle la fonction,
on lui transmet un prénom qui est utilisé pour afficher un nom complet :
Exemple
def ma_fonction(nom):
print("Bonjour " + nom)

ma_fonction("Youssouf")
ma_fonction("Leila")
ma_fonction("Ali")
Dans la documentation Python, les arguments sont souvent abrégés en args.
Paramètres ou Arguments ?
Les termes paramètre et argument désignent la même chose : les informations transmises à une
fonction.
Du point de vue de la fonction :
Paramètre : La variable indiquée entre les parenthèses dans la définition de la fonction.
Argument : La valeur qui est envoyée à la fonction lors de son appel.
Nombre d'arguments
Par défaut, une fonction doit être appelée avec le nombre exact d'arguments attendu. Autrement
dit, si une fonction attend 2 arguments, vous devez l'appeler avec exactement 2 arguments, ni
plus ni moins.
Exemple : Cette fonction attend 2 arguments et en reçoit bien 2 :
def ma_fonction(prenom, nom):

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 27 / 111
print(prenom + " " + nom)

ma_fonction("Youssouf", "EL ALLIOUI")
Si vous essayez d'appeler la fonction avec 1 ou 3 arguments, une erreur sera générée :
Exemple : Cette fonction attend 2 arguments, mais n'en reçoit qu'un :
def ma_fonction(prenom, nom):
print(prenom + " " + nom)

ma_fonction("Youssouf")
Arguments arbitraires (*args)
Si vous ne savez pas combien d'arguments seront passés à votre fonction, ajoutez un astérisque
(*) avant le nom du paramètre dans la définition. La fonction recevra alors un tuple contenant
tous les arguments, que vous pourrez parcourir :
Exemple
def ma_fonction(*enfants):
print("Le plus jeune enfant est " + enfants[2])

ma_fonction("Ali", "Leila", "Khalid")
NB : Dans la documentation Python, on abrège souvent les arguments arbitraires
par *args.
Arguments nommés (Keyword Arguments)
Vous pouvez également transmettre des arguments en utilisant la syntaxe clé = valeur. Ainsi,
l'ordre des arguments n'a pas d'importance.
Exemple
def ma_fonction(enfant3, enfant2, enfant1 ):
print("Le plus jeune enfant est " + enfant3)

ma_fonction(enfant1="Ali", enfant2="Leila", enfant3="Khalid")
NB : Les arguments nommés sont souvent abrégés par kwargs dans la documentation
Python.
Arguments nommés arbitraires (**kwargs)
Si vous ne connaissez pas le nombre d'arguments nommés qui seront transmis à votre fonction,
ajoutez deux astérisques (**) avant le nom du paramètre dans la définition. La fonction recevra
alors un dictionnaire contenant ces arguments.
Exemple
def ma_fonction(**enfant):
print("Son nom de famille est " + enfant["lname"])

ma_fonction(fname="Youssouf", lname="EL ALLIOUI")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 28 / 111
NB : Les arguments nommés arbitraires sont également souvent abrégés
par **kwargs dans la documentation Python.
Valeur par défaut d'un paramètre
L'exemple suivant montre comment utiliser une valeur par défaut pour un paramètre. Si la
fonction est appelée sans argument, elle utilise la valeur par défaut spécifiée :
Exemple
def ma_fonction(pays="Maroc"):
print("Je viens de " + pays)

ma_fonction("Suède")
ma_fonction("Inde")
ma_fonction()
ma_fonction("Brésil")
Passer une liste en argument
Vous pouvez transmettre n'importe quel type de donnée à une fonction (chaîne, nombre, liste,
dictionnaire, etc.) et elle sera traitée comme son type d'origine. Par exemple, si vous passez une
liste, elle sera perçue comme une liste à l'intérieur de la fonction :
Exemple
def ma_fonction(aliments):
for aliment in aliments:
print(aliment)

fruits = ["pomme", "banane", "cerise"]

ma_fonction(fruits)
Valeurs de retour
Pour qu'une fonction renvoie une valeur, utilisez l'instruction return :
Exemple
def ma_fonction(x):
return 5 * x

print(ma_fonction(3))
print(ma_fonction(5))
print(ma_fonction(9))
L'instruction pass
La définition d'une fonction ne peut pas être vide. Si, pour une raison ou une autre, vous
souhaitez définir une fonction sans contenu, utilisez l'instruction pass pour éviter une erreur :
Exemple
def ma_fonction():
pass

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 29 / 111
Arguments uniquement positionnels
Vous pouvez indiquer qu'une fonction accepte seulement des arguments positionnels en
ajoutant , / après la liste des paramètres :
Exemple
def ma_fonction(x, /):
print(x)

ma_fonction(3)
Sans , /, il est possible d'utiliser des arguments nommés même pour des paramètres
positionnels :
Exemple
def ma_fonction(x):
print(x)

ma_fonction(x=3)
Mais avec , /, tenter de passer un argument nommé provoquera une erreur :
Exemple
def ma_fonction(x, /):
print(x)

ma_fonction(x=3) # Erreur
Arguments uniquement nommés
Pour spécifier qu'une fonction accepte seulement des arguments nommés, placez un astérisque
(*) avant la liste des paramètres :
Exemple
def ma_fonction(*, x):
print(x)

ma_fonction(x=3)
Sans *, vous pouvez utiliser des arguments positionnels :
Exemple
def ma_fonction(x):
print(x)

ma_fonction(3)
Mais avec *, passer un argument positionnel provoquera une erreur :
Exemple
def ma_fonction(*, x):
print(x)

ma_fonction(3) # Erreur

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 30 / 111
Combiner arguments uniquement positionnels et uniquement nommés
Il est possible de combiner ces deux types dans une même fonction. Les arguments situés
avant / sont uniquement positionnels, et ceux situés après * sont uniquement nommés.
Exemple
def ma_fonction(a, b, /, *, c, d):
print(a + b + c + d)

ma_fonction(5, 6, c=7, d=8)
Récursion
Python prend en charge la récursion, ce qui signifie qu'une fonction peut s'appeler elle-même.
La récursion est un concept courant en mathématiques et en programmation, permettant de
parcourir des données jusqu'à atteindre un résultat.
Il faut toutefois faire preuve de prudence, car une récursion mal gérée peut entraîner des
fonctions qui ne se terminent jamais ou qui consomment trop de ressources (mémoire ou
processeur). Lorsqu'elle est correctement utilisée, la récursion constitue une approche élégante
et efficace.
Dans l'exemple ci-dessous, la fonction tri_recursion() s'appelle elle-même. La
variable k est utilisée comme donnée et se décrémente de 1 à chaque appel récursif. La
récursion s'arrête lorsque k n'est plus supérieur à 0 (c'est-à-dire lorsqu'il atteint 0). Pour un
développeur débutant, il peut être utile de tester et de modifier ce code afin de mieux
comprendre son fonctionnement.
Exemple
def tri_recursion(k):
if k > 0:
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result

print("Résultats de l'exemple de récursion :" )
tri_recursion(6)
Fonctions Lambda en Python
Une fonction lambda est une petite fonction anonyme qui peut prendre un nombre quelconque
d'arguments, mais ne peut contenir qu'une seule expression.
La syntaxe est la suivante :
lambda arguments : expression
L'expression est exécutée et son résultat est renvoyé.
Exemple : Ajouter 10 à l'argument a et renvoyer le résultat :
x = lambda a: a + 10
print(x(5))

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 31 / 111
Les fonctions lambda peuvent également prendre plusieurs arguments :
Exemple : Multiplier l'argument a par l'argument b et renvoyer le résultat :
x = lambda a, b: a * b
print(x(5, 6))

Exemple : Additionner les arguments a, b et c et renvoyer le résultat :
x = lambda a, b, c: a + b + c
print(x(5, 6, 2))
Pourquoi utiliser les fonctions lambda ?
Les fonctions lambda prennent tout leur sens lorsqu'elles sont utilisées comme fonctions
anonymes à l'intérieur d'autres fonctions. Par exemple, supposons que vous ayez une fonction
qui prend un argument et qui doit multiplier cet argument par un nombre inconnu :
def ma_fonction(n):
return lambda a: a * n
Utilisez cette définition pour créer une fonction qui double toujours le nombre transmis :
Exemple
def ma_fonction(n):
return lambda a: a * n

doubleur = ma_fonction( 2)
print(doubleur(11))
Ou pour créer une fonction qui triple toujours le nombre transmis :
Exemple
def ma_fonction(n):
return lambda a: a * n

tripleur = ma_fonction( 3)
print(tripleur(11))
Il est également possible de créer les deux fonctions dans le même programme :
Exemple
def ma_fonction(n):
return lambda a: a * n

doubleur = ma_fonction( 2)
tripleur = ma_fonction( 3)

print(doubleur(11))
print(tripleur(11))
Utilisez les fonctions lambda lorsqu'une fonction anonyme est nécessaire pour une courte
durée.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 32 / 111
Saisie Utilisateur en Python
Python permet d'obtenir des entrées de l'utilisateur, ce qui signifie que nous pouvons lui
demander de fournir des informations pendant l'exécution du programme.
Méthode de Saisie
La méthode de saisie diffère légèrement entre Python 3.6 et Python 2.7 :
• Python 3.6 utilise la fonction input().
• Python 2.7 utilise la fonction raw_input().
Exemple en Python 3.6
Le code suivant demande à l'utilisateur d'entrer son nom d'utilisateur et affiche ensuite la saisie:
username = input("Enter username: ")
print("Username is: " + username)
Exemple en Python 2.7
Pour Python 2.7, utilisez la fonction raw_input() :
username = raw_input("Enter username: ")
print "Username is: " + username
Lors de l'exécution, Python suspend l'exécution dès qu'il rencontre la
fonction input() (ou raw_input() en Python 2.7) et attend que l'utilisateur saisisse une
réponse. Le programme reprend ensuite son exécution une fois que l'entrée a été fournie.
Formatage de Chaînes en Python
Depuis Python 3.6, les f-strings (littéraux formatés) sont la méthode privilégiée pour formater
des chaînes de caractères. Avant Python 3.6, on utilisait la méthode format().
F-Strings
Les f-strings permettent d'insérer et de formater directement des valeurs dans une chaîne. Pour
définir une f-string, il suffit de préfixer la chaîne par la lettre f.
Exemple :
txt = f"The price is 49 dollars"
print(txt)
Espaces réservés et Modificateurs
Pour insérer des valeurs dans une f-string, on utilise des espaces réservés encadrés par des
accolades {}. Ces espaces peuvent contenir des variables, des expressions, des fonctions ou
même des modificateurs de formatage.
Exemple :
price = 59
txt = f"The price is {price} dollars"

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 33 / 111
print(txt)
On peut également appliquer des modificateurs pour formater la valeur. Par exemple, le
modificateur :.2f permet d'afficher un nombre en notation décimale fixe avec 2 décimales.
Exemple :
price = 59
txt = f"The price is {price:.2f} dollars"
print(txt)
Il est aussi possible de formater directement une valeur sans la stocker dans une variable :
Exemple :
txt = f"The price is {95:.2f} dollars"
print(txt)
Opérations dans les F-Strings
Les f-strings permettent d'effectuer des opérations directement dans les accolades.
Opérations Mathématiques
Vous pouvez réaliser des opérations mathématiques :
Exemple :
txt = f"The price is {20 * 59} dollars"
print(txt)
Ou encore sur des variables :
Exemple :
price = 59
tax = 0.25
txt = f"The price is {price + (price * tax)} dollars"
print(txt)
Conditions Inline (if...else)
Vous pouvez aussi intégrer des expressions conditionnelles :
Exemple :
price = 49
txt = f"It is very {'Expensive' if price > 50 else 'Cheap'}"
print(txt)
Exécution de Fonctions
Les f-strings permettent d'exécuter des fonctions directement dans l'espace réservé.
Exemple :
fruit = "apples"
txt = f"I love {fruit.upper()}"
print(txt)
Vous pouvez aussi utiliser vos propres fonctions :
Exemple :
def myconverter(x):

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 34 / 111
return x * 0.3048

txt = f"The plane is flying at a {myconverter(30000)} meter altitude"
print(txt)
Autres Modificateurs
Vous pouvez appliquer d'autres modificateurs de formatage pour contrôler l'apparence des
valeurs. Par exemple, pour utiliser une virgule comme séparateur de milliers :
Exemple :
price = 59000
txt = f"The price is {price:,} dollars"
print(txt)
Liste des Types de Formatage
Voici une liste non exhaustive des modificateurs que vous pouvez utiliser dans les f-strings :
Modificateur Description
:< Aligne à gauche dans l'espace disponible
:> Aligne à droite dans l'espace disponible
:^ Centre dans l'espace disponible
:= Place le signe à la position la plus à gauche
:+ Affiche un signe plus pour les valeurs positives
:- Affiche le signe moins uniquement pour les valeurs négatives
: Ajoute un espace avant les nombres positifs
:, Utilise une virgule comme séparateur de milliers
:_ Utilise un underscore comme séparateur de milliers
:b Format binaire
:c Convertit en caractère Unicode correspondant
:d Format décimal
:e Format scientifique (lettre e minuscule)
:E Format scientifique (lettre E majuscule)
:f Nombre à point fixe
:F Nombre à point fixe en majuscules (pour inf et nan : INF, NAN)
:g Format général
:G Format général (scientifique avec E majuscule si nécessaire)
:o Format octal
:x Format hexadécimal (lettres minuscules)
:X Format hexadécimal (lettres majuscules)
:n Format numérique
:% Format pourcentage
La Méthode format()
Avant Python 3.6, on utilisait la méthode format() pour formater des chaînes. Bien qu'elle
puisse toujours être utilisée, les f-strings sont plus rapides et plus simples.
Exemple Simple
Exemple :
price = 49

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 35 / 111
txt = "The price is {} dollars"
print(txt.format(price))
Spécifier le Format
Vous pouvez ajouter des paramètres à l'intérieur des accolades pour préciser le format :
Exemple :
txt = "The price is {:.2f} dollars"
print(txt.format(price))
Plusieurs Valeurs
Si vous souhaitez utiliser plusieurs valeurs, ajoutez-les dans la méthode format() et insérez
autant d'espaces réservés dans la chaîne.
Exemple :
quantity = 3
itemno = 567
price = 49
myorder = "I want {} pieces of item number {} for {:.2f} dollars."
print(myorder.format(quantity, itemno, price))
Utilisation d'Indices
Pour être sûr que les valeurs se placent aux bons emplacements, vous pouvez utiliser des indices
dans les accolades.
Exemple :
quantity = 3
itemno = 567
price = 49
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))
Vous pouvez également référencer la même valeur plusieurs fois en utilisant son indice.
Exemple :
age = 36
name = "John"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))
Utilisation d'Indices Només
Vous pouvez également utiliser des noms dans les accolades et passer des arguments nommés
à la méthode format().
Exemple :
myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname="Ford", model="Mustang"))
Conclusion
L’apprentissage des bases de la programmation en Python constitue une étape incontournable.
Grâce aux notions développées ici, les étudiants disposent désormais des outils conceptuels et

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 36 / 111
syntaxiques pour modéliser des algorithmes simples, interagir avec l’utilisateur, et construire
des logiques conditionnelles. Ces compétences fondamentales préparent l’étudiant à manipuler
des structures de données plus élaborées, que nous aborderons dans le Chapitre 3.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 37 / 111
Chapitre 3 : Structures de données en Python
L’étude des structures de données en Python constitue une étape essentielle dans la maîtrise de
ce langage, permettant de manipuler et d’organiser efficacement l’information. Python offre
quatre types de collections intégrées :
• les listes,
• les tuples,
• les ensembles (sets), et
• les dictionnaires.
Chacune de ces structures présente des caractéristiques propres qui les rendent adaptées à des
contextes d’utilisation variés.
Les listes sont des collections ordonnées et modifiables, permettant de stocker plusieurs
éléments au sein d’une même variable. Elles se distinguent notamment par la possibilité de
contenir des doublons et d’être facilement manipulées grâce à un large éventail de méthodes
(ajout, suppression, tri, etc.).
Les tuples, quant à eux, sont similaires aux listes sur le plan de l’ordonnancement, mais se
révèlent immuables, ce qui les rend idéaux pour stocker des données qui ne doivent pas être
altérées une fois définies.
Les ensembles offrent une approche différente en mettant l’accent sur l’unicité des éléments.
Bien qu’ils soient non ordonnés, les ensembles permettent des opérations de comparaison et de
regroupement efficaces, comme l’union ou l’intersection, et s’avèrent particulièrement utiles
pour éliminer les doublons.
Enfin, les dictionnaires permettent d’associer des clés à des valeurs, offrant ainsi une structure
de données optimisée pour des recherches rapides et des manipulations basées sur des
identifiants uniques. Leur caractère ordonné (à partir de Python 3.7) et modifiable en fait un
outil indispensable dans la conception de programmes complexes.
Ce chapitre propose une exploration détaillée de ces quatre types de collections, en mettant en
lumière leurs caractéristiques, leurs méthodes d’accès et de modification, ainsi que leurs
avantages et limitations respectifs. L’objectif est de fournir une base solide pour comprendre
comment ces structures facilitent le traitement et l’organisation des données, et comment elles
peuvent être exploitées dans divers contextes d’applications informatiques.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 38 / 111
Listes en Python
Les listes sont utilisées pour stocker plusieurs éléments dans une seule variable. Elles sont
créées en utilisant des crochets [].
Exemple : Création d'une liste
thislist = ["apple", "banana", "cherry"]
print(thislist)
Caractéristiques des listes
Ordonnées
Les listes conservent l'ordre des éléments. Même après l'ajout de nouveaux éléments, ceux-ci
seront placés à la fin.
Modifiables
Les listes sont mutables, ce qui signifie que nous pouvons modifier, ajouter et supprimer des
éléments après leur création.
Autorisation des doublons
Les listes autorisent plusieurs occurrences du même élément.
Exemple : Liste avec des doublons
thislist = ["apple", "banana", "cherry", "apple", "cherry"]
print(thislist)
Longueur d'une liste
On peut obtenir la longueur d'une liste en utilisant la fonction len().
Exemple :
thislist = ["apple", "banana", "cherry"]
print(len(thislist))
Types de données dans une liste
Une liste peut contenir des éléments de différents types de données :
list1 = ["apple", "banana", "cherry"]
list2 = [1, 5, 7, 9, 3]
list3 = [True, False, False]
list4 = ["abc", 34, True, 40, "male"]
On peut vérifier le type d'une liste avec type() :
mylist = ["apple", "banana", "cherry"]
print(type(mylist)) # Affichera : <class 'list'>
Création d'une liste avec le constructeur list()
thislist = list(("apple", "banana", "cherry")) # Notez les doubles
parenthèses

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 39 / 111
print(thislist)
Accès aux éléments d'une liste
Accès par index
thislist = ["apple", "banana", "cherry"]
print(thislist[1]) # Affichera "banana"
Indexation négative
thislist = ["apple", "banana", "cherry"]
print(thislist[-1]) # Affichera "cherry"
Tranches d'index (slicing)
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5]) # Affichera ["cherry", "orange", "kiwi"]
print(thislist[:4]) # Affichera ["apple", "banana", "cherry", "orange"]
print(thislist[2:]) # Affichera ["cherry", "orange", "kiwi", "melon",
"mango"]
Vérification de l'existence d'un élément
thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
print("Oui, 'apple' est dans la liste")
Modification des éléments d'une liste
Changer un élément spécifique
thislist = ["apple", "banana", "cherry"]
thislist[1] = "blackcurrant"
print(thislist) # Affichera ["apple", "blackcurrant", "cherry"]
Changer une plage d'éléments
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]
thislist[1:3] = ["blackcurrant", "watermelon"]
print(thislist)
Remplacer un élément par plusieurs
thislist = ["apple", "banana", "cherry"]
thislist[1:2] = ["blackcurrant", "watermelon"]
print(thislist)
Remplacer plusieurs éléments par un seul
thislist = ["apple", "banana", "cherry"]
thislist[1:3] = ["grape"]
print(thislist) # Affichera ["apple", "grape"]

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 40 / 111
Tableau récapitulatif des fonctions utiles
Fonction Description Exemple
append(x) Ajoute un élément à la fin de la liste lst.append("orange")
insert(i, x) Insère un élément x à l’index i lst.insert(1, "kiwi")
remove(x) Supprime la première occurrence de x lst.remove("pomme")
pop(i)
Supprime l’élément à l’index i (ou le
dernier si i est omis)
lst.pop(2)
index(x)
Retourne l’index de la première occurrence
de x
lst.index("cerise")
count(x) Compte le nombre d’occurrences de x lst.count("banane")
sort() Trie la liste en place lst.sort()
reverse() Inverse l’ordre des éléments lst.reverse()
copy() Crée une copie de la liste new_list = lst.copy()
clear() Supprime tous les éléments de la liste lst.clear()
Ce tableau résume les principales méthodes utilisées pour manipuler les listes en Python. Ces
fonctions permettent d'effectuer différentes opérations essentielles telles que l'ajout, la
suppression, le tri ou encore l'extraction d'éléments spécifiques d'une liste.
Tuples en Python
Un tuple est une collection ordonnée et immuable (unchangeable). Les tuples sont écrits
entre parenthèses.
Exemple :
mytuple = ("apple", "banana", "cherry")
print(mytuple)
Caractéristiques des Tuples
• Ordonnés : Les tuples conservent l'ordre des éléments.
• Immutables : Une fois créés, leurs éléments ne peuvent pas être modifiés.
• Permettent les doublons : Un tuple peut contenir plusieurs occurrences d'une même
valeur.
Exemple de tuple avec valeurs dupliquées :
thistuple = ("apple", "banana", "cherry", "apple", "cherry")
print(thistuple)
Longueur d'un Tuple
Utilisez len() pour déterminer le nombre d'éléments dans un tuple.
Exemple :
thistuple = ("apple", "banana", "cherry")
print(len(thistuple))
Création d'un Tuple avec un Seul Élément
Pour créer un tuple avec un seul élément, ajoutez une virgule après l'élément.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 41 / 111
Exemple :
thistuple = ("apple",) # Tuple valide
print(type(thistuple))
thistuple = ("apple") # Ce n'est pas un tuple, mais une chaîne de caractères
print(type(thistuple))
Types de Données dans un Tuple
Les éléments d'un tuple peuvent être de différents types.
Exemple :
tuple1 = ("apple", "banana", "cherry") # Chaînes
tuple2 = (1, 5, 7, 9, 3) # Entiers
tuple3 = (True, False, False) # Booléens
tuple4 = ("abc", 34, True, 40, "male") # Types mixtes
Création d'un Tuple avec le Constructeur tuple()
Exemple :
thistuple = tuple(("apple", "banana", "cherry")) # Remarque : double
parenthèse
print(thistuple)
Accéder aux Éléments d'un Tuple
Les tuples étant indexés, on peut accéder à leurs éléments en utilisant les indices.
Exemple :
thistuple = ("apple", "banana", "cherry")
print(thistuple[1]) # Affiche "banana"
Indexation Négative
L'index -1 correspond au dernier élément, -2 à l'avant-dernier, etc.
print(thistuple[-1]) # Affiche "cherry"
Plage d'Index
On peut spécifier une plage pour obtenir une sous-partie du tuple.
print(thistuple[1:3]) # Affiche ('banana', 'cherry')
Vérifier l'Existence d'un Élément
Utilisez in pour vérifier si un élément est présent.
if "apple" in thistuple:
print("Oui, 'apple' est présent dans le tuple")
Modification d'un Tuple
Les tuples sont immuables, mais on peut contourner cette limitation en le convertissant en liste.
Exemple :
x = ("apple", "banana", "cherry")
y = list(x)

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 42 / 111
y[1] = "kiwi"
x = tuple(y)
print(x) # ('apple', 'kiwi', 'cherry')
Ajouter des Élément à un Tuple
Conversion en liste :
thistuple = ("apple", "banana", "cherry")
y = list(thistuple)
y.append("orange")
thistuple = tuple(y)
Concaténation de Tuples :
tuple1 = ("apple", "banana", "cherry")
tuple2 = ("orange",)
tuple1 += tuple2 # Crée un nouveau tuple
print(tuple1) # ('apple', 'banana', 'cherry', 'orange')
Suppression d'un Tuple
Un tuple étant immuable, la seule façon de le supprimer est d'utiliser del.
tuple1 = ("apple", "banana", "cherry")
del tuple1
Déballage d'un Tuple (Tuple Unpacking)
fruits = ("apple", "banana", "cherry")
(a, b, c) = fruits
print(a) # apple
print(b) # banana
print(c) # cherry
Boucle for avec un Tuple
thistuple = ("apple", "banana", "cherry")
for item in thistuple:
print(item)
Tableau Récapitulatif des Fonctions Principales pour les Tuples
Fonction Description
len(tuple) Renvoie la longueur du tuple
tuple[i] Accède à l'élément à l'index i
tuple[i:j] Extrait une sous-partie du tuple
tuple1 + tuple2 Concatène deux tuples
tuple * n Répète le tuple n fois
x in tuple Vérifie si x est dans le tuple
tuple.index(x) Renvoie l'index de la première occurrence de x
tuple.count(x) Compte les occurrences de x
del tuple Supprime complètement le tuple

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 43 / 111
Ensembles en Python
Un ensemble est une collection qui est non ordonnée, non modifiable
1
et non indexée.
Les ensembles se définissent à l’aide d’accolades {} :
myset = {"apple", "banana", "cherry"}
Création d’un Ensemble
Exemple pour créer un ensemble et l’afficher :
thisset = {"apple", "banana", "cherry"}
print(thisset)
NB : Comme les ensembles sont non ordonnés, vous ne pouvez pas prévoir l’ordre
d’affichage des éléments.
Propriétés des Ensembles
• Non ordonné : Les éléments n’ont pas d’ordre défini et leur position peut varier à
chaque affichage.
• Non modifiable : Une fois créé, les éléments d’un ensemble ne peuvent pas être
modifiés directement (mais on peut ajouter ou retirer des éléments).
• Pas de doublons : Un ensemble ne peut contenir deux éléments identiques. Les
doublons sont automatiquement ignorés.
Exemples de doublons ignorés
thisset = {"apple", "banana", "cherry", "apple"}
print(thisset)
Les valeurs True et 1 sont considérées comme identiques :
thisset = {"apple", "banana", "cherry", True, 1, 2}
print(thisset)
De même, False et 0 sont traités comme identiques :
thisset = {"apple", "banana", "cherry", False, True, 0}
print(thisset)
Longueur et Types d’Éléments
Pour connaître le nombre d’éléments dans un ensemble, utilisez la fonction len() :
thisset = {"apple", "banana", "cherry"}
print(len(thisset))
Les éléments d’un ensemble peuvent être de n’importe quel type (chaîne, entier, bool, etc.) :

1
Les éléments d’un ensemble ne peuvent pas être modifiés directement une fois l’ensemble créé, mais il est
possible d’en retirer certains ou d’en ajouter de nouveaux

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 44 / 111
set1 = {"apple", "banana", "cherry"}
set2 = {1, 5, 7, 9, 3}
set3 = {True, False, False}
Un ensemble peut également contenir différents types simultanément :
set1 = {"abc", 34, True, 40, "male"}
Pour connaître le type d’un ensemble, utilisez la fonction type() :
myset = {"apple", "banana", "cherry"}
print(type(myset)) # Affiche : <class 'set'>
Le Constructeur set()
Il est possible de créer un ensemble en utilisant le constructeur set() :
thisset = set(("apple", "banana", "cherry")) # Remarquez les doubles
parenthèses
print(thisset)
Collections en Python
Python propose quatre types de collections :
Type de Collection Ordonné ? Modifiable ? Doublons autorisés
Liste Oui Oui Oui
Tuple Oui Non Oui
Ensemble (set) Non Partiellement
2
Non
Dictionnaire À partir de Python 3.7 Oui Non
Accès aux Éléments d’un Ensemble
Il n’est pas possible d’accéder aux éléments d’un ensemble par un index ou une clé. Toutefois,
vous pouvez :
• Parcourir les éléments avec une boucle for :
thisset = {"apple", "banana", "cherry"}
for x in thisset:
print(x)
• Vérifier la présence d’un élément à l’aide du mot-clé in :
thisset = {"apple", "banana", "cherry"}
print("banana" in thisset)
print("banana" not in thisset)
Modification d’un Ensemble
Une fois créé, vous ne pouvez pas modifier directement les éléments d’un ensemble, mais vous
pouvez ajouter ou supprimer des éléments.

2
Les ensembles ne permettent pas la modification directe de leurs éléments, mais il est possible d’ajouter ou de
retirer des éléments.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 45 / 111
Ajouter des Éléments
• Ajouter un seul élément : Utilisez la méthode add().
thisset = {"apple", "banana", "cherry"}
thisset.add("orange")
print(thisset)
• Ajouter plusieurs éléments : Utilisez la méthode update(). Vous pouvez ajouter les
éléments d’un autre ensemble ou de tout objet itérable (liste, tuple, etc.).
# Ajout d’un autre ensemble
thisset = {"apple", "banana", "cherry"}
tropical = {"pineapple", "mango", "papaya"}
thisset.update(tropical)
print(thisset)
# Ajout d’une liste
thisset = {"apple", "banana", "cherry"}
mylist = ["kiwi", "orange"]
thisset.update(mylist)
print(thisset)
Supprimer des Éléments
• Utiliser remove(): Supprime un élément précis. Si l’élément n’existe pas, une erreur
est levée.
thisset = {"apple", "banana", "cherry"}
thisset.remove("banana")
print(thisset)
• Utiliser discard(): Supprime un élément précis. Si l’élément n’existe pas, aucune
erreur n’est levée.
thisset = {"apple", "banana", "cherry"}
thisset.discard("banana")
print(thisset)
• Utiliser pop(): Retire un élément au hasard et le retourne.
thisset = {"apple", "banana", "cherry"}
x = thisset.pop()
print(x)
print(thisset)
NB : Comme les ensembles sont non ordonnés, vous ne savez pas quel élément sera retiré.
• Vider l’ensemble avec clear():
thisset = {"apple", "banana", "cherry"}
thisset.clear()
print(thisset)
• Supprimer complètement l’ensemble avec del:
thisset = {"apple", "banana", "cherry"}
del thisset

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 46 / 111
# print(thisset) # Cela lèvera une erreur (l’ensemble n’existe plus ).
Parcourir un Ensemble
Vous pouvez parcourir les éléments d’un ensemble avec une boucle for :
thisset = {"apple", "banana", "cherry"}
for x in thisset:
print(x)
Joindre des Ensembles
Il existe plusieurs méthodes pour joindre deux ensembles ou plus :
Union
• Méthode union(): Retourne un nouvel ensemble contenant tous les éléments des
ensembles joints.
set1 = {"a", "b", "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
print(set3)
• Opérateur |:
set1 = {"a", "b", "c"}
set2 = {1, 2, 3}
set3 = set1 | set2
print(set3)
Joindre Plusieurs Ensembles
• Avec union():
set1 = {"a", "b", "c"}
set2 = {1, 2, 3}
set3 = {"John", "Elena"}
set4 = {"apple", "bananas", "cherry"}
myset = set1.union(set2, set3, set4)
print(myset)
• Avec l’opérateur |:
set1 = {"a", "b", "c"}
set2 = {1, 2, 3}
set3 = {"John", "Elena"}
set4 = {"apple", "bananas", "cherry"}
myset = set1 | set2 | set3 | set4
print(myset)
Joindre un Ensemble et un Tuple
La méthode union() permet de joindre un ensemble avec d’autres types (liste, tuple, etc.). Le
résultat sera toujours un ensemble.
x = {"a", "b", "c"}

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 47 / 111
y = (1, 2, 3)
z = x.union(y)
print(z)
NB : L’opérateur | ne permet de joindre que des ensembles entre eux.
Méthode update()
La méthode update() ajoute les éléments d’un ensemble à un autre. Elle modifie l’ensemble
d’origine sans retourner un nouvel ensemble.
set1 = {"a", "b", "c"}
set2 = {1, 2, 3}
set1.update(set2)
print(set1)
NB : Tant union() que update() excluent les doublons.
Tableau Récapitulatif des Méthodes sur les Ensembles
Méthode Raccourci Description Exemple
add()

Ajoute un élément à l’ensemble. thisset.add("orange")
clear()

Supprime tous les éléments de
l’ensemble.
thisset.clear()
copy()

Retourne une copie de l’ensemble. newset = thisset.copy()
difference()

Retourne un ensemble contenant la
différence entre deux ensembles ou
plus.
result =
set1.difference(set2)
difference_upd
ate()
-= Supprime de cet ensemble les
éléments présents dans un autre
ensemble spécifié.
set1.difference_update(s
et2)
discard()

Supprime l’élément spécifié. thisset.discard("banana"
)
intersection() & Retourne un ensemble
correspondant à l’intersection de
deux ensembles.
result =
set1.intersection(set2)
intersection_u
pdate()
&= Retire de cet ensemble les éléments
qui ne sont pas présents dans l’autre
ensemble spécifié.
set1.intersection_update
(set2)
isdisjoint()

Retourne True si les ensembles n’ont
aucune intersection, sinon False.
result =
set1.isdisjoint(set2)
issubset() <= Retourne True si cet ensemble est un
sous-ensemble d’un autre.
result =
set1.issubset(set2)
(proper subset) < Retourne True si tous les éléments
de cet ensemble se trouvent dans un
autre ensemble spécifié.
result = set1 < set2
issuperset() >= Retourne True si cet ensemble
contient un autre ensemble.
result =
set1.issuperset(set2)

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 48 / 111
(proper
superset)
> Retourne True si tous les éléments
d’un autre ensemble spécifié se
trouvent dans cet ensemble.
result = set1 > set2
pop()

Retire un élément de l’ensemble et le
retourne (élément choisi au hasard).
element = thisset.pop()
remove()

Supprime l’élément spécifié (génère
une erreur si l’élément n’existe pas).
thisset.remove("banana")
symmetric_diff
erence()
^ Retourne un ensemble contenant la
différence symétrique entre deux
ensembles.
result =
set1.symmetric_differenc
e(set2)
symmetric_diff
erence_update
()
^= Met à jour l’ensemble avec la
différence symétrique d’un autre
ensemble.
set1.symmetric_differenc
e_update(set2)
union() | Retourne un nouvel ensemble
contenant l’union de plusieurs
ensembles.
result =
set1.union(set2)
update() |= Met à jour l’ensemble en ajoutant les
éléments d’autres ensembles.
set1.update(set2)
Dictionnaires en Python
Un dictionnaire est une collection qui est ordonnée
3
, modifiable et n’autorise pas les
doublons.
Les dictionnaires se définissent à l’aide d’accolades {} et se composent de clés et de valeurs :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
Création et Affichage d’un Dictionnaire
Voici un exemple pour créer et afficher un dictionnaire :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict)
Propriétés des Dictionnaires
• Ordonnés : En Python 3.7 et versions ultérieures, les éléments conservent l’ordre dans
lequel ils ont été ajoutés. En Python 3.6 et antérieur, l’ordre n’était pas garanti.

3
À partir de Python 3.7, les dictionnaires sont ordonnés. En Python 3.6 et versions antérieures, ils étaient
considérés comme non ordonnés.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 49 / 111
• Modifiables : Vous pouvez modifier, ajouter ou supprimer des éléments après la
création du dictionnaire.
• Doublons non autorisés : Les clés doivent être uniques. Si une clé est dupliquée, la
dernière valeur écrase la précédente.
Exemple de doublon (la clé "year" est présente deux fois) :
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964,
"year": 2020
}
print(thisdict) # Affichera : {'brand': 'Ford', 'model': 'Mustang', 'year':
2020}
Taille et Types de Données
Pour connaître le nombre d’éléments d’un dictionnaire, utilisez la fonction len() :
print(len(thisdict))
Les valeurs d’un dictionnaire peuvent être de n’importe quel type de données (chaîne, entier,
booléen, liste, etc.) :
thisdict = {
"brand": "Ford",
"electric": False,
"year": 1964,
"colors": ["red", "white", "blue"]
}
Pour vérifier le type d’un dictionnaire, utilisez la fonction type() :
print(type(thisdict)) # Affiche : <class 'dict'>
Le Constructeur dict()
Il est également possible de créer un dictionnaire en utilisant le constructeur dict() :
thisdict = dict(name="John", age=36, country="Norway")
print(thisdict)
Comparaison des Collections en Python
Python propose quatre types de collections :
Type de Collection Ordonné ? Modifiable ? Doublons autorisés
Liste Oui Oui Oui
Tuple Oui Non Oui
Ensemble (set) Non Partiellement4 Non

4
Les éléments d’un ensemble ne peuvent pas être modifiés directement, mais il est possible d’ajouter ou de
supprimer des éléments.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 50 / 111
Dictionnaire À partir de Python 3.7 (non garanti en 3.6) Oui Non
Accès aux Éléments d’un Dictionnaire
Accéder à une Valeur par sa Clé
Vous pouvez accéder aux valeurs d’un dictionnaire en utilisant le nom de la clé entre crochets
:
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict["brand"])
Il existe également la méthode get() qui permet d’accéder à la même valeur :
x = thisdict.get("model")
Obtenir les Clés, Valeurs et Paires
• Clés : La méthode keys() renvoie une vue contenant toutes les clés du dictionnaire.
x = thisdict.keys()
print(x)
Cette vue se met à jour automatiquement si le dictionnaire change.
• Valeurs : La méthode values() renvoie une vue contenant toutes les valeurs.
x = thisdict.values()
print(x)
• Paires Clé:Valeur : La méthode items() renvoie une vue contenant des tuples pour
chaque paire.
x = thisdict.items()
print(x)
Vérifier l’Existence d’une Clé
Utilisez le mot-clé in pour vérifier si une clé est présente :
if "model" in thisdict:
print("Oui, 'model' est l'une des clés du dictionnaire" )
Modification d’un Dictionnaire
Modifier la Valeur d’une Clé
Pour modifier une valeur, référez-vous à la clé :
thisdict["year"] = 2018
Mettre à Jour un Dictionnaire
La méthode update() permet de mettre à jour ou d’ajouter des paires clé:valeur :

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 51 / 111
thisdict.update({"year": 2020})
Ajout d’Éléments dans un Dictionnaire
Pour ajouter un élément, assignez une valeur à une nouvelle clé :
thisdict["color"] = "red"
print(thisdict)
La méthode update() fonctionne également pour ajouter de nouveaux éléments :
thisdict.update({"color": "red"})
Suppression d’Éléments d’un Dictionnaire
Il existe plusieurs méthodes pour supprimer des éléments :
• pop() : Supprime et renvoie la valeur associée à la clé spécifiée :
thisdict.pop("model")
print(thisdict)
• popitem() : Supprime la dernière paire insérée (ou une paire aléatoire dans les versions
antérieures à Python 3.7) :
thisdict.popitem()
print(thisdict)
• del : Supprime une clé et sa valeur, ou le dictionnaire entier :
del thisdict["model"]
print(thisdict)
# Pour supprimer le dictionnaire entier :
del thisdict
# print(thisdict) -> Provoquera une erreur car le dictionnaire n'existe plus.
• clear() : Vide le dictionnaire
thisdict.clear()
print(thisdict)
Parcourir un Dictionnaire
Parcourir les Clés
for x in thisdict:
print(x)
ou
for x in thisdict.keys():
print(x)
Parcourir les Valeurs
for x in thisdict:
print(thisdict[x])
ou

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 52 / 111
for x in thisdict.values():
print(x)
Parcourir les Paires Clé:Valeur
for key, value in thisdict.items():
print(key, value)
Copier un Dictionnaire
Ne pas copier un dictionnaire par simple affectation (ex. : dict2 = dict1) car cela ne crée
qu’une référence.
Pour copier un dictionnaire, utilisez :
• La méthode copy() :
mydict = thisdict.copy()
print(mydict)
• La fonction dict() :
mydict = dict(thisdict)
print(mydict)
Dictionnaires Imbriqués (Nested Dictionaries)
Un dictionnaire peut contenir d’autres dictionnaires. C’est ce que l’on appelle un dictionnaire
imbriqué.
Exemple 1 : Dictionnaire contenant trois dictionnaires
myfamily = {
"child1": {
"name": "Emil",
"year": 2004
},
"child2": {
"name": "Tobias",
"year": 2007
},
"child3": {
"name": "Linus",
"year": 2011
}
}

Exemple 2 : Ajouter des dictionnaires préalablement définis dans un dictionnaire
global
child1 = {
"name": "Khalid",
"year": 2004
}
child2 = {
"name": "Leila",

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 53 / 111
"year": 2007
}
child3 = {
"name": "Ali",
"year": 2011
}
myfamily = {
"child1": child1,
"child2": child2,
"child3": child3
}
Pour accéder aux éléments d’un dictionnaire imbriqué, spécifiez successivement les clés :
print(myfamily["child2"]["name"]) #Leila
Pour parcourir un dictionnaire imbriqué :
for key, subdict in myfamily.items():
print(key)
for subkey, value in subdict.items():
print(f"{subkey}: {value}")
Tableau Récapitulatif des Méthodes sur les Dictionnaires
Méthode Description Exemple
clear() Supprime tous les éléments du dictionnaire. thisdict.clear()
copy() Retourne une copie du dictionnaire. newdict = thisdict.copy()
fromkeys() Crée un dictionnaire à partir d’une séquence de
clés, avec une même valeur pour chacune.
dict.fromkeys(["a", "b"], 0)
get() Retourne la valeur associée à la clé spécifiée. thisdict.get("model")
items() Retourne une vue contenant des tuples pour
chaque paire clé:valeur.
thisdict.items()
keys() Retourne une vue contenant toutes les clés du
dictionnaire.
thisdict.keys()
pop() Supprime l’élément avec la clé spécifiée et
renvoie sa valeur.
thisdict.pop("model")
popitem() Supprime et renvoie la dernière paire insérée
(ou une paire aléatoire en versions
antérieures).
thisdict.popitem()
setdefault() Retourne la valeur associée à la clé spécifiée ;
si la clé n’existe pas, l’ajoute avec une valeur
donnée.
thisdict.setdefault("color", "red")
update() Met à jour le dictionnaire avec les paires
clé:valeur d’un autre dictionnaire ou itérable.
thisdict.update({"year": 2020})
values() Retourne une vue contenant toutes les valeurs
du dictionnaire.
thisdict.values()
Conclusion
La compréhension des structures de données permet de gagner en expressivité, en efficacité et
en organisation dans l’écriture du code. Grâce aux outils présentés, les étudiants peuvent
désormais modéliser des ensembles d’informations complexes et structurer leurs algorithmes

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 54 / 111
avec plus de précision. La suite du cours introduira des concepts avancés qui permettront
d’organiser le code à une échelle plus large, notamment à travers la programmation orientée
objet, que nous aborderons dans le Chapitre 4.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 55 / 111
Chapitre 4 : Concepts Avancés de Programmation
Ce chapitre initie les étudiants à la programmation orientée objet (POO), un paradigme
fondamental dans le développement logiciel moderne. Il introduit les concepts de classes,
objets, encapsulation, héritage, et polymorphisme, tout en expliquant leur mise en œuvre
pratique en Python. En parallèle, d'autres concepts avancés tels que la portée des variables,
les itérateurs et la modularité sont explorés afin d’enrichir la palette des outils de structuration
du code.

La programmation Orientée Objet en Python
Classes et Objets en Python
Python est un langage de programmation orienté objet. Presque tout en Python est un objet,
doté de ses propres propriétés et méthodes.
Une classe est comparable à un constructeur d'objets, ou encore à un "plan" pour créer des
objets.
Créer une Classe
Pour définir une classe, utilisez le mot-clé class :
Exemple : Créer une classe nommée MyClass avec une propriété x :
class MyClass:
x = 5
Créer un Objet
Une fois la classe définie, vous pouvez l’utiliser pour créer des objets.
Exemple : Créer un objet nommé p1 et afficher la valeur de x :
p1 = MyClass()
print(p1.x)
La Fonction __init__()
Les exemples précédents montrent des classes et objets sous leur forme la plus simple. En
pratique, ils sont souvent plus élaborés grâce à la fonction intégrée __init__().

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 56 / 111
Chaque classe possède une fonction __init__() qui est automatiquement exécutée lors de la
création d’un nouvel objet. Cette fonction permet d'initialiser les propriétés de l'objet ou
d'exécuter d'autres opérations nécessaires lors de sa création.
Exemple : Créer une classe Person qui initialise les propriétés name et age :
class Person:
def __init__(self, name, age):
self.name = name
self.age = age

p1 = Person("John", 36)
print(p1.name)
print(p1.age)
NB : La fonction __init__() est appelée automatiquement à chaque création d’un
nouvel objet.
La Fonction str()
La fonction __str__() contrôle la représentation d’un objet sous forme de chaîne de
caractères.
Si elle n’est pas définie, Python affichera une représentation par défaut de l’objet.
Exemple (sans str())
class Person:
def __init__(self, name, age):
self.name = name
self.age = age

p1 = Person("John", 36)
print(p1)

Exemple (avec str())
class Person:
def __init__(self, name, age):
self.name = name
self.age = age

def __str__(self):
return f"{self.name} ({self.age})"

p1 = Person("John", 36)
print(p1)
Méthodes d'Objet
Les objets peuvent également contenir des méthodes : des fonctions qui leur appartiennent.
Exemple : Ajouter une méthode à la classe Person qui affiche un message de
salutation, puis l’exécuter sur l’objet p1 :
class Person:

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 57 / 111
def __init__(self, name, age):
self.name = name
self.age = age

def myfunc(self):
print("Hello, my name is " + self.name)

p1 = Person("Youssouf", 20)
p1.myfunc()
NB : Le paramètre self fait référence à l’instance courante de la classe et permet
d’accéder aux variables qui lui appartiennent.
Le Paramètre self
Le paramètre self est une référence à l’instance actuelle de la classe et permet d’accéder aux
attributs de l’objet.
Il n’est pas obligatoire de le nommer self (vous pouvez utiliser un autre nom), mais il doit être
le premier paramètre de toute méthode de la classe.
Exemple : Utilisation des noms mysillyobject et abc à la place de self :
class Person:
def __init__(mysillyobject, name, age):
mysillyobject.name = name
mysillyobject.age = age

def myfunc(abc):
print("Hello, my name is " + abc.name)

p1 = Person("John", 36)
p1.myfunc()
Modifier les Propriétés d'un Objet
Vous pouvez modifier les propriétés d'un objet de la manière suivante :
Exemple : Modifier l'âge de p1 et le passer à 40 :
p1.age = 22
Supprimer des Propriétés d'un Objet
Pour supprimer une propriété d'un objet, utilisez le mot-clé del.
Exemple : Supprimer la propriété age de l'objet p1 :
del p1.age
Supprimer un Objet
Vous pouvez également supprimer un objet entier avec le mot-clé del.
Exemple : Supprimer l'objet p1 :
del p1

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 58 / 111
L'Instruction pass
La définition d'une classe ne peut être vide. Si, pour une raison ou une autre, vous souhaitez
définir une classe sans contenu, utilisez l'instruction pass pour éviter une erreur.
Exemple
class Person:
pass
L’Héritage en Python
Introduction
L’héritage est un concept fondamental de la programmation orientée objet (POO) qui permet
de créer de nouvelles classes à partir de classes existantes. En Python, l’héritage facilite la
réutilisation de code et l’extension des fonctionnalités d’une classe sans avoir à la réécrire
entièrement. Ce chapitre vous guidera à travers les concepts de base, la syntaxe et les exemples
concrets pour bien comprendre ce mécanisme.
Concepts de Base
Classe et Objet
• Classe : Une classe est un modèle qui définit des attributs (données) et des méthodes
(fonctions) communes aux objets qui en sont issus.
• Objet : Un objet est une instance d’une classe, c’est-à-dire une entité créée à partir du
modèle défini par la classe.
Superclasse et Sous-classe
• Superclasse (ou classe parente) : C’est la classe dont les caractéristiques (attributs et
méthodes) vont être héritées.
• Sous-classe (ou classe dérivée) : C’est la classe qui hérite des attributs et méthodes de
la superclasse. Elle peut aussi avoir ses propres attributs et méthodes ou redéfinir ceux
hérités.
Syntaxe de Base de l’Héritage en Python
Pour définir une sous-classe qui hérite d’une superclasse, la syntaxe est la suivante :
Syntaxe :
class SuperClasse:
def __init__(self, param):
self.param = param

def methode(self):
print("Méthode de la SuperClasse" )

class SousClasse(SuperClasse):
def __init__(self, param, nouveau_param ):
# Appel du constructeur de la superclasse

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 59 / 111
super().__init__(param)
self.nouveau_param = nouveau_param

def methode(self):
# Redéfinition de la méthode héritée
print("Méthode redéfinie dans la SousClasse" )
Explications :
• Définition de la superclasse :
La classe SuperClasse possède un constructeur __init__ qui initialise un attribut,
ainsi qu’une méthode simple.
• Création de la sous-classe :
La classe SousClasse hérite de SuperClasse en indiquant celle-ci entre parenthèses.
Dans son constructeur, la fonction super().__init__(param) permet d’appeler le
constructeur de la superclasse pour initialiser les attributs hérités.
• Redéfinition (Override) :
La méthode methode est redéfinie dans SousClasse, ce qui permet de modifier ou
d’étendre le comportement de la méthode héritée.
Avantages et Utilisations de l’Héritage
• Réutilisation du Code
L’héritage permet d’éviter la duplication de code. Une fois que vous avez défini une
classe avec certaines fonctionnalités, vous pouvez créer plusieurs sous-classes qui
héritent de ces fonctionnalités et y ajouter ou modifier certaines parties.
• Extensibilité
Grâce à l’héritage, il est possible d’étendre le comportement d’une classe existante sans
la modifier directement, facilitant ainsi la maintenance et l’évolution du code.
• Organisation du Code
L’utilisation judicieuse de l’héritage permet de structurer le code de manière
hiérarchique et logique, ce qui rend le programme plus lisible et plus facile à
comprendre.
• Méthodes et Attributs Hérités
Lorsque vous créez une sous-classe, elle hérite automatiquement de tous les attributs et
méthodes de la superclasse, sauf si vous choisissez de les redéfinir.
• Accès aux Méthodes et Attributs de la Superclasse
Vous pouvez accéder aux méthodes et attributs de la superclasse directement à partir
d’une instance de la sous-classe.
Exemple
# Création d'une instance de SousClasse
objet = SousClasse("valeur1", "valeur2")

# Accès à un attribut hérité
print(objet.param) # Affiche: valeur1

# Appel de la méthode redéfinie

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 60 / 111
objet.methode() # Affiche: Méthode redéfinie dans la SousClasse
Utilisation de la Fonction super()
La fonction super() est très utile pour appeler des méthodes de la superclasse sans avoir à
nommer explicitement la classe parente. Cela rend le code plus flexible et plus facile à
maintenir, notamment en cas de modification du nom de la superclasse ou lors d’un héritage
multiple.
Exemple d’Utilisation :
class Animal:
def __init__(self, nom):
self.nom = nom

def parler(self):
print("L'animal fait un bruit" )

class Chien(Animal):
def __init__(self, nom, race):
super().__init__(nom) # Appel du constructeur de Animal
self.race = race

def parler(self):
super().parler() # Appel de la méthode parler de Animal
print("Le chien aboie")

# Test
mon_chien = Chien("Rex", "Berger Allemand")
mon_chien.parler()
Dans cet exemple, la méthode parler de la classe Chien appelle d’abord la
méthode parler de Animal grâce à super().parler(), puis ajoute un comportement
spécifique.
L’Héritage Multiple
Python permet à une classe de hériter de plusieurs classes. C’est ce qu’on appelle l’héritage
multiple. Cela peut être utile pour combiner des comportements de différentes classes, mais il
faut faire attention à la complexité que cela peut engendrer.
Exemple d’Héritage Multiple :
class Maman:
def parler(self):
print("Méthode de Maman")

class Papa:
def parler(self):
print("Méthode de Papa")

class Enfant(Maman, Papa):
pass

# Test

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 61 / 111
enfant = Enfant()
enfant.parler() # Quel sera le résultat ?
Explication :
Dans cet exemple, la classe Enfant hérite de Maman et de Papa. Python utilise un ordre de
résolution appelé MRO (Method Resolution Order) pour déterminer quelle méthode appeler.
Ici, Python cherchera d’abord la méthode dans Maman, puis dans Papa.
Remarques sur l’Héritage Multiple
• Complexité : L’héritage multiple peut rendre le code plus difficile à comprendre et à
maintenir.
• Ordre de résolution (MRO) : Pour savoir quelle méthode est appelée en cas de conflit,
vous pouvez utiliser la méthode __mro__ sur la classe :
print(Enfant.__mro__)
Cela affichera l’ordre dans lequel Python recherche les méthodes.
Bonnes Pratiques et Conseils
• Utiliser l’héritage quand cela a du sens : L’héritage doit être utilisé pour exprimer des
relations "est-un" (par exemple, un Chien est un Animal). Pour d’autres types de
relations, d’autres mécanismes comme la composition peuvent être plus adaptés.
• Limiter l’héritage multiple : Bien que Python le permette, il est préférable de limiter
son usage pour éviter une complexité inutile.
• Redéfinir les méthodes avec précaution : Lorsque vous redéfinissez une méthode
héritée, assurez-vous que le nouveau comportement est cohérent avec l’intention de la
méthode originale.
Polymorphisme en Python
Le terme polymorphisme signifie « plusieurs formes ». En programmation, il désigne la
possibilité d'utiliser des méthodes, fonctions ou opérateurs portant le même nom, qui
s'exécutent de manière appropriée selon les objets ou les classes sur lesquels ils interviennent.
Polymorphisme des Fonctions
Un exemple classique est la fonction len(), qui s'adapte aux différents types d'objets.
Chaînes de caractères
Pour une chaîne de caractères, len() renvoie le nombre de caractères :
Exemple
x = "Hello World!"
print(len(x))
Tuples
Pour un tuple, len() renvoie le nombre d'éléments :

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 62 / 111
Exemple
mon_tuple = ("apple", "banana", "cherry")
print(len(mon_tuple))
Dictionnaires
Pour un dictionnaire, len() renvoie le nombre de paires clé/valeur :
Exemple
mon_dict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(len(mon_dict))
Polymorphisme des Classes
Le polymorphisme intervient également dans les méthodes des classes. On peut définir
plusieurs classes possédant des méthodes ayant le même nom, et exécuter cette méthode de
manière différente selon la classe de l'objet.
Exemple avec des Méthodes Identiques
Supposons que nous ayons trois classes : Car, Boat et Plane, chacune possédant une
méthode move() :
Exemple
class Car:
def __init__(self, brand, model):
self.brand = brand
self.model = model

def move(self):
print("Drive!")

class Boat:
def __init__(self, brand, model):
self.brand = brand
self.model = model

def move(self):
print("Sail!")

class Plane:
def __init__(self, brand, model):
self.brand = brand
self.model = model

def move(self):
print("Fly!")

car1 = Car("Ford", "Mustang")
boat1 = Boat("Ibiza", "Touring 20")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 63 / 111
plane1 = Plane("Boeing", "747")

for x in (car1, boat1, plane1):
x.move()
Dans la boucle for, le même appel à la méthode move() s'exécute sur des objets de classes
différentes, chaque méthode fournissant une implémentation propre à la classe concernée.
Polymorphisme par Héritage
Le polymorphisme s'applique également aux classes dérivées. Par exemple, si l'on crée une
classe parente Vehicle et que l'on fait hériter Car, Boat et Plane de cette classe, les classes
enfants héritent des propriétés et méthodes de la classe parente, tout en pouvant les redéfinir
(les surcharger).
Exemple
class Vehicle:
def __init__(self, brand, model):
self.brand = brand
self.model = model

def move(self):
print("Move!")

class Car(Vehicle):
pass

class Boat(Vehicle):
def move(self):
print("Sail!")

class Plane(Vehicle):
def move(self):
print("Fly!")

car1 = Car("Ford", "Mustang")
boat1 = Boat("Ibiza", "Touring 20")
plane1 = Plane("Boeing", "747")

for x in (car1, boat1, plane1):
print(x.brand)
print(x.model)
x.move()
Dans cet exemple, la classe Car n'a pas redéfini la méthode move(), elle utilise donc celle
héritée de Vehicle. En revanche, les classes Boat et Plane redéfinissent la méthode move(),
permettant ainsi un comportement spécifique à chaque type de véhicule. Grâce au
polymorphisme, nous pouvons appeler la méthode move() sur n'importe quel objet dérivé
de Vehicle sans connaître sa classe exacte.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 64 / 111
Portée en Python
Une variable est accessible uniquement dans la région (portée) où elle est créée.
Portée Locale
Une variable créée à l'intérieur d'une fonction appartient à la portée locale de cette fonction et
ne peut être utilisée qu'à l'intérieur de celle-ci.
Exemple : La variable créée à l'intérieur d'une fonction est accessible uniquement
dans cette fonction :
def ma_fonction():
x = 300
print(x)

ma_fonction()
Fonction à l'intérieur d'une Fonction
Comme le montre l'exemple ci-dessus, la variable x n'est pas accessible en dehors de la
fonction, mais elle peut être utilisée par une fonction définie à l'intérieur :
Exemple : La variable locale peut être accédée depuis une fonction imbriquée :
def ma_fonction():
x = 300
def ma_fonction_interne():
print(x)
ma_fonction_interne()

ma_fonction()
Portée Globale
Une variable créée dans le corps principal du code (en dehors de toute fonction) est une variable
globale et appartient à la portée globale.
Les variables globales sont accessibles aussi bien dans la portée globale que dans les portées
locales (sous réserve de certaines conditions).
Exemple : Une variable créée en dehors d'une fonction est globale et peut être
utilisée n'importe où :
x = 300

def ma_fonction():
print(x)

ma_fonction()
print(x)
Nommer les Variables
Si vous utilisez le même nom de variable à l'intérieur et à l'extérieur d'une fonction, Python les
traitera comme deux variables distinctes :

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 65 / 111
• Une variable locale (à l'intérieur de la fonction)
• Une variable globale (à l'extérieur de la fonction)
Exemple : La fonction affichera le x local, puis le code affichera le x global :
x = 300

def ma_fonction():
x = 200
print(x)

ma_fonction()
print(x)
Mot-clé global
Si vous souhaitez créer ou modifier une variable globale depuis une portée locale, vous pouvez
utiliser le mot-clé global.
Ce mot-clé permet de déclarer qu'une variable appartient à la portée globale, même lorsqu'elle
est utilisée dans une fonction.
Exemple : Déclarer une variable globale à l'intérieur d'une fonction :
def ma_fonction():
global x
x = 300

ma_fonction()
print(x)

Exemple : Modifier la valeur d'une variable globale depuis une fonction :
x = 300

def ma_fonction():
global x
x = 200

ma_fonction()
print(x)
Mot-clé nonlocal
Le mot-clé nonlocal est utilisé pour travailler avec des variables dans des fonctions
imbriquées.
Il permet d'indiquer que la variable appartient à la fonction englobante, et non à la portée locale
de la fonction imbriquée.
Exemple : Utiliser nonlocal pour modifier une variable définie dans une fonction
extérieure :
def ma_fonction1():
x = "Youssouf"
def ma_fonction2():
nonlocal x

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 66 / 111
x = "hello"
ma_fonction2()
return x

print(ma_fonction1())
Itérateurs en Python
Un itérateur est un objet qui contient un nombre dénombrable de valeurs. En d'autres termes,
un itérateur est un objet sur lequel on peut itérer, c'est-à-dire parcourir toutes ses valeurs.
Techniquement, en Python, un itérateur est un objet qui implémente le protocole des itérateurs,
composé des méthodes __iter__() et __next__().
Itérateur vs Itérable
Les listes, tuples, dictionnaires et ensembles sont des objets itérables. Ce sont des conteneurs
à partir desquels vous pouvez obtenir un itérateur.
Tous ces objets possèdent une méthode iter() (ou plus précisément, la fonction
intégrée iter()) qui permet d'obtenir un itérateur.
Exemple : Retourner un itérateur à partir d'un tuple et afficher chaque valeur :
mon_tuple = ("apple", "banana", "cherry")
mon_iterateur = iter(mon_tuple)

print(next(mon_iterateur))
print(next(mon_iterateur))
print(next(mon_iterateur))
Les chaînes de caractères sont également des objets itérables et peuvent renvoyer un itérateur :
Exemple : Une chaîne de caractères est un itérable contenant une séquence de
caractères :
mon_str = "banana"
mon_iterateur = iter(mon_str)

print(next(mon_iterateur))
print(next(mon_iterateur))
print(next(mon_iterateur))
print(next(mon_iterateur))
print(next(mon_iterateur))
print(next(mon_iterateur))
Parcourir un Itérateur
Il est également possible d'utiliser une boucle for pour parcourir un objet itérable.
Exemple : Parcourir les valeurs d'un tuple :
mon_tuple = ("apple", "banana", "cherry")

for x in mon_tuple:
print(x)

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 67 / 111
Exemple : Parcourir les caractères d'une chaîne :
mon_str = "banana"

for x in mon_str:
print(x)
NB : La boucle for crée en fait un objet itérateur et exécute la méthode next() à
chaque itération.
Créer un Itérateur
Pour créer un objet ou une classe qui se comporte comme un itérateur, vous devez implémenter
les méthodes __iter__() et __next__().
Comme expliqué dans la section sur les classes et objets, toutes les classes possèdent une
méthode __init__() qui permet d'initialiser l'objet.
La méthode __iter__() est similaire : elle peut exécuter des opérations d'initialisation et doit
toujours retourner l'objet itérateur lui-même.
La méthode __next__() doit effectuer des opérations et renvoyer le prochain élément de la
séquence.
Exemple : Créer un itérateur qui renvoie des nombres, en commençant par 1 et en
incrémentant de 1 à chaque appel (renvoyant ainsi 1, 2, 3, 4, 5, etc.) :
class MesNombres:
def __iter__(self):
self.a = 1
return self

def __next__(self):
x = self.a
self.a += 1
return x

mon_objet = MesNombres()
mon_iterateur = iter(mon_objet)

print(next(mon_iterateur))
print(next(mon_iterateur))
print(next(mon_iterateur))
print(next(mon_iterateur))
print(next(mon_iterateur))
StopIteration
L'exemple précédent continuerait indéfiniment si vous utilisiez suffisamment d'appels
à next(), ou si vous l'utilisiez dans une boucle for.
Pour empêcher une itération infinie, vous pouvez utiliser la levée de
l'exception StopIteration.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 68 / 111
Dans la méthode __next__(), vous pouvez définir une condition d'arrêt qui lève cette
exception lorsque le nombre d'itérations souhaité est atteint.
Exemple : Arrêter l'itération après 20 itérations :
class MesNombres:
def __iter__(self):
self.a = 1
return self

def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration

mon_objet = MesNombres()
mon_iterateur = iter(mon_objet)

for x in mon_iterateur:
print(x)
Modules en Python
Qu'est-ce qu'un Module ?
Un module peut être considéré comme une bibliothèque de code. Il s'agit d'un fichier contenant
un ensemble de fonctions (et/ou de variables) que vous souhaitez intégrer dans votre
application.
Créer un Module
Pour créer un module, il suffit d'enregistrer le code désiré dans un fichier avec l'extension .py.
Exemple : Enregistrez ce code dans un fichier nommé mymodule.py
def greeting(name):
print("Hello, " + name)
Utiliser un Module
Vous pouvez utiliser le module que vous venez de créer grâce à l'instruction import.
Exemple : Importer le module mymodule et appeler la fonction greeting
import mymodule

mymodule.greeting("Youssouf")
NB : Pour utiliser une fonction d'un module, utilisez la
syntaxe : nom_du_module.nom_de_la_fonction .

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 69 / 111
Variables dans un Module
Un module peut contenir non seulement des fonctions, mais aussi des variables de tout type
(listes, dictionnaires, objets, etc.).
Exemple : Enregistrez ce code dans le fichier mymodule.py
person1 = {
"name": "Yoyssouf",
"age": 20,
"country": "Morocco"
}

Exemple : Importer le module mymodule et accéder au dictionnaire person1
import mymodule

a = mymodule.person1[ "age"]
print(a)
Nommer un Module
Vous pouvez nommer votre fichier module comme vous le souhaitez, à condition qu'il ait
l'extension .py.
Renommer un Module
Vous pouvez créer un alias lors de l'importation d'un module en utilisant le mot-clé as.
Exemple : Créer un alias mx pour le module mymodule
import mymodule as mx

a = mx.person1["age"]
print(a)
Modules Intégrés
Python dispose de plusieurs modules intégrés que vous pouvez importer à tout moment.
Exemple : Importer et utiliser le module platform
import math

x = math.sqrt(16)
print(x)
Utiliser la Fonction dir()
La fonction dir() en Python est utilisée pour obtenir une liste des noms disponibles dans le
namespace courant, ce qui inclut les noms des attributs, des méthodes et des classes. C'est un
outil utile pour explorer les objets en Python, et il peut être utilisé de plusieurs manières :
1) Sans arguments : Si vous l'appelez sans arguments, dir() renvoie une liste des noms
dans l'espace de noms local, c'est-à-dire les variables, fonctions et classes définies dans
la portée courante.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 70 / 111
a = 10
def ma_fonction():
pass

print(dir())
2) Avec un objet comme argument : Si vous passez un objet à dir(), il retournera une
liste des attributs et méthodes de cet objet. Cela inclut les méthodes spéciales (par
exemple, celles commençant par __).
class Personne:
def __init__(self, nom):
self.nom = nom

def parler(self):
return "Bonjour"

p = Personne("Ali")
print(dir(p))
3) Utiliser avec les modules : Vous pouvez aussi utiliser dir() sur les modules pour
obtenir une liste des fonctions, classes et constantes définies dans le module.
import math
print(dir(math))
En résumé, dir() est un outil puissant pour l'inspection et la découverte d'objets et de leurs
interfaces en Python, ce qui peut être très utile lors du développement et du débogage.
NB : La fonction dir() peut être utilisée pour tous les modules, y compris ceux que vous
créez vous-même.
Importer depuis un Module
Vous pouvez choisir d'importer uniquement certaines parties d'un module en utilisant le mot-
clé from.
Exemple : Si le module mymodule contient la fonction suivante et le dictionnaire
suivant
def greeting(name):
print("Hello, " + name)

person1 = {
"name": "Youssouf",
"age": 20,
"country": "Morocco"
}

Exemple : Importer uniquement le dictionnaire person1 depuis le module
from mymodule import person1

print(person1["age"])

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 71 / 111
NB : Lorsque vous importez avec le mot-clé from, il n'est pas nécessaire de préfixer
l'élément importé par le nom du module (par exemple, on écrira person1["age"] et
non mymodule.person1["age"] ).
Conclusion
La maîtrise des concepts orientés objets marque un tournant dans l’apprentissage de Python,
car elle permet d’aborder la programmation avec plus de modularité, de clarté et de
réutilisabilité. Les étudiants sont désormais prêts à utiliser Python pour des projets structurés et
complexes. Le chapitre suivant approfondira l’utilisation des bibliothèques standards de
Python, qui constituent un socle essentiel pour le développement d’applications robustes.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 72 / 111
Chapitre 5 : Outils et Bibliothèques Standards
Python est livré avec un ensemble riche de bibliothèques standard qui permettent de gagner en
efficacité sans réinventer la roue. Ce chapitre met l’accent sur quelques-unes de ces
bibliothèques utiles dans la pratique quotidienne : manipulation de dates, calculs
mathématiques, expressions régulières, et gestion des packages avec PIP. Il s’agit ici de
sensibiliser les étudiants à l’importance de l’écosystème Python et à la manière de tirer parti
de ses ressources existantes.

Dates en Python
Une date en Python n'est pas un type de données spécifique, mais nous pouvons importer le
module datetime pour travailler avec des dates sous forme d'objets date.
Afficher la Date Actuelle
Exemple : Importer le module datetime et afficher la date actuelle :
import datetime

x = datetime.datetime.now()
print(x)

Sortie attendue : Lorsque vous exécutez ce code, le résultat sera similaire à :
2025-04-02 10:49:37.360647
Ce résultat contient l'année, le mois, le jour, l'heure, la minute, la seconde et la microseconde.
Le module datetime propose de nombreuses méthodes permettant d'extraire des informations
de l'objet date. Voici quelques exemples qui seront approfondis plus tard dans ce chapitre :
Exemple : Retourner l'année et le nom du jour de la semaine :
import datetime

x = datetime.datetime.now()

print(x.year) # Affiche l'année
print(x.strftime("%A")) # Affiche le jour de la semaine (version complète)

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 73 / 111
Création d'Objets Date
Pour créer une date, vous pouvez utiliser la classe datetime() du module datetime.
Cette classe requiert trois paramètres obligatoires pour créer une date : l'année, le mois et le
jour.
Exemple : Créer un objet date :
import datetime

x = datetime.datetime( 2020, 5, 17)
print(x)
La classe datetime() accepte également des paramètres optionnels pour l'heure et le fuseau
horaire (heure, minute, seconde, microseconde, fuseau horaire), qui ont pour valeurs par défaut
0 (ou None pour le fuseau horaire).
La Méthode strftime()
L'objet datetime dispose d'une méthode appelée strftime() qui permet de formater les dates
en chaînes de caractères lisibles.
Cette méthode prend un paramètre format pour spécifier le format de la chaîne retournée.
Exemple : Afficher le nom complet du mois :
import datetime

x = datetime.datetime( 2018, 6, 1)
print(x.strftime("%B"))
Référence des Codes de Format
Voici une table récapitulative de tous les codes de format autorisés pour la
méthode strftime() :
Directive Description Exemple
%a Jour de la semaine, version abrégée Wed
%A Jour de la semaine, version complète Wednesday
%w Jour de la semaine sous forme de nombre (0-6, 0 =
dimanche)
3
%d Jour du mois (01-31) 31
%b Nom du mois, version abrégée Dec
%B Nom du mois, version complète December
%m Mois sous forme de nombre (01-12) 12

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 74 / 111
%y Année, version courte (sans le siècle) 18
%Y Année, version complète 2018
%H Heure en format 24h (00-23) 17
%I Heure en format 12h (00-12) 05
%p Indicateur AM/PM PM
%M Minute (00-59) 41
%S Seconde (00-59) 08
%f Microseconde (000000-999999) 548513
%z Décalage horaire UTC +0100
%Z Fuseau horaire CST
%j Numéro du jour dans l'année (001-366) 365
%U Numéro de semaine de l'année (dimanche comme
premier jour, 00-53)
52
%W Numéro de semaine de l'année (lundi comme premier
jour, 00-53)
52
%c Représentation locale de la date et de l'heure Mon Dec 31 17:41:00
2018
%C Siècle 20
%x Représentation locale de la date 12/31/18
%X Représentation locale de l'heure 17:41:00
%% Caractère % %
%G Année selon la norme ISO 8601 2018
%u Jour de la semaine selon ISO 8601 (1-7) 1
%V Numéro de semaine selon ISO 8601 (01-53) 01

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 75 / 111
Mathématiques en Python
Python dispose d'un ensemble de fonctions mathématiques intégrées, ainsi que d'un module
mathématique étendu, qui permettent d'effectuer diverses opérations sur les nombres.
Fonctions Mathématiques Intégrées
Trouver la Valeur Minimale et Maximale
Les fonctions min() et max() permettent de déterminer respectivement la plus petite et la plus
grande valeur d'un itérable ou d'une série de valeurs.
Exemple
x = min(5, 10, 25)
y = max(5, 10, 25)

print(x) # Affiche 5
print(y) # Affiche 25
Valeur Absolue
La fonction abs() renvoie la valeur absolue (positive) d'un nombre.
Exemple
x = abs(-7.25)
print(x) # Affiche 7.25
Puissance
La fonction pow(x, y) renvoie la valeur de x élevé à la puissance y (équivalent à x^y).
Exemple : Calculer 4 à la puissance 3 (soit 4 * 4 * 4) :
x = pow(4, 3)
print(x) # Affiche 64
Le Module math
Python intègre également un module nommé math qui étend la liste des fonctions
mathématiques disponibles. Pour l'utiliser, il faut l'importer :
import math
Racine Carrée
La méthode math.sqrt() renvoie la racine carrée d'un nombre.
Exemple
import math

x = math.sqrt(64)
print(x) # Affiche 8.0
Arrondi
• math.ceil() arrondit un nombre à l'entier supérieur le plus proche.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 76 / 111
• math.floor() arrondit un nombre à l'entier inférieur le plus proche.
Exemple
import math

x = math.ceil(1.4) # Retourne 2
y = math.floor(1.4) # Retourne 1

print(x)
print(y)
Constante PI
La constante math.pi fournit la valeur de PI (3.14159…).
Exemple
import math

x = math.pi
print(x)
Référence Complète du Module math
Pour découvrir toutes les méthodes et constantes disponibles dans le module math, il est
recommandé de consulter la documentation officielle qui fournit une référence complète.
Les expression régulière
Une expression régulière (ou RegEx) est une séquence de caractères qui définit un modèle de
recherche. On les utilise pour vérifier si une chaîne contient le modèle spécifié.
Le Module re
Python dispose d'un package intégré nommé re qui permet de travailler avec les expressions
régulières.
Importer le module :
import re
Utilisation des Expressions Régulières en Python
Une fois le module re importé, vous pouvez commencer à utiliser les expressions régulières.
Par exemple, pour vérifier si une chaîne commence par "The" et se termine par "Spain" :
Exemple :
import re

texte = "The rain in Spain"
resultat = re.search( "^The.*Spain$", texte)

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 77 / 111
Fonctions Principales du Module re
Le module re offre plusieurs fonctions permettant de rechercher des correspondances dans une
chaîne :
• findall() : Retourne une liste contenant toutes les correspondances trouvées.
Exemple :
import re

texte = "The rain in Spain"
correspondances = re.findall( "ai", texte)
print(correspondances) # Affiche ['ai', 'ai']
• search() : Recherche une correspondance dans la chaîne et retourne un objet Match si
une correspondance est trouvée. Si plusieurs correspondances existent, seule la première
est retournée.
Exemple :
import re

texte = "The rain in Spain"
correspondance = re.search( "\s", texte)
if correspondance:
print("Le premier caractère d'espacement se trouve à la position :" ,
correspondance.start())
Si aucune correspondance n'est trouvée, None est retourné.
Exemple sans correspondance :
import re

texte = "The rain in Spain"
correspondance = re.search( "Portugal", texte)
print(correspondance) # Affiche None
• split() : Retourne une liste obtenue en découpant la chaîne à chaque correspondance.
Exemple : Découper la chaîne à chaque espace :
import re

texte = "The rain in Spain"
parties = re.split("\s", texte)
print(parties)
Vous pouvez limiter le nombre de découpages avec le paramètre maxsplit :
Exemple :
import re

texte = "The rain in Spain"
parties = re.split("\s", texte, 1)
print(parties)
• sub() : Remplace une ou plusieurs correspondances par une chaîne de votre choix.
Exemple : Remplacer chaque espace par le chiffre 9 :

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 78 / 111
import re

texte = "The rain in Spain"
nouveau_texte = re.sub( "\s", "9", texte)
print(nouveau_texte)
Vous pouvez limiter le nombre de remplacements avec le paramètre count :
Exemple :
import re

texte = "The rain in Spain"
nouveau_texte = re.sub( "\s", "9", texte, 2)
print(nouveau_texte)
Les Métacaractères
Les métacaractères sont des caractères ayant une signification particulière dans une expression
régulière. Voici quelques exemples :
Caractère Description Exemple
[] Ensemble de caractères (ex : [a-m]) [a-m]
\ Indique une séquence spéciale ou permet d'échapper un caractère spécial
(ex : \d)
\d
. N'importe quel caractère (sauf le saut de ligne) he..o
^ Indique le début de la chaîne ^hello
$ Indique la fin de la chaîne planet$
* Zéro ou plusieurs occurrences he.*o
+ Une ou plusieurs occurrences he.+o
? Zéro ou une occurrence he.?o
{} Nombre exact d'occurrences he.{2}o
` ` OU (alternatives)
() Capturer et grouper (abc)
Séquences Spéciales
Une séquence spéciale est constituée d'un antislash \ suivi d'un caractère particulier, avec une
signification spécifique :
Séquence Description Exemple d'utilisation
\A Correspond si les caractères spécifiés se trouvent au début de la
chaîne
\AThe
\b Correspond si les caractères spécifiés se trouvent au début ou à la
fin d'un mot
r"\bain" ou r"ain\b"
\B Correspond si les caractères spécifiés sont présents mais pas au
début ou à la fin d'un mot
r"\Bain" ou r"ain\B"
\d Correspond à un chiffre (0-9) \d
\D Correspond à tout caractère non numérique \D
\s Correspond à un caractère d'espacement (espace, tabulation, etc.) \s
\S Correspond à tout caractère non blanc \S
\w Correspond à un caractère de mot (a-z, A-Z, 0-9, et _ ) \w
\W Correspond à tout caractère non alphanumérique \W
\Z Correspond si les caractères spécifiés se trouvent à la fin de la chaîne Spain\Z

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 79 / 111
Les Ensembles (Sets)
Un ensemble est une collection de caractères placés entre crochets [] avec une signification
particulière :
Ensemble Description Exemple
[arn] Correspond si l'un des caractères spécifiés (a, r ou
n) est présent
[arn]
[a-n] Correspond à tout caractère minuscule compris
entre a et n
[a-n]
[^arn] Correspond à tout caractère sauf a, r et n [^arn]
[0123] Correspond si l'un des chiffres spécifiés est présent [0123]
[0-9] Correspond à n'importe quel chiffre entre 0 et 9 [0-9]
[0-
5][0-9]
Correspond à n'importe quel nombre à deux
chiffres entre 00 et 59
[0-5][0-9]
[a-zA-
Z]
Correspond à n'importe quel caractère
alphabétique, minuscule ou majuscule
[a-zA-Z]
[+] Dans un ensemble, +, *, ., ` , (), $, {}, n'ont pas de
signification spéciale.
Ainsi, [+]` correspond au caractère +
L'Objet Match
Un objet Match contient des informations sur la recherche effectuée et le résultat obtenu.
Si aucune correspondance n'est trouvée, la fonction retourne None.
Exemple : Effectuer une recherche qui retourne un objet Match :
import re

texte = "The rain in Spain"
match_obj = re.search( "ai", texte)
print(match_obj) # Affiche un objet Match s'il y a une correspondance
L'objet Match propose plusieurs méthodes et propriétés utiles :
• span() : Retourne un tuple contenant les positions de début et de fin de la
correspondance.
Exemple :
import re

texte = "The rain in Spain"
match_obj = re.search( r"\bS\w+", texte)
print(match_obj.span())
• string : Retourne la chaîne passée à la fonction de recherche.
Exemple :
import re

texte = "The rain in Spain"
match_obj = re.search( r"\bS\w+", texte)
print(match_obj.string)
• group() : Retourne la partie de la chaîne où la correspondance a été trouvée.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 80 / 111
Exemple :
import re

texte = "The rain in Spain"
match_obj = re.search( r"\bS\w+", texte)
print(match_obj.group())
NB : Si aucune correspondance n'est trouvée, None sera retourné au lieu d'un objet
Match.
PIP en Python
Qu'est-ce que PIP ?
PIP est un gestionnaire de paquets pour les modules ou packages Python.
NB : À partir de Python 3.4, PIP est inclus par défaut.
Qu'est-ce qu'un Package ?
Un package contient l'ensemble des fichiers nécessaires pour un module.
Les modules sont des bibliothèques de code Python que vous pouvez intégrer dans vos projets.
Vérifier si PIP est Installé
Pour vérifier l'installation de PIP, ouvrez l'invite de commandes, naviguez vers le répertoire des
scripts de Python et tapez :
C:\Users\VotreNom\AppData\Local\Programs\Python\Python36-32\Scripts>pip --
version
Cette commande affiche la version de PIP installée sur votre système.
Installer PIP
Si PIP n'est pas installé, vous pouvez le télécharger et l'installer à partir de la page suivante :
https://pypi.org/project/pip/
Télécharger un Package
Pour télécharger un package, ouvrez l'invite de commandes et indiquez à PIP de télécharger le
package souhaité.
Par exemple, pour télécharger un package nommé "camelcase" :
C:\Users\VotreNom\AppData\Local\Programs\Python\Python36-32\Scripts>pip
install camelcase
Après exécution, le package sera téléchargé et installé.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 81 / 111
Utiliser un Package
Une fois le package installé, vous pouvez l'utiliser dans votre projet.
Par exemple, pour importer et utiliser le package "camelcase" :
import camelcase

c = camelcase.CamelCase()
texte = "hello world"
print(c.hump(texte))
Trouver des Packages
Vous pouvez trouver de nombreux packages sur le site PyPI.

Supprimer un Package
Pour supprimer un package, utilisez la commande uninstall de PIP.
Par exemple, pour désinstaller le package "camelcase" :
C:\Users\VotreNom\AppData\Local\Programs\Python\Python36-32\Scripts>pip
uninstall camelcase
Le gestionnaire PIP vous demandera de confirmer la suppression :
Uninstalling camelcase -0.2:
Would remove:
c:\users\VotreNom\appdata\local\programs\python\python36-32\lib\site-
packages\camelcase-0.2-py3.6.egg-info
c:\users\VotreNom\appdata\local\programs\python\python36-32\lib\site-
packages\camelcase\*
Proceed (y/n)?
Tapez y pour confirmer et le package sera supprimé.
Lister les Packages Installés
Pour afficher la liste de tous les packages installés sur votre système, utilisez la commande
suivante :
C:\Users\VotreNom\AppData\Local\Programs\Python\Python36-32\Scripts>pip
list
Exemple de résultat :
Package Version
-------------------------
camelcase 0.2
mysql-connector 2.1.6
pip 18.1
pymongo 3.6.1
setuptools 39.0.1

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 82 / 111
Conclusion
Ce chapitre a démontré la puissance des bibliothèques standard pour automatiser des tâches
courantes et accélérer le développement. Cette connaissance est fondamentale pour accéder à
des domaines plus spécifiques. Le prochain chapitre s’intéressera à la persistance des données,
à travers l’enregistrement de fichiers et l’utilisation de formats standards comme JSON.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 83 / 111
Chapitre 6 : Persistance simple - Manipulation de
Fichiers et Données
La capacité à sauvegarder, lire et manipuler des données de manière persistante est essentielle
dans tout développement logiciel. Ce chapitre introduit la gestion des fichiers texte et des
fichiers JSON, tout en abordant la gestion des erreurs à l’aide de blocs try/except.
L’objectif est de fournir aux étudiants les outils nécessaires pour interagir avec le système de
fichiers et gérer les données de manière fiable.

Les fichiers en Python
La gestion des fichiers joue un rôle fondamental dans le développement d’applications, qu’il
s’agisse d’applications web, de bureau ou de tout autre environnement logiciel.
Python propose plusieurs fonctions pour créer, lire, mettre à jour et supprimer des fichiers.
Ouverture de fichiers en Python
La fonction clé pour manipuler des fichiers en Python est la fonction open().
La fonction open() prend deux paramètres : le nom du fichier et le mode d'ouverture.
Il existe quatre méthodes (modes) différentes pour ouvrir un fichier :
• "r" - Lecture : Valeur par défaut. Ouvre un fichier en lecture. Une erreur est générée
si le fichier n'existe pas.
• "a" – Ajout : Ouvre un fichier en mode ajout, et crée le fichier s'il n'existe pas.
• "w" – Écriture : Ouvre un fichier en écriture, et crée le fichier s'il n'existe pas.
Attention, ce mode écrase le contenu existant.
• "x" – Création : Crée le fichier spécifié et renvoie une erreur si le fichier existe déjà.
De plus, vous pouvez préciser si le fichier doit être traité en mode binaire ou texte :
• "t" – Texte : Valeur par défaut. Mode texte.
• "b" – Binaire : Mode binaire (par exemple, pour les images).
Syntaxe
Pour ouvrir un fichier en lecture, il suffit de spécifier le nom du fichier :
f = open("demofile.txt")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 84 / 111
Le code ci-dessus équivaut à :
f = open("demofile.txt", "rt")
Puisque "r" pour lecture et "t" pour texte sont les valeurs par défaut, il n'est pas nécessaire de
les préciser.
NB : Assurez-vous que le fichier existe, sinon une erreur sera générée.
Ouvrir un fichier sur le serveur
Supposons que nous ayons le fichier suivant, situé dans le même dossier que votre script Python
:
demofile.txt
Hello! Welcome to demofile.txt
This file is for testing purposes.
Good Luck!
Pour ouvrir le fichier, utilisez la fonction intégrée open(), qui retourne un objet fichier
comportant une méthode read()pour lire le contenu du fichier :
Exemple
f = open("demofile.txt", "r")
print(f.read())
Si le fichier se trouve à un autre emplacement, il faut spécifier le chemin complet :
Exemple : Ouvrir un fichier situé ailleurs
f = open("D:\\myfiles\\welcome.txt", "r")
print(f.read())
Lecture d’un fichier
Lecture partielle d’un fichier
Par défaut, la méthode read() renvoie tout le texte, mais vous pouvez également spécifier le
nombre de caractères à lire :
Exemple : Retourner les 5 premiers caractères du fichier
f = open("demofile.txt", "r")
print(f.read(5))
Lecture par lignes
Vous pouvez lire une seule ligne à l’aide de la méthode readline() :
Exemple : Lire une ligne du fichier
f = open("demofile.txt", "r")
print(f.readline())
En appelant readline() deux fois, vous lisez les deux premières lignes :
Exemple : Lire deux lignes du fichier
f = open("demofile.txt", "r")
print(f.readline())

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 85 / 111
print(f.readline())
Pour parcourir le fichier ligne par ligne, vous pouvez utiliser une boucle :
Exemple : Parcourir le fichier ligne par ligne
f = open("demofile.txt", "r")
for x in f:
print(x)
Fermeture des fichiers
Il est recommandé de toujours fermer un fichier une fois les opérations terminées.
Exemple : Fermer le fichier après utilisation
f = open("demofile.txt", "r")
print(f.readline())
f.close()
NB : Il est important de toujours fermer vos fichiers. Dans certains cas, en raison du
buffering, les modifications apportées à un fichier ne seront pas visibles tant que le fichier
n’est pas fermé.
Écriture dans un fichier en Python
Écrire dans un fichier existant
Pour écrire dans un fichier existant, vous devez ajouter un paramètre à la fonction open() :
• "a" - Ajout : ajoutera le contenu à la fin du fichier.
• "w" - Écriture : écrasera le contenu existant.
Exemple : Ouvrir le fichier "demofile2.txt" et ajouter du contenu
f = open("demofile2.txt", "a")
f.write("Now the file has more content!" )
f.close()

# Ouvrir et lire le fichier après l'ajout :
f = open("demofile2.txt", "r")
print(f.read())

Exemple : Ouvrir le fichier "demofile3.txt" et écraser le contenu
f = open("demofile3.txt", "w")
f.write("Woops! I have deleted the content!" )
f.close()

# Ouvrir et lire le fichier après écrasement :
f = open("demofile3.txt", "r")
print(f.read())
NB : La méthode "w" écrase entièrement le contenu du fichier.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 86 / 111
Création d’un nouveau fichier
Pour créer un nouveau fichier en Python, utilisez la fonction open() avec l'un des paramètres
suivants :
• "x" - Création : crée le fichier, renvoie une erreur si le fichier existe déjà.
• "a" - Ajout : crée le fichier s'il n'existe pas.
• "w" - Écriture : crée le fichier s'il n'existe pas.
Exemple : Créer un fichier appelé "myfile.txt"
f = open("myfile.txt", "x")
Þ Résultat : Un nouveau fichier vide est créé !
Exemple : Créer un nouveau fichier s'il n'existe pas
f = open("myfile.txt", "w")
Suppression d’un fichier en Python
Supprimer un fichier
Pour supprimer un fichier, importez le module os et utilisez sa fonction os.remove() :
Exemple : Supprimer le fichier "demofile.txt"
import os
os.remove("demofile.txt")
Vérifier l'existence d’un fichier
Pour éviter une erreur, il est conseillé de vérifier si le fichier existe avant de tenter de le
supprimer :
Exemple : Vérifier si le fichier existe, puis le supprimer
import os
if os.path.exists("demofile.txt"):
os.remove("demofile.txt")
else:
print("The file does not exist" )
Renommer un fichier
Pour renommer un fichier entier, utilisez la méthode os.rename() :
Exemple : Renommer le fichier "ancienFichier.txt"
import os
os.rename("ancienFichier.txt", "nouveauFichier.txt")
Suppression d’un dossier
Pour supprimer un dossier entier, utilisez la méthode os.rmdir() :
Exemple : Supprimer le dossier "myfolder"
import os
os.rmdir("myfolder")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 87 / 111
NB : Vous ne pouvez supprimer que des dossiers vides.
JSON en Python
Qu’est-ce qu’un fichier JSON ?
JSON signifie JavaScript Object Notation. C’est un format léger et lisible par les humains,
utilisé pour représenter des données structurées. Il est très utilisé pour échanger des
données entre un programme et une application web, ou entre deux systèmes.
Exemple de fichier personne.json :
{
"nom": "Ali",
"age": 25,
"est_etudiant": true
}
En JSON :
• Les données sont représentées sous forme de paires clé-valeur.
• Les chaînes de caractères sont entre guillemets doubles.
• Les booléens sont écrits true et false (en minuscules).
Le module json de Python
Python propose un module standard appelé json pour manipuler facilement les fichiers JSON.
Il permet de :
• Convertir un objet Python en JSON : json.dump() ou json.dumps()
• Convertir du JSON en objet Python : json.load() ou json.loads()
NB :
dump() et load() sont utilisés pour les fichiers.
dumps() et loads() sont utilisés pour les chaînes de caractères.
Lire un fichier JSON
Exemple simple
Supposons que nous avons un fichier etudiant.json contenant :
etudiant.json
{
"nom": "Fatima",
"age": 21,
"notes": [15.5, 14.0, 16.5]
}
Voici comment le lire avec Python :

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 88 / 111
import json

# Ouvrir le fichier JSON en lecture
fichier = open ("etudiant.json", "r")
donnees = json.load(fichier)

# Afficher les données
print(donnees)
print("Nom :", donnees['nom'])
print("Notes :", donnees['notes'])

Sortie :
{'nom': 'Fatima', 'age': 21, 'notes': [15.5, 14.0, 16.5]}
Nom : Fatima
Notes : [15.5, 14.0, 16.5]
Écrire dans un fichier JSON
On peut aussi enregistrer des données Python dans un fichier JSON.
Exemple :
import json

etudiant = {
"nom": "Youssouf",
"age": 23,
"est_inscrit": True
}

# Ouvrir le fichier en écriture (créera le fichier s’il n’existe pas)
fichier = open ("nouvel_etudiant.json", "w")
json.dump(etudiant, fichier, indent=4) # indent pour rendre le fichier
lisible
Le contenu du fichier nouvel_etudiant.json sera :
nouvel_etudiant.json
{
"nom": "Youssef",
"age": 23,
"est_inscrit": true
}
Utiliser JSON avec la programmation orientée objet
On peut combiner JSON et POO pour sauvegarder ou charger des objets.
Exemple : classe Étudiant
class Etudiant:
def __init__(self, nom, age, notes ):
self.nom = nom
self.age = age
self.notes = notes

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 89 / 111
def to_dict(self):
return {
"nom": self.nom,
"age": self.age,
"notes": self.notes
}
Sauvegarder un objet :
etudiant1 = Etudiant("Sara", 22, [14.5, 15.0, 13.5])
fichier = open ("sara.json", "w")
json.dump(etudiant1.to_dict(), fichier, indent=4)
Charger un objet à partir d’un fichier :
fichier = open('sara.json', 'r')
data = json.load(fichier)

etudiant2 = Etudiant(data['nom'], data['age'], data['notes'])
print(etudiant2.nom, etudiant2.notes)
Conversion d'Objets Python en Chaînes JSON
Vous pouvez convertir en JSON des objets Python de types suivants :
• dict
• list
• tuple
• str
• int
• float
• True
• False
• None
Exemple : Convertir divers objets Python en chaînes JSON :
import json

print(json.dumps({"name": "John", "age": 30}))
print(json.dumps(["apple", "bananas"]))
print(json.dumps(("apple", "bananas")))
print(json.dumps("hello"))
print(json.dumps(42))
print(json.dumps(31.76))
print(json.dumps(True))
print(json.dumps(False))
print(json.dumps(None))
Lors de la conversion de Python vers JSON, les objets Python sont transformés en leur
équivalent JavaScript :
Python JSON
dict Object

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 90 / 111
list Array
tuple Array
str String
int Number
float Number
True true
False false
None null

Exemple : Convertir un objet Python contenant tous ces types de données :
import json

x = {
"name": "John",
"age": 30,
"married": True,
"divorced": False,
"children": ("Ann", "Billy"),
"pets": None,
"cars": [
{"model": "BMW 230", "mpg": 27.5},
{"model": "Ford Edge", "mpg": 24.1}
]
}

print(json.dumps(x))
Formater le Résultat
Par défaut, le JSON généré par json.dumps() n'est pas très lisible car il n'inclut pas
d'indentations ni de retours à la ligne. Vous pouvez améliorer sa lisibilité en utilisant certains
paramètres de la méthode.
Utiliser le Paramètre indent
Pour définir le nombre d'indentations :
print(json.dumps(x, indent= 4))
Modifier les Séparateurs
Le séparateur par défaut est (", ", ": "), ce qui signifie qu'une virgule suivie d'un espace
sépare chaque objet, et un deux-points suivi d'un espace sépare les clés de leurs valeurs. Vous
pouvez le modifier avec le paramètre separators :
print(json.dumps(x, indent= 4, separators=(". ", " = ")))
Ordonner les Clés
Pour trier les clés dans le résultat JSON, utilisez le paramètre sort_keys :
print(json.dumps(x, indent= 4, sort_keys=True))

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 91 / 111
Gestion des Exceptions avec try/except en Python
Le bloc try vous permet de tester un morceau de code pour détecter d'éventuelles erreurs.
Le bloc except vous permet de gérer l'erreur lorsqu'elle survient.
Le bloc else permet d'exécuter du code lorsque aucune erreur n'est levée,
et le bloc finally s'exécute dans tous les cas, que le code dans try ait généré une exception
ou non.
Gestion des Exceptions
Lorsque survient une erreur (ou exception), Python s'arrête normalement et affiche un message
d'erreur.
Ces exceptions peuvent être gérées grâce à l'instruction try.
Exemple : Le bloc try va générer une exception parce que la variable x n'est pas
définie :
try:
print(x)
except:
print("Une exception est survenue" )
Ici, comme le bloc try soulève une erreur, le bloc except est exécuté.
Sans le bloc try, le programme se planterait et générerait une erreur :
Exemple :
print(x) # Provoque une erreur car x n'est pas définie
Gérer Plusieurs Exceptions
Vous pouvez définir autant de blocs d'exceptions que nécessaire pour traiter différents types
d'erreurs.
Par exemple, vous pouvez afficher un message spécifique pour une erreur de type NameError
et un autre pour les autres erreurs :
Exemple :
try:
print(x)
except NameError:
print("La variable x n'est pas définie" )
except:
print("Une autre erreur est survenue" )
Le Bloc else
Le mot-clé else permet de définir un bloc de code qui s'exécute si aucune erreur n'est levée dans
le bloc try.
Exemple :
try:
print("Hello")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 92 / 111
except:
print("Une erreur est survenue" )
else:
print("Aucune erreur n'est survenue" )
Le Bloc finally
Le bloc finally s'exécute toujours, que le bloc try lève ou non une exception.
Ce bloc est souvent utilisé pour fermer des objets ou libérer des ressources.
Exemple :
try:
print(x)
except:
print("Une erreur est survenue" )
finally:
print("L'exécution du try/except est terminée" )
Un exemple plus concret, pour essayer d'ouvrir et d'écrire dans un fichier, puis le fermer, même
si une erreur survient :
try:
f = open("demofile.txt")
try:
f.write("Lorem Ipsum")
except:
print("Une erreur est survenue lors de l'écriture dans le fichier" )
finally:
f.close()
except:
print("Une erreur est survenue lors de l'ouverture du fichier" )
Ici, le programme peut continuer sans laisser le fichier ouvert.
Lever (raise) une Exception
En tant que développeur Python, vous pouvez choisir de lever une exception lorsque survient
une condition particulière.
Pour lever (ou déclencher) une exception, utilisez le mot-clé raise.
Exemple : Lever une exception et arrêter le programme si x est inférieur à 0 :
x = -1

if x < 0:
raise Exception("Désolé, aucun nombre inférieur à zéro n'est autorisé" )
Vous pouvez également lever un type d'erreur spécifique, par exemple, lever une exception de
type TypeError si x n'est pas un entier :
Exemple :
x = "hello"

if not isinstance(x, int):
raise TypeError("Seuls les entiers sont autorisés" )

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 93 / 111
Conclusion
Les mécanismes de persistance simples permettent de créer des applications plus interactives
et résilientes. L’utilisation des fichiers et des formats standards comme JSON ouvre la voie à
des traitements plus avancés sur des données stockées de manière structurée. Dans le chapitre
suivant, nous allons franchir un nouveau cap en introduisant la connexion aux bases de
données relationnelles, notamment MySQL, à l’aide de Python.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 94 / 111
Chapitre 7 : Persistance avancée - Manipulation de
Bases de Données MySQL en Python
Ce chapitre approfondit les mécanismes de persistance en introduisant l’interfaçage de Python
avec des bases de données MySQL. À travers la connexion, l’exécution de requêtes SQL, la
gestion des résultats, la modification et la suppression de données, les étudiants découvrent
comment intégrer Python dans des systèmes de gestion de données robustes et performants. Les
notions de jointure et de filtrage sont également abordées pour des traitements complexes.

Création de la Connexion
Commencez par créer une connexion à la base de données.
Utilisez le nom d'utilisateur et le mot de passe de votre base de données MySQL.
Exemple :
import mysql.connector
from mysql.connector import Error

try:
# Établir la connexion avec MySQL :
connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='' # mot de passe vide par défaut
)

if connection.is_connected():
print("Connexion established")

except Error as e:
print("Erreur lors de la connexion à MySQL", e)

finally:
connection.close()
print("La connexion MySQL a été fermée")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 95 / 111
Dès lors, vous pouvez commencer à interroger la base de données en utilisant des instructions
SQL.
NB :
Si le module mysql-connector-python n'est pas installé dans votre
environnement Python, vous pouvez l'installer en exécutant la commande suivante dans
votre terminal :
pip install mysql-connector-python
Si cette commande ne fonctionne pas, essayez avec :
pip3 install mysql-connector-python
Ces commandes installeront le module nécessaire pour permettre l'accès à MySQL en
Python. Veillez à utiliser l'environnement Python adéquat (par exemple, un environnement
virtuel) afin de garantir que l'installation est correctement effectuée pour votre projet.
L’objet cursor
Qu'est-ce qu'un cursor ?
• Définition : Un curseur (cursor) est un objet qui sert d’interface entre votre
application Python et la base de données. Il permet d’exécuter des requêtes SQL et de
gérer les résultats retournés.
• Fonction principale : Le curseur facilite l'envoi de commandes SQL au serveur et
l'extraction des données issues de ces commandes. Il représente un « pointeur » sur le
jeu de résultats obtenu par l'exécution d'une requête.
Utilisation de connection.cursor()
Lorsque vous établissez une connexion avec la base de données via une bibliothèque (par
exemple, mysql-connector-python), vous créez d'abord une connexion. Ensuite, en
appelant connection.cursor(), vous créez un curseur qui vous permettra :
• D'exécuter des requêtes SQL : En utilisant la méthode execute(), le curseur permet
d’exécuter des instructions SQL (INSERT, SELECT, UPDATE, DELETE, etc.).
• De récupérer les résultats : Après avoir exécuté une requête, le curseur offre des
méthodes telles que fetchone(), fetchall() ou l’itération sur le curseur pour obtenir
les enregistrements retournés par la requête.
• De gérer les transactions : Bien que la gestion des transactions soit souvent réalisée au
niveau de la connexion, le curseur joue un rôle dans l'exécution des opérations de
modification des données (INSERT, UPDATE, DELETE).
Avantages de l'utilisation du curseur
• Séparation des préoccupations : Le curseur isole la logique d'exécution des requêtes
de la logique de gestion de la connexion.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 96 / 111
• Contrôle fin des opérations SQL : Il permet de gérer de manière précise l'exécution
des requêtes, le traitement des erreurs et la récupération des résultats.
• Flexibilité : Certains curseurs offrent des fonctionnalités supplémentaires, comme des
curseurs dict (pour obtenir des résultats sous forme de dictionnaires) ou des curseurs en
mode itératif pour traiter des volumes importants de données.
En résumé, l’instruction connection.cursor() est fondamentale pour interagir avec la base
de données, vous permettant d’exécuter des requêtes SQL, de récupérer et manipuler les
résultats et de gérer les transactions de manière efficace dans votre application Python.
Création d'une Base de Données MySQL en Python
Créer une Base de Données
Pour créer une base de données dans MySQL, utilisez l'instruction CREATE DATABASE.
Exemple : Créer une base de données nommée mydatabase :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='' # mot de passe vide par défaut
)

mycursor = connection.cursor()

mycursor.execute("CREATE DATABASE mydatabase" )
Si le code ci-dessus s'exécute sans erreur, cela signifie que vous avez créé la base de données
avec succès.
Vérifier l'Existence d'une Base de Données
Pour vérifier si une base de données existe, vous pouvez lister toutes les bases de données du
système à l'aide de l'instruction SHOW DATABASES :
Exemple : Retourner la liste des bases de données du système
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='' # mot de passe vide par défaut
)

mycursor = mydb.cursor()

mycursor.execute("SHOW DATABASES")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 97 / 111
for x in mycursor:
print(x)
Vous pouvez également essayer d'accéder à la base de données lors de l'établissement de la
connexion :
Exemple : Tenter de se connecter à la base de données mydatabase
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)
Si la base de données n'existe pas, une erreur sera générée.
Création de Table en MySQL avec Python
Créer une Table
Pour créer une table dans MySQL, utilisez l'instruction CREATE TABLE.
Assurez-vous de préciser le nom de la base de données lors de la création de la connexion.
Exemple : Créer une table nommée customers
import mysql.connector

request = """CREATE TABLE myDB.personne (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(30) NOT NULL,
prenom VARCHAR(30) NOT NULL,
email VARCHAR(50),
reg_date TIMESTAMP)"""

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

mycursor.execute (request)
Si le code s'exécute sans erreur, la table a été créée avec succès.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 98 / 111
Vérifier l'Existence d'une Table
Pour vérifier l'existence d'une table, vous pouvez lister toutes les tables de la base de données
avec l'instruction SHOW TABLES :
Exemple : Retourner la liste des tables
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

mycursor.execute("SHOW TABLES")

for x in mycursor:
print(x)
Insertion de Données dans une Table MySQL avec Python
Insérer une Ligne
Pour insérer des données dans la table, utilisez l'instruction INSERT INTO.
Exemple : Insérer un enregistrement dans la table customers
connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "INSERT INTO personne (nom, prenom, email) VALUES (%s, %s, %s)"
val = ("EL ALLIOUI", "Youssouf", "[email protected]")
mycursor.execute(sql, val)

connection.commit()

print(mycursor.rowcount, "record inserted.")
NB : N'oubliez pas d'appeler mydb.commit() pour valider les modifications.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 99 / 111
Insérer Plusieurs Lignes
Pour insérer plusieurs lignes, utilisez la méthode executemany().
Le deuxième paramètre est une liste de tuples contenant les données à insérer.
Exemple : Insérer plusieurs enregistrements dans la table customers
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "INSERT INTO personne (nom, prenom, email) VALUES (%s, %s, %s)"

val = [("EL ALLIOUI", "Youssouf", "[email protected]"),
("EL ALLIOUI", "Youssouf", "[email protected]"),
("EL ALLIOUI", "Youssouf", "[email protected]"),
("EL ALLIOUI", "Youssouf", "[email protected]")
]

mycursor.executemany(sql, val)

mydb.commit()

print(mycursor.rowcount, "was inserted.")
Récupérer l'ID Inséré
Vous pouvez obtenir l'ID du dernier enregistrement inséré en interrogeant l'objet curseur.
Exemple : Insérer une ligne et récupérer l'ID :
connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "INSERT INTO personne (nom, prenom, email) VALUES (%s, %s, %s)"
val = ("EL ALLIOUI", "Youssouf", "[email protected]")
mycursor.execute(sql, val)

connection.commit()

print("1 record inserted, ID:" , mycursor.lastrowid)

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 100 / 111
Sélection de Données
Sélectionner Depuis une Table
Pour sélectionner des données dans une table MySQL, utilisez l'instruction SELECT.
Exemple : Sélectionner tous les enregistrements de la table customers et afficher
le résultat :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

mycursor.execute("SELECT * FROM personne")

myresult = mycursor.fetchall()

for x in myresult:
print(x)
NB : La méthode fetchall() récupère toutes les lignes de la dernière instruction
exécutée.
Sélectionner Certaines Colonnes
Pour sélectionner uniquement certaines colonnes, précisez les noms des colonnes dans
l'instruction SELECT.
Exemple : Sélectionner uniquement les colonnes name et address :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

mycursor.execute("SELECT nom, prenom FROM personne")

myresult = mycursor.fetchall()

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 101 / 111
for x in myresult:
print(x)
Utiliser la Méthode fetchone()
Si vous ne souhaitez récupérer qu'une seule ligne, utilisez la méthode fetchone() qui renvoie la
première ligne du résultat :
Exemple :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

mycursor.execute("SELECT * FROM personne")

myresult = mycursor.fetchone()

print(myresult)
Filtrer les Résultats
Sélection avec Filtre
Pour filtrer les enregistrements lors d'une sélection, utilisez l'instruction WHERE.
Exemple : Sélectionner les enregistrements dont l'adresse est "Park Lane 38" :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "SELECT * FROM personne WHERE prenom ='Ali'"
mycursor.execute(sql)

myresult = mycursor.fetchall()

for x in myresult:
print(x)

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 102 / 111
Utiliser des Caractères Joker
Pour sélectionner des enregistrements commençant, contenant ou se terminant par une certaine
chaîne, utilisez le caractère % comme joker.
Exemple : Sélectionner les enregistrements dont l'adresse contient le mot "way" :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "SELECT * FROM personne WHERE prenom LIKE '%li%'"
mycursor.execute(sql)

myresult = mycursor.fetchall()

for x in myresult:
print(x)
Prévenir les Injections SQL
Lorsque les valeurs des requêtes proviennent de l'utilisateur, il est important de les échapper
pour éviter les injections SQL, une technique de piratage visant à détruire ou détourner votre
base de données.
Le module mysql.connector permet d'échapper les valeurs via des placeholders %s.
Exemple : Échapper les valeurs dans une requête :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "SELECT * FROM personne WHERE prenom = %s"
prenom = ("Youssouf", )

mycursor.execute(sql, prenom)

myresult = mycursor.fetchall()

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 103 / 111
for x in myresult:
print(x)
Tri des Résultats
Utiliser ORDER BY
Utilisez l'instruction ORDER BY pour trier les résultats en ordre croissant (par défaut) ou
décroissant (avec le mot-clé DESC).
Exemple : Trier les enregistrements par ordre alphabétique sur le champ name :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "SELECT * FROM personne ORDER BY prenom"
mycursor.execute(sql)

myresult = mycursor.fetchall()

for x in myresult:
print(x)

Exemple : Trier les enregistrements en ordre alphabétique inverse :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "SELECT * FROM personne ORDER BY prenom DESC"
mycursor.execute(sql)

myresult = mycursor.fetchall()

for x in myresult:
print(x)

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 104 / 111
Suppression de Données
Supprimer des Enregistrements
Pour supprimer des enregistrements, utilisez l'instruction DELETE FROM.
Exemple : Supprimer tous les enregistrements dont l'adresse est "Mountain 21"
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "DELETE FROM personne WHERE prenom = 'Ali'"
mycursor.execute(sql)

mydb.commit()

print(mycursor.rowcount, "record(s) deleted")
NB : N'oubliez pas d'appeler mydb.commit(). Sans cette instruction, les modifications
ne seront pas enregistrées.
Pour éviter les injections SQL dans les requêtes de suppression, utilisez le placeholder %s.
Exemple : Supprimer en échappant la valeur
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "DELETE FROM personne WHERE prenom = %s"
prenom = ("Ali", )

mycursor.execute(sql, prenom)

mydb.commit()

print(mycursor.rowcount, "record(s) deleted")

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 105 / 111
Suppression d'une Table
Supprimer une Table
Pour supprimer une table existante, utilisez l'instruction DROP TABLE.
Exemple : Supprimer la table customers :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "DROP TABLE personne"
mycursor.execute(sql)
Supprimer une Table Seulement si Elle Existe
Si la table est déjà supprimée ou n'existe pas, utilisez le mot-clé IF EXISTS pour éviter une
erreur :
Exemple : Supprimer la table customers si elle existe
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "DROP TABLE IF EXISTS personne"
mycursor.execute(sql)
Mise à Jour des Données
Mettre à Jour une Table
Pour mettre à jour des enregistrements existants, utilisez l'instruction UPDATE.
Exemple : Modifier l'adresse de "Valley 345" en "Canyon 123"
import mysql.connector

connection = mysql.connector.connect(

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 106 / 111
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "UPDATE personne SET prenom = 'Khalid' WHERE prenom = 'Ali'"
mycursor.execute(sql)

mydb.commit()

print(mycursor.rowcount, "record(s) affected")
Encore une fois, il est important d'utiliser mydb.commit() pour enregistrer les modifications.
Pour prévenir les injections SQL, utilisez le placeholder %s.
Exemple : Mettre à jour en échappant les valeurs :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "UPDATE personne SET prenom = %s WHERE prenom = %s"
val = ("Khalid", "Ali")

mycursor.execute(sql, val)

mydb.commit()

print(mycursor.rowcount, "record(s) affected")
Limitation du Nombre de Résultats
Utiliser LIMIT
Pour limiter le nombre d'enregistrements retournés par la requête, utilisez l'instruction LIMIT.
Exemple : Sélectionner les 5 premiers enregistrements de la table customers :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 107 / 111
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

mycursor.execute("SELECT * FROM personne LIMIT 5")

myresult = mycursor.fetchall()

for x in myresult:
print(x)
Utiliser OFFSET
Pour retourner 5 enregistrements en commençant à partir du troisième enregistrement, utilisez
le mot-clé OFFSET.
Exemple : Commencer à partir de la position 3 et retourner 5 enregistrements :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

mycursor.execute("SELECT * FROM personne LIMIT 5 OFFSET 2")

myresult = mycursor.fetchall()

for x in myresult:
print(x)
Jointure de Tables
Joindre Deux ou Plusieurs Tables
Vous pouvez combiner les enregistrements de deux ou plusieurs tables, en fonction d'une
colonne commune, à l'aide d'une instruction JOIN.
Considérez l'exemple suivant avec une table users et une table products :
Tables Exemple :
users
# Exemple de contenu :
# { id: 1, name: 'John', fav: 154 },

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 108 / 111
# { id: 2, name: 'Peter', fav: 154 },
# { id: 3, name: 'Amy', fav: 155 },
# { id: 4, name: 'Hannah', fav: None },
# { id: 5, name: 'Michael', fav: None }

products
# Exemple de contenu :
# { id: 154, name: 'Chocolate Heaven' },
# { id: 155, name: 'Tasty Lemons' },
# { id: 156, name: 'Vanilla Dreams' }
Ces deux tables peuvent être jointes en reliant le champ fav de la table users au champ id de
la table products.
Exemple : Joindre users et products pour afficher le nom de l'utilisateur et le
nom de son produit favori :
import mysql.connector

connection = mysql.connector.connect(
host='localhost', # ou 127.0.0.1
port=3306, # port par défaut, à confirmer dans XAMPP
user='root', # nom d'utilisateur par défaut
password='', # mot de passe vide par défaut
database='myDB' # précisez le nom de la base si elle existe
)

mycursor = connection.cursor()

sql = "SELECT \
users.name AS user, \
products.name AS favorite \
FROM users \
INNER JOIN products ON users.fav = products.id"
mycursor.execute(sql)

myresult = mycursor.fetchall()

for x in myresult:
print(x)
NB : Vous pouvez utiliser JOIN au lieu de INNER JOIN car le résultat sera identique.
LEFT JOIN
Dans l'exemple précédent, les utilisateurs sans produit favori (par exemple, Hannah et Michael)
ne sont pas affichés car INNER JOIN ne retourne que les enregistrements avec une
correspondance.
Pour afficher tous les utilisateurs, même ceux sans produit favori, utilisez LEFT JOIN.
Exemple : Sélectionner tous les utilisateurs et leur produit favori
sql = "SELECT \
users.name AS user, \

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 109 / 111
products.name AS favorite \
FROM users \
LEFT JOIN products ON users.fav = products.id"
RIGHT JOIN
Si vous souhaitez retourner tous les produits, ainsi que les utilisateurs qui les ont choisis comme
favori (même si aucun utilisateur n'a choisi certains produits), utilisez RIGHT JOIN.
Exemple : Sélectionner tous les produits et les utilisateurs qui les ont choisis
sql = "SELECT \
users.name AS user, \
products.name AS favorite \
FROM users \
RIGHT JOIN products ON users.fav = products.id"
NB : Dans cet exemple, les utilisateurs sans produit favori ne seront pas affichés
Conclusion
Ce chapitre clôture notre parcours par une ouverture vers des systèmes d’information complets
et évolutifs. L’intégration de Python avec des bases de données relationnelles marque une étape
décisive dans l’apprentissage de la programmation orientée objets. Les étudiants sont
désormais en mesure de développer des applications structurées, interactives et capables de
manipuler des données de manière persistante et fiable. La conclusion générale viendra
synthétiser l’ensemble des acquis et proposer des perspectives futures.

Support de cours Python
Y. EL ALLIOUI | USMS | FPK | [email protected] 110 / 111
Conclusion générale et Perspectives
À l’issue de ce module consacré à l’apprentissage progressif du langage Python, les étudiantes
et étudiants ont pu acquérir une compréhension approfondie et opérationnelle des principales
composantes de ce langage à la fois polyvalent, moderne et accessible. Ce parcours
pédagogique, structuré en sept chapitres complémentaires, a permis d'explorer les multiples
dimensions de Python, depuis ses fondements syntaxiques jusqu’à son interaction avec des
systèmes de gestion de bases de données relationnelles.
Nous avons commencé par la découverte du langage, ses cas d’usage, son installation, et la
réalisation des premiers scripts. Ensuite, nous avons étudié les bases de la programmation
procédurale, les structures de données natives de Python, avant de plonger dans des concepts
plus avancés tels que la programmation orientée objets, les modules, et la portée des variables.
Le cours s’est poursuivi avec une initiation aux bibliothèques standards, à la manipulation de
fichiers, à la gestion d’exceptions, et s’est clôturé par une introduction pratique à la persistance
des données à travers l’usage de bases MySQL avec Python.
Cette diversité de contenus vise à développer non seulement des compétences techniques
solides, mais aussi à encourager une autonomie dans la conception et la résolution de problèmes
informatiques réels. Elle permet d’aborder avec sérénité les exigences de projets concrets, qu’ils
soient académiques ou professionnels.
En termes de perspectives, les étudiantes et étudiants sont désormais en mesure de poursuivre
leur apprentissage dans des directions plus spécialisées : science des données, intelligence
artificielle, développement web avec Flask ou Django, ou encore automatisation de processus
métiers. Python, en tant que langage généraliste mais extensible, constitue un socle idéal pour
s’orienter vers ces domaines d’avenir.
Il est recommandé de continuer à expérimenter le langage à travers des projets personnels ou
collaboratifs, d’explorer les bibliothèques avancées (comme NumPy, Pandas, Matplotlib,
SQLAlchemy, etc.), et de s’intéresser aux bonnes pratiques de développement (tests unitaires,
gestion de dépendances, documentation, versionnage).
Je tiens à remercier sincèrement l’ensemble des étudiants pour leur assiduité, leur engagement,
leur curiosité intellectuelle et leur enthousiasme tout au long du module. C’est leur implication
qui donne tout son sens à ce travail pédagogique.
Que cette introduction à Python soit pour vous une porte d’entrée vers un monde d’opportunités
numériques, de projets créatifs et de collaborations fructueuses. Bonne continuation à toutes et
à tous dans votre parcours académique et professionnel.

Programmation Orientée Objets (Python) : CONCEPTS, PRATIQUES ET APPLICATIONS

About This Presentation

Slide Content

Tags

Categories

Download

Quick Actions

Statistics

Related Slideshows

Programmation Orientée Objets (Python) : CONCEPTS, PRATIQUES ET APPLICATIONS

About This Presentation

Slide Content

Slide 1

Slide 2

Slide 3

Slide 4

Slide 5

Slide 6

Slide 7

Slide 8

Slide 9

Slide 10

Slide 11

Slide 12

Slide 13

Slide 14

Slide 15

Slide 16

Slide 17

Slide 18

Slide 19

Slide 20

Slide 21

Slide 22

Slide 23

Slide 24

Slide 25

Slide 26

Slide 27

Slide 28

Slide 29

Slide 30

Slide 31

Slide 32

Slide 33

Slide 34

Slide 35

Slide 36

Slide 37

Slide 38

Slide 39

Slide 40

Slide 41

Slide 42

Slide 43

Slide 44

Slide 45

Slide 46

Slide 47

Slide 48

Slide 49

Slide 50

Slide 51

Slide 52

Slide 53

Slide 54

Slide 55

Slide 56

Slide 57

Slide 58

Slide 59

Slide 60

Slide 61

Slide 62

Slide 63

Slide 64

Slide 65

Slide 66

Slide 67

Slide 68

Slide 69

Slide 70

Slide 71

Slide 72

Slide 73

Slide 74

Slide 75

Slide 76

Slide 77