Bouebdelli University Année Universitaire

4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

Programmation Python

L A
Chapitre2 : Structures de contrôle et de flux en Python

FA
ER
Objectif :


GU
Se familiariser avec l’environnement de développement Thonny et acquérir les bases
de la programmation en Python à travers la création de scripts simples. L’accent sera
mis sur la compréhension et l’utilisation des structures conditionnelles (if,
match...case), des boucles (for, while), des fonctions, ainsi que des mécanismes de
gestion des erreurs (try...except).
ajih

 Apprendre à contrôler le flux d’exécution d’un programme et de le rendre plus

robuste et interactif.
 Se familiariser avec de l’environnement de programmation Python Thonny IDL
dW
me

1- Structures de contrôle
La conception d’un programme passe par l’utilisation de conditions, boucles, fonctions, que
l’on appelle structures de contrôle. La structuration d’un programme Python est définie par
ha

son indentation. Le début d’un bloc est défini par un ':', la première ligne pouvant être
considérée comme un en-tête (test, boucle, définition, etc.).
Mo

Il est crucial de gérer les erreurs et les exceptions qui se produisent pendant l'exécution, sans
causer de perturbation au bon fonctionnement du programme.

Mohamed Wajih GUERFALA

1
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

a) Structure conditionnelle if … else

A
L’instruction conditionnelle 'if' permet de contrôler le déroulement du programme dans

L
différentes directions, en fonction de la condition testée.

FA
Python offre une seule construction pour réaliser des tests : le 'if then else'. Une
particularité de cette mise en œuvre est la possibilité d’enchaîner les tests avec la construction

ER
'elif'. Le 'else' et le 'elif' sont bien sûr optionnels. Enfin, a clause 'elif' peut
être utilisée plusieurs fois dans un même bloc.

Ce qui suit est un bref aperçu de la manière de construire la structure conditionnelle if ...

GU
else en Python, en illustrant les différentes formes qu’elle peut adopter :

if condition :
ajih

instructions...

ou
dW

if condition :
instructions...
else :
instructions...
me

ou
ha

if condition :
instructions...
elif condition 1 :
Mo

instructions...
else :
instructions...

Mohamed Wajih GUERFALA

2
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

Ou

A
if condition :

L
instructions...
elif condition 1 :

FA
instructions...
elif condition 2 :
instructions...
.
.

ER
.
elif condition N-1 :
instructions...
elif condition N :
instructions...
else :
instructions...
GU
Exercice 1.1:
ajih

Dans le script « TP2_Ex1.py » écrivez le programme suivant et commentez :

# --------------- Structure conditionnelle if ---------------------
N = int(input("Donnez-moi un nombre : "))
dW

if N < 50 :
print("Votre nombre est inférieur à 50.")
elif N == 50 :
print("Votre nombre est égal à 50")
me

else :
print("Votre nombre est supérieur à 50.")
# ------------------------- Fin Code -----------------------------
ha

b) Structure conditionnelle Match … Case

L’instruction conditionnelle ' Match-Case ' est l’équivalent du ' Switch-Case '
Mo

des autres langages de programmation. Cette instruction de « Filtrage par

motif structurel » permet de vérifier qu’une variable correspond à une des
valeurs définies. Les instructions match-case sont arrivées avec la version 3.10 de Python.

Mohamed Wajih GUERFALA

3
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

A
valeurT = « Type de donnée »
# int, float & str»

L
match valeurT :

FA
case scenario_1 :
expression_1

ER
case scenario_2 :
expression_2
case scenario_3 :

case _ :
expression_3
GU
expression_par_defaut
ajih

Exercice 1.2:
Dans le script « TP2_Ex1.py » écrivez le programme suivant et commentez :
# --------------- Structure conditionnelle if ---------------------
dW

jour = 2
match jour:
case 1:
print("Lundi")
case 2:
print("Mardi")
me

case 3:
print("Mercredi")
case 4:
print("Jeudi")
case 5:
ha

print("Vendredi")
case 6:
print("Samedi")
Mo

case 7:
print("Dimanche")
case _:
print("Pas un jour de la semaine")
# ------------------------- Fin Code -----------------------------

Mohamed Wajih GUERFALA

4
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

c) Boucles For & While

Deux types de boucles sont disponibles : les boucles énumérées (for) et les boucles basées

A
sur un test de fin (while). Ces deux constructions suivent le même schéma : un en-tête qui

L
décrit l’évolution de la boucle, un ensemble d’instructions qui sont évaluées à chaque tour de

FA
boucle et une partie optionnel qui est évaluée en sortie de boucle (introduite par else).

 Boucles énumérées For

ER
Une boucle 'for' définit une variable qui prend successivement toutes les valeurs de la
séquence (Liste ou Tuple) parcourue (ligne 1). La structure globale de cette boucle est la
suivante :

for <cible> in <objet>: GU

blocs d'instructions 1
if <test1>: break
ajih

if <test2>: continue
if <test3>: pass
else:
dW

blocs d'instructions 2

Avec :
• break: sort de la boucle sans passer par else,
• continue : remonte au début de la boucle,
me

• pass : ne fait rien,

• else : lancé si et seulement si la boucle se termine normalement.
ha

Exercice 1.3:
Dans le script « TP2_Ex1.py » écrivez le programme suivant et commentez :
# --------------- Boucles énumérées For ---------------------
Mo

# --- Exp1:
som1 = 0
for i in [1, 2, 3, 4]:
som1 = som1 + i
print("La somme est:",som1 ,"\n")

Mohamed Wajih GUERFALA

5
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

# --- Exp2:
prod = 1

A
for p in range(1, 10):
prod = prod * p
print("Le produit est:",prod ,"\n")

L
# --- Exp3:

FA
for j in range(1, 10, 2):
print(j)

# --- Exp4:

ER
s = 'bonjour'
for c in s:
if c=='j': break # remplacer 'break' par 'continue' et 'pass'
print(c);
else: print("Fin boucle For")

# --- Exp5:
L = [ x + 10 for x in range(10)]
print("\nLa liste est:",L ,"\n")
GU
# ------------------------- Fin Code -----------------------------
ajih

 Boucles While
Une boucle ' while' définit une condition booléenne avec les mêmes règles que pour les
tests (ligne 1). Tant que cette condition est respectée, les instructions du bloc associé au (
dW

while ) sont évaluées. La structure globale de cette boucle est la suivante :

while condition:
bloc d'instructions 1
if <test2>: break
me

if <test3>: continue
if <test3>: pass
else:
bloc d'instructions 2
ha

...
Avec :
: sort de la boucle sans passer par else,
Mo

• break
• continue : remonte au début de la boucle,
• pass : ne fait rien,
• else : lancé si et seulement si la boucle se termine normalement.

Mohamed Wajih GUERFALA

6
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

Exercice 1.4:
Dans le script « TP2_Ex1.py » écrivez le programme suivant et commentez :

A
# --------------------- Boucles while ---------------------
# --- Exp1:

L
counter = 0
while counter < 10 :

FA
counter += 1
print("Le compteur est à: ", counter)
else: print("Fin Boucle While")

ER
# --- Exp2:
while True :
print("Erreur --> boucle infinie !")
# ------------------------- Fin Code ------------------------

GU
NB : Utiliser les touches Ctrl+C pour interrompre un traitement encours d’exécution ou une
boucle infinie.

c) Fonctions
ajih

Il n’y a que des fonctions en Python (et non une distinction entre fonction et procédures
comme dans certains langages). Une fonction est définie en utilisant le mot clé "def". Elle
regroupe des instructions sous un nom et s'exécute lors de l'appel.
dW

La définition d'une fonction peut être avec paramètres (un ou plusieurs arguments) ou sans
paramètres.
Une fonction en Python renvoie toujours une valeur, qu’elle soit unique ou multiple. Si
aucune instruction return n’est spécifiée, la fonction retourne automatiquement la valeur
me

spéciale None (joue le rôle d’une procédure).

def nom_fonction (arg1, arg2,... argN):

ha

...
bloc d'instructions
...
Mo

return <valeur(s)>...

Mohamed Wajih GUERFALA

7
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

Exercice 1.5:
Dans le script « TP2_Ex1.py » écrivez le programme suivant et commentez :

A
# ----------------------- Fonctions -----------------------------
# --- Exp1: Fonction sans paramètres

L
# Variables Locales VS Globales
def monter():

FA
global a
a = a+1 ; print("Inc a -> a = ", a)
b = a/2 ; print("b = ", b)
a = 15

ER
monter()
monter()

# --- Exp2: Fonction avec un seul paramètre

def cube(n):
return n**3
GU
n=3; c1=cube(n); print("Le cube de",n,"est:",c1,"\n")
# ------------------------- Fin Code -----------------------------

 Variable locale
ajih

Une variable locale est définie à l’intérieur d’une fonction. Elle n’existe que pendant
l’exécution de cette fonction. Parmi ces caractéristiques, ce qu’elle masque toute variable
globale du même nom et elle est inaccessible en dehors de la fonction.
dW

 Variable globale
Une variable locale est définie en dehors de toute fonction, dans le corps principal du
programme. Elle est accessible dans toutes les fonctions, sauf si une variable locale du même
me

nom la masque. Pour la modifier dans une fonction, il faut utiliser le mot-clé global.

c) Fonctions Lambda
ha

Une fonction lambda (ou fonction anonyme) est une façon concise de définir une fonction
en une seule ligne, sans utiliser le mot-clé def.
La syntaxe générale de la fonction lambda se présente comme suit :
Mo

lambda arguments: expression

Mohamed Wajih GUERFALA

8
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

Les caractéristiques principales de la fonction Lambda sont :

˄ Une seule expression autorisée

A
˄ Aucun nom requis (anonyme)

L
˄ Exécution immédiate de l'expression

FA
˄ Accepte tous types de paramètres
˅ Pas de return explicite nécessaire
˅ Pas de blocs multiples possibles

ER
La comparaison entre la fonction classique et Lambda est illustré par le code suivant :
# --| FONCTION CLASSIQUE

GU
def f(x):
return x**2
print(f(5)) # 25

# --| FONCTION LAMBDA

f = lambda x: x**2
ajih
print(f(5)) # 25

Les fonctions Lambda sont utiles pour effectuer des opérations mathématiques simples,
manipuler les fonctions de tri et filtrer des données.
Exemple d’utilisation du Lamda pour les opérations mathématiques simples
dW

# Carré d'un nombre

carre = lambda x: x**2
# Somme de deux nombres
addition = lambda a, b: a + b
# Vérification pair/impair
me

est_pair = lambda n: n % 2 == 0
print(carre(4))
print(addition(3, 7))
print(est_pair(5))
ha

Exemple d'utilisation du Lamda pour le tri des données.

# Tri par deuxième élément d'un tuple
etudiants = [("Alice", 18), ("Bob", 15), ("Charlie", 20)]
Mo

etudiants_tries = sorted(etudiants, key=lambda x: x[1])

Exemple d'utilisation du Lamda pour le filtrage de données.
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pairs = list(filter(lambda x: x % 2 == 0, nombres))

Mohamed Wajih GUERFALA

9
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

2- Gestion des erreurs (Exceptions) : try ... except ... finally

A
Les exceptions en Python sont des événements qui se produisent pendant l'exécution d'un

L
programme et qui interrompent le flux normal d'instructions.
Lorsqu’elle se produit, le programme tente de trouver un bloc de traitement d'exception

FA
adapté (try...except) pour la gérer.
Si aucun gestionnaire n'est trouvé, le programme s'arrête et affiche une trace d'erreur.

ER
La syntaxe générale de la structure de gestion des exceptions se présente comme suit :

try:
Instruction à exécuter s'il n'y a pas d'erreur!
except:
Instruction pour gérer l'erreur
finally:
GU
# Bloc de code qui sera toujours exécuté
ajih

Exemple code python de gestion des exceptions d’un script :

# --------------- Gestion des erreurs ---------------------

dW

try:
# Bloc surveillé
numerateur = int(input("Numérateur : "))
denominateur = int(input("Dénominateur : "))
resultat = numerateur / denominateur
print(f"Résultat : {resultat}")
me

except ZeroDivisionError as e:
# Gestion spécifique
print(f"--X Erreur division : {e}")

except ValueError as e:
ha

# Gestion spécifique
print(f"--X Erreur valeur : {e}")

except Exception as e:
Mo

# Gestion générale (attrape toutes les autres erreurs)

print(f"--X Erreur inattendue : {e}")

finally:
# TOUJOURS exécuté (avec ou sans erreur)
print("--| Nettoyage des ressources...")

Mohamed Wajih GUERFALA

10
Bouebdelli University Année Universitaire
4éme Année Ingénieur en Mécatronique (ASIIN) 2025-2026

Pour la gestion des erreurs d’un script python, le tableau suivant regroupe les erreurs les plus

A
courantes et leurs causes :

L
Mémo : Tableau des gestions des exceptions

FA
Exception Cause Exemple

Division par zéro

ER
ZeroDivisionError 10 / 0

ValueError Conversion impossible int("abc")

TypeError

NameError Variable non définie

GU
Opération sur mauvais type "hello" + 5

print(variable_inexistante)

Index hors liste

ajih
IndexError liste[10] (liste trop petite)

KeyError Clé absente du dictionnaire dico["cle_inexistante"]

dW

Fichier introuvable open("fichier_inexistant.txt"

FileNotFoundError
)

ImportError Module non trouvé import module_inexistant

Utilisateur appuie sur

me

KeyboardInterrupt Interruption manuelle

Ctrl+C

MemoryError Mémoire insuffisante Liste trop grande

ha
Mo

Mohamed Wajih GUERFALA

11