Cours Programmation Python avancée

M2 génie électrique

Sommaire

CHAPITRE I. INSTALLER ET UTILISER PYTHON 1

I.1. RAPPEL SUR LES ALGORITHMES ET LES LANGAGES DE PROGRAMMATION 1

I.1.A. LANGAGE COMPILÉ VS LANGAGE INTERPRÉTÉ 1
I.1.B. PYTHON, C’EST QUOI? 2
I.1.C. INSTALLER PYTHON 2

CHAPITRE II. NOTIONS DE BASE 5

II.1. MODE INTERACTIF ET MODE SCRIPT 5

II.2. OPERATIONS ARITHMETIQUES ET LOGIQUES DE BASE 5
II.3. UTILISER LES VARIABLES 6
II.4. LES FONCTIONS PREDEFINIES DANS PYTHON 7
II.5. CREER UN SCRIPT PYTHON 10

CHAPITRE III. LES STRUCTURES CONDITIONNELLES 13

III.1. LES STRUCTURES DE CONTROL 13

III.2. LES PREDICATS ET LES OPERATEURS LOGIQUES 13
III.3. STRUCTURE DE CONTROL CONDITIONNELLE : LA FORME MINIMALE EN IF 13
III.4. FORME EN IF … ELSE 15
III.5. LA FORME COMPLETE IF … ELIF … ELSE 16
CHAPITRE IV. LES BOUCLES 18

IV.1. INTRODUCTION 18
IV.2. LA BOUCLE WHILE 18
IV.3. LA BOUCLE FOR 20

CHAPITRE V. LES FONCTIONS 22

V.1. INTRODUCTION 22
V.2. CREER UNE FONCTION 22
V.2.A. CREER UNE FONCTION FIGEE 22
V.2.B. UNE FONCTION AVEC PARAMETRES 24
V.2.C. FONCTION AVEC VALEUR DE RETOUR 24
V.2.D. FONCTION AVEC PLUSIEURS VALEURS DE RETOUR 25
V.3. VALEUR PAR DEFAUT DES PARAMETRES 25
V.4. SIGNATURE D’UNE FONCTION 26
V.5. LES MODULES 26
V.5.A. LA METHODE IMPORT 26
V.5.B. CREER SON PROPRE MODULE 28
V.5.C. QUELQUES MODULES UTILES 29

CHAPITRE VI. LES LISTES ET TUPLES 30

VI.1. INTRODUCTION 30
VI.2. CREER UNE LISTE 30
VI.3. ACCEDER AUX ELEMENTS D’UNE LISTE 30
VI.4. LA FONCTION ENUMERATE 32
VI.5. MANIPULER ET MODIFIER LES ELEMENTS D’UNE LISTE 32
VI.5.A. AJOUTER UN ELEMENT A LA FIN D’UNE LISTE 32
VI.5.B. CONCATENER DEUX LISTES 33
VI.5.C. INSERER UN ELEMENT DANS LA LISTE 33
VI.5.D. SUPPRIMER UN ELEMENT D’UNE LISTE 33
VI.5.E. QUELQUES FONCTIONS UTILES SUR LES LISTES 34
VI.6. LES TUPLES 34
 Cours rédigé par

Dr. [Link]

([Link]@[Link])

Enseignant chercheur au département de génie électrique,

Faculté de technologie,
Université de Bejaia

Membre du Laboratoire de Maitrise des Énergies Renouvelables LMER.

 Chapitre I.
Installer et utiliser Python
Cours Prog Python Avancée Génie électrique Chapitre I

Chapitre I. Installer et utiliser Python

I.1. Rappel sur les algorithmes et les langages de programmation

En informatique, un algorithme est une séquence finie d’instructions, conçu pour résoudre un type de
problèmes précis (comme résoudre une équation), traiter des données (modifier une image, un texte, ou
toute autre donnée), ou faire un calcul mathématique ou logique. Les instructions qui composent un
algorithme sont des ordres que l’ordinateur doit exécuter dans l’ordre dans lequel elles sont écrites. Un
algorithme décrit donc les étapes à suivre pour atteindre un résultat souhaité.

Il est tout d’abord écrit dans une langue naturelle, tel que le français, anglais ou arabe, puis il doit être
traduit dans un langage de programmation pour obtenir un code source. Ce code source sera ensuite soit
compilé, si le langage de programmation choisi est un langage compilé, ou bien directement interprété si
le langage de programmation choisi est un langage interprété.

I.1.a. Langage compilé VS Langage interprété

Un langage de programmation fait office d’intermédiaire entre l’être humain et l’ordinateur. Grace à une
application spéciale, appelée compilateur ou interpréteur (selon le type du langage), il convertit le
programme écrit par le programmeur, avec un langage humain, en un langage codé que l’ordinateur peut
comprendre et exécuter.

Dans le cas de langages compilés (tel que le C, C++, et le Pascal), un petit logiciel appelé compilateur se
charge de convertir le fichier texte dans lequel le programme est écrit en un fichier exécutable (voir Figure
1). Ce dernier est un fichier codé, extrêmement difficile à décoder par l’être humain, mais très facilement
compréhensible par l’ordinateur. Pour diffuser son programme il suffit donc d’envoyer le fichier
exécutable, et à chaque modification du code, il faut recompiler et rediffuser le nouveau fichier
exécutable.

Un programme informatique sous forme d un Un programme informatique prêt à être

langage de programmation exécuté par l ordinateur
Traduction en langage binaire
par le compilateur
- Créer la variable tc_mo
- Lui attribuer la valeur 136.09
Traduire les 1100111011010011110111110
- Créer la variable dzd
1010000110100011000111011
- Lui attribuer la valeur 135000 instructions 0001010101111100010101000
- Diviser dzd par tc_mo en binaire 1001111011010011101000010
- Stocker le résultat dans la
variable eur_mp

Figure 1 : Fonctionnement de la compilation

1|Page
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre I
Ce processus permet au programme de s’exécuter plus rapidement et de protéger le code source contre
toute tentative de vol. Mais possède l’inconvénient de n’être pas portable, c-à-d qu’un programme
compilé sous Windows ne fonctionnera pas sur linux ou MacOs.

Un langage interprété (tel que Python ou Matlab), ne se compile pas, mais vient sous forme d’un fichier
texte contenant le code source du programme et portant une extension propre au langage (comme .py
pour python, et .m pour Matlab) qui s’appelle un Script, puis un logiciel spécialisé, appelé interpréteur,
transcrit chaque instruction en langage machine et l’exécute au fur et à mesure que le logiciel lit le code
source. Ce procédé permet de rendre n’importe quel programme portable, et plus simple à diffuser. Ainsi,
un programme Python développé sous Windows peut très bien fonctionner sur linux ou MacOs. Le plus
grand inconvénient de ce genre de langage est que le code source n’est pas protégé, et quiconque
possédant le programme peut lire son code source. De plus, pour diffuser son programme, il faut envoyer
le script lui-même, et demander à l’utilisateur final d’installer l’interpréteur adéquat.

I.1.b. Python, c’est quoi?

Python est un langage interprété, modulaire, et puissant, à la fois facile à apprendre et riche en
possibilités. Dès l'instant où vous l'installez sur votre ordinateur, vous disposez de nombreuses
fonctionnalités intégrées au langage. Il est, en outre, très facile d’ajouter plus de fonctionnalités en
installant des bibliothèques et des modules supplémentaires qui aident le développeur à travailler sur des
projets particuliers. Plusieurs bibliothèques peuvent ainsi être installées pour, par exemple, développer
des interfaces graphiques en Python.

Python peut être utilisé pour créer de petit logiciel, des programmes complets, des projets complexes tel
que les progiciels (un ensemble de plusieurs logiciels fonctionnants ensemble), programmation Hardware,
Intelligence artificielle, et bien plus encore.

I.1.c. Installer Python

L’installation de python est très simple. Il suffit de se rendre sur le site officiel de [Link], aller dans le
menu Download, puis cliquer sur la dernière version disponible pour la télécharger (Figure 2). Il est
recommandé de toujours installer la dernière version afin de profiter des fonctionnalités les plus récentes.
Le site vous propose directement la version adéquate selon votre système d’exploitation, qu’il soit
Windows, Linux, ou Mac. Notez que Python est préinstallé sur la plupart des distribution linux.

2|Page
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre I

Figure 2 : Télécharger Python 3.13

Une fois le fichier téléchargé, l’exécuter, choisir le mode d’installation personnalisé, puis cocher les
éléments disponibles tel montré sur la Figure 3. La case For all users peut être cochée si vous souhaitez
que le programme soit disponible pour tous les comptes utilisateurs de l’ordinateur.

Une fois installé, Python peut directement être utilisé en lançant le programme Python dans le menu
démarrer, tel montré sur la Figure 4.

Figure 3 : Installer Python 3.13

3|Page
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre I

Figure 4 : Lancer Python 3.13

4|Page
Dr. [Link]
 Chapitre II.
Notions de base
Cours Prog Python Avancée Génie électrique Chapitre II

Chapitre II. Notions de base

II.1. Mode interactif et mode script

Python offre deux manières de l’utiliser, en mode interactif ou en mode script, de la même manière que
Matlab. Il est possible d’écrire les instructions directement dans l’interpréteur et les exécuter, ou bien
écrire tout son programme dans un fichier texte portant l’extension .py et appelé Script, et de l’exécuter.

Pour commencer, on explore le mode interactif de Python, en lançant le programme Python 3.13 depuis
le menu démarrer (Figure 4). Une fenêtre noire apparait, avec un message d’accueil, prête à recevoir des
instructions.

II.2. Opérations arithmétiques et logiques de base

Python supporte les opérations arithmétiques et logique de base, communes dans le monde
informatique. Ces opérations, et les symboles utilisés, sont résumées dans le Tableau 1.

Tableau 1 : Opérations arithmétiques et logiques de bases dans Python

Nature Opération Symbol Exemple Résultat

Addition + >>> 10+3 13

Opérateurs arithmétiques

Soustraction - >>> 10-3 7

Multiplication * >>> 10*3 30
Division / >>> 10/3 3.3333333333333335
Division entière // >>> 10//3 3
Modulo ou reste de division % >>> 10%3 1
Carré ou puissance 2 ** >>> 10**3 1000
Supérieur à > >>> 10>3 True
Inférieur à < >>> 10>=10 True
Opérateur logiques

Supérieur ou égal à >= >>> 10<10 False

Inférieur ou égal à <= >>> 10<=10 True
Égal à == >>> 10==3 False
Différent de != >>> 10!=3 True
Non ou inverse logique not >>> not 10!=3 False

5|Page
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre II
II.3. Utiliser les variables
Un programme, qui fait souvent des calculs, doit stocker les résultats qu’il trouve dans la mémoire de
l’ordinateur. Mais pour pouvoir y revenir plus tard, il faut que ces données, rangées dans la mémoire,
soient identifiables de manière facile et unique. On utilise alors ce qu’on appelle un identificateur, pour
identifier de manière unique une variable quelconque.

Comme dans tout langage de programmation, un identificateur, ou plus précisément un nom de variable,
dans python est tout simplement une chaine de caractère (une phrase). Cependant, quelques conditions
limitent le choix de ce nom. Il ne doit contenir que des lettres, des chiffres, et le tiret-bas ( _ ), et doit
obligatoirement commencer par une lettre. On ne peut donc pas utiliser de lettres accentuées, des
espaces ou des symboles spéciaux.

Pour créer une variable dans Python, il suffit d’écrire directement son nom, suivit du signe égal, puis enfin
la valeur qui doit être stocké dans cette variable. On n’a pas besoin de déclarer la variable comme c’est le
cas dans les autres langages, tel que le C et le Pascal.

Pour utiliser la valeur stockée dans une variable, afin de réaliser un calcul par exemple, il suffit d’utiliser
son nom dans l’équation. Et pour afficher sa valeur, il suffit d’écrire le nom de la variable et de cliquer sur
Entrer. Le code suivant montre un exemple d’utilisation de variable pour calculer l’âge d’une personne.

>>> anneeNaissance = 1953

anneeEnCours = 2025
>>> age = anneeEnCours - anneeNaissance
>>> age
72
>>> age>100
False

Vous aurez compris que le type de la variable est automatiquement définit par l’interpréteur, sans avoir
besoin de le déclarer au préalable, tel que c’est le cas en Pascal par exemple.

Les types de variables existant sur Python sont les même que dans la plupart des langages. On y retrouve
alors les nombre entier (Integer), les nombres à virgule (Float), les chaines de caractères (String), et les
booléens (Boolean).

Pour déclarer une chaine de caractère, il suffit de l’écrire entre apostrophes ou guillemets (Voir les deux
exemples ci-dessous). Si vous utilisez des apostrophes, il ne sera pas possible d’écrire d’autres
apostrophes dans la phrase. Dans ce cas il faut utiliser le caractère d’échappement antislash ( \ ) avant les
autres apostrophes, sinon l’interpréteur affichera une erreur. La même chose est vraie dans le cas de
guillemets aussi (Voir les deux exemples ci-dessous).

#Exemple de déclaration d’une chaine de caractère en utilisant des apostrophes

6|Page
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre II

>>> phrase1 = 'ceci est une phrase'

>>> phrase1
'ceci est une phrase'
>>> phrase2 = 'Aujourd'hui on est mercredi'
File "<python-input-6>", line 1
phrase2 = 'Aujourd'hui on est mercredi'

SyntaxError: unterminated string literal (detected at line 1)

>>> phrase2 = 'Aujourd\'hui on est mercredi
>>> phrase2
"Aujourd'hui on est mercredi"

#Exemple de déclaration d’une chaine de caractère en utilisant des guillemets

>>> phrase2 = "le mot-clé utilisé est "True""

File "<python-input-11>", line 1
phrase2 = "le mot-clé utilisé est "True""

SyntaxError: invalid syntax

>>> phrase2 = "le mot-clé utilisé est \"True\""
>>> phrase2
'le mot-clé utilisé est "True" '

II.4. Les fonctions prédéfinies dans Python

Une fonction est un groupe d’instructions préenregistré, qui permet de les exécuter avec une seule ligne
de code sans avoir à récrire toutes les instructions à chaque fois. La plupart des fonctions ont besoin d'au
moins un paramètre pour travailler sur une donnée, ces paramètres sont des informations que vous
donnez à la fonction afin qu'elle travaille dessus. On s’approfondira plus dans ce concept plus tard dans
ce cours. Pour le moment, il est important de savoir que pour utiliser une fonction, il faut écrire son nom,
suivi de deux parenthèses entre lesquelles on écrit les paramètres requis par la fonction, de cette
manière :

>>> nom_de_la_fonction(parametre_1,parametre_2,…,parametre_n)

Python vient avec un grand nombre de fonctions prédéfinies prêtes à être utilisées, tel que les fonctions
mathématiques, des fonctions pour afficher des messages, lire des variables, etc.

A. La fonction “type”
On a vu avant que Python détermine automatiquement le type des variables à leur création. La fonction
type permet d’afficher le type des variables crées dans le programme. Le code suivant montre un exemple
d’utilisation de cette fonction.

>>> var1 = 'Bonjours'

>>> type(var1)
<class 'str'>
>>> var2 = 10
>>> type(var2)
<class 'int'>
>>> var3 = 10.0
>>> type(var3)

7|Page
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre II
<class 'float'>
>>> var4 = True
>>> type(var4)
<class 'bool'>

La fonction requiert la variable à examiner comme paramètre, et elle affiche un message montrant la
classe de cette variable : str est l’abréviation de String, int veut dire Integer, et bool est l’abréviation de
Boolean.

Cette fonction est très utile et importante dans certaines applications où il est important de connaitre le
type d’une variable pour déterminer quel traitement effectuer sur elle.

B. La fonction “Print”
Print permet d’afficher des messages et les valeurs des variables. Il est vrai qu’il est possible d’afficher la
valeur d’une variable dans l’interpréteur, mais cette astuce est limitée. D’un coté elle ne fonctionne pas
en mode script, et de l’autre, elle ne permet pas d’avoir du texte accompagnant la valeur affichée. Cette
fonction est plus utile en mode Script de Python.

Le code suivant montre quelques exemples d’utilisation de cette fonction, pour, respectivement, afficher
un message simple, afficher seulement la valeur d’une variable numérique, afficher la valeur d’une
variable numérique avec un message explicatif, afficher la valeur d’une variable String, et enfin combiner
plusieurs variables.

>>> var1 = 'Bonjour, quel beau matin.'

>>> var2 = 2025
>>> print('Bonjours et bienvenu sur Python')
Bonjours et bienvenu sur Python
>>> print(var2)
2025
>>> print('La valeur enregistrée dans la variable 2 est:',var2)
La valeur enregistrée dans la variable 2 est: 2025
>>> print(var1)
Bonjour, quel beau matin.
>>> print(var1,"On est en l'an",var2)
Bonjour, quel beau matin. On est en l'an 2025

Remarquez qu’il est possible de mettre plusieurs textes l’un après l’autre, séparés par des virgules, et la
fonction Print se chargera de coller tous les morceaux, tout en insérant automatiquement des espaces
entre eux, et de les afficher comme un seul paragraphe.

De plus, remarquez la différence entre afficher la valeur d’une variable String en écrivant son nom
directement, et en utilisant la fonction Print. La première méthode affiche le message entre apostrophes
(ou guillemets), tel écrit lors de l’affectation de la variable, alors que la fonction Print affiche le contenu
de la variable en enlevant les délimiteurs inutiles de la phrase.

>>> var1

8|Page
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre II
'Bonjour, quel beau matin.'
>>> print(var1)
Bonjour, quel beau matin.

C. Les fonctions mathématiques

Python vient avec un grand nombre de fonctions mathématiques intégrées, le tableau suivant résume
quelques

Fonction Signification Exemple Résultat

abs(a) Valeur absolue abs(-5) 5

min(a,b,c,d,…) La plus petite valeur donnée en paramètres min(3,5,6,1,5,7,4) 1

max(a,b,c,d,…) La plus grande valeur donnée en paramètres max(3,5,6,1,5,7,4) 7

pow(a,b) ab pow(2,4) 16

Basiquement, il n’y a que ces fonctions mathématique dabs Python. Les autres fonctions plus
compliquées, tel que le factoriel et les fonctions trigonométriques, sont disponible dans une bibliothèque
appelée math. Pour les utiliser il faut l’intégrer dans le programme via l’instruction « import math ». Ce
concept sera abordé plus tard dans ce cours.

D. Lire des variables avec la fonction input

Pour le moment, on a toujours donné les valeurs des variables dans le programme lui-même, ce qui fait
que son comportement est figé. Or, dans la plupart du temps, un programme a besoin d’être interactif, c-
à-d qu’il doit interagir avec l’utilisateur pour lui demander des informations ou de faire des choix. Ainsi,
la valeur des variables devient dépendante de ce que l’utilisateur insert.

Afin de demander à l’utilisateur la valeur d’une variable, on utilise la fonction input(), qui s’utilise comme
suit :

nomVariable = input('un message explicatif')

nomVariable est le nom de la variable dans laquelle la valeur écrite par l’utilisateur est enregistrée, et le
texte entre parenthèses est un message qui sera affiché à l’utilisateur pour lui expliquer ce qu’il doit faire.

Cette instruction interrompt le programme et attend que l'utilisateur saisisse ce qu'il veut puis appuie sur
Entrée. À cet instant, la fonction renvoie ce que l'utilisateur a saisi. Il faut donc récupérer cette valeur
dans une variable.

Sauf qu’un problème subsiste. Peu importe la donnée saisie par l’utilisateur, le type de la variable
nomVariable sera toujours Chaine de caractères. Pour remédier à ce problème, il faut la convertir. Pour
9|Page
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre II
convertir le type de n’importe quelle variable, il suffit d’utiliser le nom du type comme fonction, et de
passer la variable en paramètres. Voici un exemple :

>>> var = input("Veuillez saisir un nombre")

Veuillez saisir un nombre 15
>>> type(var)
<class 'str'>
>>> var = int(var)
>>> type(var)
<class 'int'>
>>> var = float(var)
>>> type(var)
<class 'float'>

Le potentiel et l’utilité de cette fonction seront plus abordés lors de l’exploration des scripts.

E. Demander de l’aide à Python

L’interpréteur Python offre une fonction d’aide, qui sert à afficher des descriptions détaillées des
fonctions de base. Elle s’utilise comme suit :

help(nomFonction)

Si on exécute cette commande sur la fonction abs, elle retourne un message expliquant à quel module
elle appartient, la syntaxe, le nombre d’arguments, et explique ce qu’elle fait au juste.

>>> help (abs)

Help on built-in function abs in module builtins:

abs(x, /)
Return the absolute value of the argument.

De plus, la documentation complète est disponible sur le site officiel [Link]/3 qui met à la
disposition des utilisateurs toute les ressources nécessaires pour maitriser toutes les fonctions de Python,
même les plus avancées.

II.5. Créer un script Python

Jusqu’à présent nous avons exploré que le mode interactif de Python, où on insert les instructions une à
une dans l’interpréteur. Mais cette pratique est limitée et devient très vite une source de problèmes dès
que le programme se complique un peu. Ainsi, pour créer un programme sous Python il faut regrouper
toutes les instructions dans un seul fichier texte, qu’on appelle un fichier Script, et qui porte l’extension
.py.

On peut utiliser n’importe quel éditeur de texte, tel que Notepad sous Windows. Il est recommandé de
télécharger et d’installer Notepad++ car il permet d’autocompléter le code saisi, et il ajoute des couleurs
au code afin qu’il soit plus facile à manipuler. Il est téléchargeable sur le site officiel [Link].

10 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre II
Maintenant il faut ouvrir l’éditeur de texte Notepad++, et lui indiquer qu’on va écrire du Python, en allant
dans le menu Language > lettre P > Python (Figure 5). Cette fenêtre servira à écrire le programme. Chaque
script devra avoir la structure suivante :

# -*-coding:UTF-8 -*
import os

# écrire son code ici ...

[Link]('pause')

Expliquons à quoi sert chaque ligne. La première permet au programme de prendre en charge les lettres
accentuées, la deuxième (import os) permet d’utiliser la fonction « [Link]('pause') » afin que la fenêtre
du programme ne se ferme pas automatiquement à la fin de l’exécution. Enfin, le programme doit être
écrit entre ces deux lignes, là où est écrit « écrire son code ici ».

Commençant par un programme simple, afficher un message de bienvenu, enregistrer quelques variables,
et enfin afficher un message d’au-revoir :

# -*-coding:UTF-8 -*
import os
print('Je suis heureux de vous présenter mon premier programme écrit en Python')
var1 = 'Bonjour, quel beau matin.'
var2 = 2025
print(var1,"On est en l'an",var2)
[Link]('pause')

Figure 5 : Configurer Notepad++ pour écrire en Python

Pour l’exécuter il faut d’abord l’enregistrer. Enregistrez le fichier dans un dossier de votre choix. Vous
remarquerez que Notepad++ ajoute automatiquement l’extension .py au fichier (Figure 6).

11 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre II

Figure 6 : Enregistrer le programme Python

Pour exécuter le programme, ouvrir le dossier contenant le fichier, et double cliquer dessus, on aura alors
le résultat affiché dans la Figure 7. Sans la dernière ligne [Link](‘pause’) la fenêtre se serait fermée
automatiquement sans donner le temps de lire ce qui s’est affiché.

Figure 7 : Exécution du premier programme Python

Un dernier concept très important : les commentaires. Il est possible d’insérer dans un fichier script du
texte qui ne sera pas lu par l’interpréteur, mais tout simplement ignoré, qu’on appelle commentaire. Il
permet de donner des indications et des précisions sur le code, car, dans le cas de projets compliqués, on
oublie souvent à quoi servent les lignes qu’on a écrit.

Pour en insérer dans le code, il suffit d’écrire dièse (#), suivit du texte explicatif, tel dans l’exemple ci-
après, où les commentaires sont écrits en vert.

# -*-coding:UTF-8 -*
import os # cette ligne permet d’utiliser l’instruction [Link]
# j’affiche tout d’abord un message de bienvenu
print('Je suis heureux de vous présenter mon premier programme écrit en Python')
var1 = 'Bonjour, quel beau matin.'
var2 = 2025
print(var1,"On est en l'an",var2) # cette ligne permet d’afficher un message
# cette instruction est à mettre à la fin pour que le programme ne se ferme pas
# directement
[Link]('pause')

12 | P a g e
Dr. [Link]
 Chapitre III.

Les structures conditionnelles

Cours Prog Python Avancée Génie électrique Chapitre III

Chapitre III. Les structures conditionnelles

III.1. Les structures de control

Pour le moment, tous les programmes que nous avons vus s’exécutent de manière séquentielle, linéaire
et prévisible, c-à-d que le programme n’a qu’un seul chemin d’exécution, la première instruction, puis la
deuxième, puis la troisième, et ainsi de suite. On sait donc d’avance ce que le programme fera quand il
sera exécuté. Mais pratiquement, un programme servant à résoudre des problèmes plus complexes, doit
souvent choisir entre deux ou plusieurs options, ou répéter une opération plusieurs fois de suite, ou bien
sauter l’exécution d’un certain nombre d’instructions. Pour permettre à un programme de faire ce genre
d’opérations, les structures de contrôle ont été créée.

Les structures de contrôle sont un bout de code indiquant à la machine qui exécute le programme qu’elle
doit faire des choix concernant son évolution. Elles sont de deux types : structure de contrôle
conditionnelle (ou condition), et structure de contrôle répétitive (ou boucle).

III.2. Les prédicats et les opérateurs logiques

Avant de parler des structures de contrôle, on doit aborder un concept important. Toutes les structures
de contrôle utilisent ce qu’on appelle des prédicats, qui ne sont rien d’autre que des équations
mathématiques logiques, c’est-à-dire des équations qui donnent un résultat logique (ou booléen). Elles
emploient les opérateurs logiques (voir Tableau 1), ainsi que les opérateurs and et or.

Les opérateurs and et or permettent de combiner plusieurs équations logiques afin d’éviter de condenser
plusieurs structures de contrôle. Ils sont utilisés de la manière suivante :

equationLogique1 and equationLogique2...

equationLogique1 or equationLogique2...

L’opérateur and donne un résultat vrai si et seulement si toutes les équations logiques donnent un résultat
vrai, tandis que l’opérateur or donne un résultat vrai si au moins une des équations logiques donne un
résultat vrai.

III.3. Structure de control conditionnelle : la forme minimale en if

Une structure de control conditionnelle sert à déterminer quel bloc d’instruction exécuter selon des cas
prédéfinis. La forme minimale s’écrit comme suit :

# instructions …
if conditionLogique :
# instruction 1
# instruction 2
# instruction 3
# instruction n

13 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre III
# suite du programme

La variable conditionLogique est de type booléen, qu’on appelle prédicat. Ça peut être soit une variable
booléenne ou bien une équation logique. Si sa valeur est True alors le bloc d’instructions 1 à n est exécuté,
puis le programme continu son exécution, sinon le bloc est ignoré, et le programme saute directement
aux instructions qui viennent après la structure. On différencie la structure conditionnelle de la suite du
programme par l’indentation (l’espace qui est à gauche de chaque ligne de code). La Figure 8 explique
graphiquement comment fonctionne cette structure.

Début du
programme

Évaluer La
Faux
condition
If conditionLogique :

logique

Vrai

Exécuter Le bloc
d instructions du if

Suite du programme

Figure 8 : Fonctionnement de la structure conditionnelle if

Voici un exemple :

# -*-coding:UTF-8 -*
import os
age = input("Quel est votre age? ")
age = int(age)
if age >= 18:
print("Vous êtes majeur")
print("Veuillez présenter votre document d'identité")
print ("Le programme est terminé")
[Link]('pause')

Les deux cas d’exécution de ce code donnent les résultats suivants :

# cas où la condition est fausse # cas où la condition est vraie

Quel est votre age? 15 Quel est votre age? 19
Le programme est terminé Vous êtes majeur
Press any key to continue . . . Veuillez présenter votre document d'identité
Le programme est terminé
Press any key to continue . . .
Vous remarquez que quand l’équation logique age>=18 est vraie, toutes les instructions sont exécutées,
mais quand la condition est fausse, les deux instructions qu’il y a dans la structure conditionnelle sont
ignorées.

14 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre III
III.4. Forme en if … else
Parfois, on a besoin de faire un choix entre deux blocs d’instructions, si une condition est vraie alors on
exécute un bloc, si la condition est fausse on exécute un autre. Ceci est possible grâce à la deuxième forme
de la structure conditionnelle avec if … else. Elle s’écrit comme suit :

# instructions …
if conditionLogique :
# Bloc d’instructions 1
else:
# Bloc d’instructions 2
# suite du programme

Dans ce cas, le programme fera un choix entre le bloc 1 et le bloc 2 selon que la condition soit vraie ou
fausse, comme expliqué dans la Figure 9.

Début du
programme

Évaluer Exécuter le bloc

Faux
l expression d instructions de
.
if conditionLogique :

logique else

Vrai

Exécuter le bloc du
else:

if

Suite du programme

Figure 9 : Fonctionnement de la structure conditionnelle if…else

Voici un exemple :

# -*-coding:UTF-8 -*
import os
age = input("Quel est votre age? ")
age = int(age)
if age >= 18:
print("Vous êtes majeur")
print("Veuillez présenter votre pièce d'identité")
else:
print ("Désolé, vous n'avez pas le droit de participer")
print ("Le programme est terminé")
[Link]('pause')

Les deux cas possibles dans ce programme donnent les résultats suivants :

# cas où la condition est fausse # cas où la condition est vraie

Quel est votre age? 15 Quel est votre age? 19
Désolé, vous n'avez pas le droit de Vous êtes majeur
participer Veuillez présenter votre pièce d'identité

15 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre III
Le programme est terminé Le programme est terminé
Press any key to continue . . . Press any key to continue . . .
On voit clairement que le programme exécute des blocs d’instructions différents selon que la condition
soit vraie ou fausse, soit l’un soit l’autre, mais jamais les deux. Il faut noter aussi que le mot clé else doit
être au même niveau d’indentation que l’instruction if qu’elle complète.

III.5. La forme complète if … elif … else

La structure conditionnelle permet aussi de prendre en compte un autre cas de figure : si plus de deux cas
sont envisageables. Si une situation présente plusieurs cas possibles, dans ce cas on peut utiliser la forme
complète de la structure conditionnelle, qui met en œuvre le mot clé elif, c’est l’abréviation de else if,
sinon si. Il permet d’ajouter des conditions intermédiaires, comme si plusieurs « if » sont utilisés. La
différence est que dans ce cas le traitement des conditions s’arrête dès qu’une condition est vraie, et ne
traitera pas les suivantes, ce qui augmente la vitesse du programme en évitant des calculs inutiles. Cette
structure s’écrit comme suit :

# instructions …
if conditionLogique1 :
# Bloc d’instructions 1
elif conditionLogique2 :
# Bloc d’instructions 2
elif conditionLogique3 :
# Bloc d’instructions 3
elif conditionLogiqueN :
# Bloc d’instructions n
else:
# Bloc d’instructions else
# suite du programme

Dans ce cas, le système va vérifier si la condition 1 est vraie, dans ce cas il exécute le bloc d’instructions 1
et ignore le reste des conditions et blocs associés, puis continu avec la suite du programme. Si la condition
1 est fausse, alors le système vérifie la condition 2, si elle est vraie il exécute le bloc 2 et ignore le reste
des conditions et blocs, puis continu avec le reste du programme, si la condition 2 est fausse alors il fait
de même avec la 3, et ainsi de suite jusqu’à atteindre une condition vraie, ou, le cas échéant, exécute le
bloc d’instructions else. On peut avoir autant de elif que nécessaire, et il n’est pas obligatoire d’avoir un
else à la fin. La Figure 10 explique graphiquement le fonctionnement de cette forme.

16 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre III
Début du
programme

.
elif conditionLogique2 :
if conditionLogique1 : .
Évaluer Évaluer Évaluer Exécuter le bloc
Faux Faux Faux
l expression l expression l expression d instructions de
logique 1 logique 2 logique 3 else

Vrai Vrai Vrai

Exécuter le bloc Exécuter le bloc Exécuter le bloc

else :

d instructions 1 d instructions 2 d instructions 3

Suite du programme

Figure 10 : Fonctionnement de la forme complète de la structure conditionnelle en python

Voici un exemple d’utilisation de cette structure :

# -*-coding:UTF-8 -*
import os
age = input("Quel est votre age? ")
age = int(age)
if age >= 100:
print("Vous êtes centenaire")
elif age >= 60:
print("Vous êtes retraité")
elif age >= 40:
print("Vous n'êtes plus aussi jeune")
elif age >= 15:
print("Vous êtes jeune et fort")
elif age >= 1:
print("Vous êtes très jeune")
else:
print ("Désolé, vous n'êtes pas encore né")
print ("Le programme est terminé")
[Link]('pause')

Tester ce programme avec plusieurs cas donne les résultats suivants :

# cas age = 120 # cas age = 30 # cas else

Quel est votre age? 101 Quel est votre age? 30 Quel est votre age? 0

Vous êtes centenaire Vous êtes jeune et fort Désolé, vous n'êtes pas encore né

Le programme est terminé Le programme est terminé Le programme est terminé

Press any key to continue . . . Press any key to continue . . . Press any key to continue . . .

Remarquez que le traitement des conditions s’arrête dès que le programme détecte une vraie, et les
autres ne seront pas traitées.

17 | P a g e
Dr. [Link]
Chapitre IV.

Les Boucles
Cours Prog Python Avancée Génie électrique Chapitre IV

Chapitre IV. Les boucles

IV.1. Introduction
Les boucles sont un bout de code qui permet de répéter un bloc d’instructions un certain nombre de fois,
tant qu’une condition spécifique est vraie, ou tant que le compteur n’a pas atteint sa valeur maximale. Il
en existe 2 : la boucle while et la boucle for.

IV.2. La boucle while

La boucle while s’écrit comme suit :

while expressionLogique :
# instruction 01
# instruction 02
# instruction 03
# instruction n

Son fonctionnement est simple, tant que l’expression logique donne un résultat vrai les instructions 1 à n
sont exécutées. On déduit que le résultat de l’expression doit pouvoir changer à chaque tour de boucle,
pour qu’à un moment donné elle renvoi un résultat faux, sinon on tombe dans ce qu’on appelle une boucle
infinie. La Figure 11 explique le fonctionnement de cette boucle :

Début du
programme
Boucle while

Évaluer Vrai Exécuter le bloc

l expression d instructions de la
logique boucle while

Faux

Suite du programme

Figure 11 : Boucle while

On va présenter trois exemples d’utilisation de cette boucle :

Exemple 01 : Vérifier le choix de l’utilisateur et insister sur lui pour respecter les règles.

On peut l’utiliser pour insister sur le respect d’une règle quand on demande à l’utilisateur d’insérer une
information via la fonction input. Imaginons qu’on demande à l’utilisateur d’insérer une nombre positif
inférieur à 10, mais il insert des nombres plus grand. Au lieu de continuer le programme et rencontrer des
erreurs par la suite, il vaudrait mieux vérifier si l’utilisateur a respecté la condition, le cas échéant insister
pour choisir un nombre plus approprié. Voici un exemple de code :
18 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre IV
nbr = input("Veuillez insérer un nombre compris entre 0 et 10 ")
nbr = float(nbr)
while nbr <= 0 or nbr >= 10 :
nbr = input("Erreur, intervalle non respecté, réessayez : ") # Instruction 01
nbr = float(nbr) # Instruction 02
print("Merci d'avoir respecté la condition et inséré le nombre",nbr) # Instruction 03
input() # Instruction 04

Ce programme insiste sur l’utilisateur d’insérer un nombre compris entre 0 et 10. Tant-que le nombre
inséré est inférieur ou égale a 0, OU supérieur ou égal a 10, le programme réexécute les instructions 01
et 02. Ce n’est que lorsque le prédicat « nbr <= 0 or nbr >= 10 » renvoi False que l’exécution de ces
deux instructions s’arrête, et le programme continu avec les instructions 03 et 04. Exécuter le programme
donne le résultat suivant :

Veuillez insérer un nombre compris entre 0 et 10 : 10

Erreur, intervalle non respecté, réessayez : 11
Erreur, intervalle non respecté, réessayez : 20
Erreur, intervalle non respecté, réessayez : -10
Erreur, intervalle non respecté, réessayez : 7
Merci d'avoir respecté la condition et inséré le nombre 7.0

Remarquez qu’on utilise ici l’instruction input() a la place de [Link](‘pause’), ce qui aura exactement
le même effet.

Exemple 02 : Exécuter un bloc d’instruction un nombre prédéfini de fois.

La boucle while est utilisée cette fois pour compter, ou répéter une ou plusieurs actions un nombre
prédéfini de fois. On doit utiliser pour cela une variable qui servira de compteur, on préfère généralement
utiliser la lettre i, qu’on va incrémenter à chaque tour de boucle, c-à-d qu’on lui ajoute un. Voici un
exemple :

print("Je vais afficher la phrase 'I Love Python' 5 fois")

i = 1 # on initialise le compteur i
while i <= 5: # on répète la boucle tant que le compteur n’a pas atteint sa limite
print(i,"- I Love Python") # on execute les instructions
i = i+1 # on incrémente enfin la variable compteur
print("Fin du programme")
input()

Il faut tout d’abord déclarer et initialiser la variable compteur, c-à-d lui donner une valeur initiale. Ça peut
être zéro, un, ou n’importe quelle autre valeur selon le besoin. On utilise ensuite un prédicat qui devient
faux dés que le compteur dépasse la limite souhaitée, puis enfin, on incrémente le compteur lorsque le
bloc d’instructions est achevé. L’exécution de ce programme donne le résultat suivant :

Je vais afficher la phrase 'I Love Python' 5 fois

1 - I Love Python
2 - I Love Python
3 - I Love Python
4 - I Love Python
5 - I Love Python
19 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre IV
Fin du programme

Bien sûr la variable i peut être utilisée pour faire des calculs, et l’incrémentation n’est pas obligatoirement
de 1, mais on peut l’incrémenter autant que nécessaire.

Exemple 03 :

IV.3. La boucle for

L’utilisation de la boucle for dans Python est différente par rapport aux autres langages, tel que le C++,
JAVA, ou encor MATLAB. Elle travaille sur des séquences, ou des listes, et non pas avec une variable qui
s’incrémente automatiquement. Les listes sont un sujet qui sera traité dans les chapitres à venir, mais on
verra quand même un ou deux exemples.

A ce stade d’avancement, on connaît un type de liste qu’on a beaucoup utilisé, la chaine de caractères,
qui n’est rien d’autre qu’une liste de caractères.

La boucle for s’écrit comme suit :

for var in List:

# instructions 01
# instructions 02
# instructions n
# Suite du programme

Ici, la variable var va prendre successivement les valeurs que contient la variable liste « List » une à une,
à chaque tour de boucle, jusqu’à ce que la boucle ait parcourue toute la liste. On peut alors utiliser la
valeur enregistrée dans var pour diverses opérations. Prenons un exemple, celui de parcourir les lettres
d’une variable str et de les afficher une à une :

nom = "Mazri"
i = 1
for lettre in nom:
print("Lettre n",i,"dans ton nom est",lettre)
i = i+1
input("Cliquer sur entrer pour quitter")

Voici ce que donne l’exécution de ce programme :

Lettre n 1 dans ton nom est M

Lettre n 2 dans ton nom est a
Lettre n 3 dans ton nom est z
Lettre n 4 dans ton nom est r
Lettre n 5 dans ton nom est i
Cliquer sur entrer pour quitter

On remarque qu’à chaque tour de la boucle, la variable lettre prend une seule valeur, une lettre de la
variable str « nom ». On a ajouté un compteur ici pour montrer le nombre de tours que la boucle a
effectué, où on remarque que le nombre de tours correspond au nombre des lettres de la variable nom.

20 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre IV
Le mot clé « in » peut être utilisé ailleurs que dans la boucle for. Il peut servir à vérifier si une valeur en
particulier se trouve dans une liste ou pas. Si on prend une chaine de caractères, alors il vérifie si une
lettre est contenue dans la chaine ou pas. Par exemple :

>>> "a" in "AMARA Abdessamed"

True
>>> "z" in "AMARA Abdessamed"
False

21 | P a g e
Dr. [Link]
 Chapitre V.

Les Fonctions
Cours Prog Python Avancée Génie électrique Chapitre V

Chapitre V. Les Fonctions

V.1. Introduction
En programmation, on est souvent amené à réutiliser un même bout de code plusieurs fois, dans des
endroits différents, dans le même programme. Ça serait très onéreux d’en faire plusieurs copies, car, d’un
coté ça consomme beaucoup d’espace, et de l’autre, si on veut améliorer ce code ou le corriger, il fraudera
passer en revue tout le programme. C’est dans le but d’éviter ces répétitions que les fonctions sont créées.

Une fonction est un bout de code réutilisable, possède obligatoirement un nom, et facultativement un ou
plusieurs paramètres (des valeurs d’entrée), et une valeur de retour (ou résultat).

Python vient avec pleines de fonctions de tout genre, tel que input() qui prend un message en paramètre
et retourne la valeur saisie par l’utilisateur, et print() qui prend uniquement un message en paramètre. Il
reste cependant possible de créer d’autres fonctions à des fins spécifiques.

V.2. Créer une fonction

La forme complète d’une déclaration de fonction est comme suit :

def fctName (parametre1, parametre2, parametre3, parametreN) :

#instruction 01
#instruction 02
#instruction 03
#instruction n
return result

La déclaration d’une fonction commence obligatoirement par le mot clé « def » (abréviation de define en
anglais) suivi d’un nom pour la fonction. Le nom de fonction obéit aux mêmes règles que les noms de
variable. Le tout suivit de paramètres d’entrée, mis entre parenthèses, et séparé par des virgules. On peut
ajouter autant de paramètres que nécessaire, comme on peut ne pas mettre du tout, quoique les
parenthèses restent obligatoires, tout comme les deux points qui clôturent la ligne.

Les instructions de la fonction sont indentées, et se termine par le mot clé « return », qui permet à la
fonction d’envoyer une valeur au programme principal qui a fait appel à la fonction, qu’il peut récupérer
via le signe égale (par exemple a = abs(-5)).

Dans toute fonction, les paramètres et le return ne sont pas obligatoire, ils peuvent être utilisés
uniquement si nécessaire. Et la déclaration se fait au début du script.

V.2.a. Créer une fonction figée

Donnons un exemple d’une fonction sans paramètres ni retour de résultat. Le programme suivant
contient une fonction, dont le nom est showSchema, qui affiche un petit dessin servant à séparer les

22 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre V
différents messages affichés par le programme. On la déclare au début du script, et, comme elle n’a pas
besoin de données pour travailler, on ne met aucun paramètre.

Pour utiliser la fonction, il suffit d’écrire son nom suivit de deux parenthèses. On dit qu’on fait appel à la
fonction. Dans ce programme, la fonction « showSchema() » est appelée 3 fois. Si on décide de ne pas
utiliser de fonction, alors le code de la fonction devra être répété trois fois dans le programme, ce qui
risque de très rapidement encombrer le code source.

def showSchema () : # On déclare notre fonction, elle n’a ni paramètres ni retour

i = 5
while i > 0 :
# Multiplier un caractère par un nombre permet de l’écrire autant de fois
print ((10-i)*" ", (i*2)*"-")
i -= 1

print("Bonjour, merci d'avoir choisi d'utiliser mon programme")

showSchema() # On fait appel à la fonction en écrivant son nom suivit de ()
print("Mon programme ne fait rien du tout")
showSchema()
print("J'espère que vous avez aimé l'expérience")
showSchema()
print("Au revoir")

input("END")

Notez aussi que dans la fonction print() à l’intérieur de la fonction on a multiplié un caractère par un
nombre. Ceci permet de le répéter autant de fois. Par exemple, « 3 * "s" » donnera comme résultat
« sss ».

Voici ce que donne ce programme une fois exécuté :

Bonjour, merci d'avoir choisi d'utiliser mon programme

----------
--------
------
----
--
Mon programme ne fait rien du tout
----------
--------
------
----
--
J'espere que vous avez aimé l'expérience
----------
--------
------
----
--
Au revoir
END

On remarque que les lignes de séparation s’affichent à chaque fois que la fonction est appelée.

23 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre V
V.2.b. Une fonction avec paramètres
Donnons maintenant un exemple d’une fonction avec paramètres. Une fonction qui permet d’afficher un
message souligné. Elle exploite la fonction print(), puis la fonction len() permet de renvoyer le nombre de
caractères d’une chaine de caractères, ce qui permet d’exploiter l’astuce expliquée dans l’exemple
précédent.

def printL(msg) :
print(msg)
size = len(msg) # Permet de donner le nombre de caractères de la chaine msg
print(size * "-")

print("Bonjour, merci d'avoir choisi d'utiliser mon programme")

print("Ceci est un message simple")
print()

printL("Ceci est un message souligné, c'est beau non?")

printL("Au revoir")

input("END")

Ce programme donne le résultat suivant :

Bonjour, merci d'avoir choisi d'utiliser mon programme

Ceci est un message simple

Ceci est un message souligné, c'est beau non?

---------------------------------------------
Au revoir
---------
END

Bien entendu, notre fonction peut avoir autant de paramètres que nécessaire, et on est pas obligé de se
limiter à un seul.

V.2.c. Fonction avec valeur de retour

Passons à présent à un exemple de fonction qui retourne une valeur. Une fonction « toPay » qui retourne
la valeur de la remise selon le nombre d’articles acheté.

def toPay(prix, nbrArticles) :

if nbrArticles < 3:
aPayer = prix
elif nbrArticles == 3:
aPayer = prix*0.9
elif nbrArticles == 4:
aPayer = prix*0.75
elif nbrArticles == 5:
aPayer = prix*0.6
else :
aPayer = prix*0.5
return aPayer

p = input("Insérez le prix? ")

p = int(p)
n = input("Combien d'articles? ")

24 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre V
n = int(n)

prixApayer = toPay(p,n)

print("Vous devez payer", prixApayer, "DA")

input("Appuyez sur entrer pour quitter")

V.2.d. Fonction avec plusieurs valeurs de retour

Il est aussi possible de renvoi plus d’une valeur, en les séparant par des virgules dans l’instruction return :

return var1, var2, var3

V.3. Valeur par défaut des paramètres

Python permet d’affecter une valeur par défaut aux paramètres d’une fonction. Ceci permet d’avoir des
fonctions plus polyvalentes. C’est très utile lorsque la valeur d’un paramètre est souvent la même, sauf
dans des cas précis, ce qui permet de gagner du temps.

Reprenons l’exemple précédent, on le modifie pour prendre en charge un second paramètre « char »,
auquel on assigne une valeur par défaut on la spécifiant entre les parenthèses de la fonction :

def printL(msg, char = '-') : # On précise la valeur par défaut ici

print(msg)
size = len(msg) # Permet de donner le nombre de caractères de la chaine msg
print(size * char)

print("Bonjour, merci d'avoir choisi d'utiliser mon programme")

print("Ceci est un message simple")
print()

printL("Ceci est un message souligné avec le caractère par défaut") # I01

print()
printL("là je teste un autre caractère", '*') # I02
print()
printL("Et là un autre", '~') # I03
print()

input("END")

On remarque quand l’instruction I01 ne spécifie pas le caractère à utiliser pour souligner. Si la valeur par
défaut de char n’a pas été spécifié le programme ne fonctionnerait pas, car dans ce cas, la variable char
n’aura pas de valeur. Mais dans ce cas, le programme donne le résultat suivant :

Bonjour, merci d'avoir choisi d'utiliser mon programme

Ceci est un message simple

Ceci est un message souligné avec le caractère par défaut

----------------------------------------------------------

là je teste un autre caractère

*******************************

Et là un autre
~~~~~~~~~~~~~~
25 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre V

END

V.4. Signature d’une fonction

La signature d’une fonction sont les éléments qui permettent à python d’identifier une fonction. Il s’agit
tout simplement de son nom. On peut définir plusieurs fonctions avec le même nom, mais la dernière
écrasera les précédentes, qui ne seront plus prises en compte par le programme.

V.5. Les modules

Python, bien qu’il soit lui-même puissant, permet d’ajouter encore plus de fonctionnalités via ce qu’on
appel les modules. Ce sont un bout de code, contenant des fonctions et des variables, enregistré dans un
fichier. Ces fonctions et variables peuvent avoir un lui entre elles, comme par exemple des fonctions et
des variables purement mathématiques afin de réaliser des calculs mathématiques poussés, ou bien des
fonctions qui permettent de manipuler des fichiers, établir des connexions internet, etc.

Pour pouvoir utiliser ces fonctions, il suffit d’importer le module pour qu’il soit accessible et utilisable par
le programme. L’importation de modules se fait via l’instruction import.

Il existe un grand nombre de modules disponibles avec Python sans qu'il soit nécessaire d'installer des
bibliothèques supplémentaires. Pour cette partie, nous prendrons l'exemple du module math qui
contient, comme son nom l'indique, des fonctions mathématiques.

V.5.a. La méthode import

Dans un programme python, les fonctionnalités du module math ne sont pas disponible par défaut,
comme par exemple la fonction sqrt qui calcul la racine carrée, factorial qui calcul le factoriel, ou bien
encor exp qui calcul l’exponentiel d’un nombre. Pour pouvoir les utiliser, il faut importer le module math,
en insérant l’instruction suivante dans le programme :

import math

Ceci de rendre l‘ensemble des fonctions et des constantes du module math accessibles au programme,
tel que celles montrées dans le Tableau 2. Une liste plus exhaustive peut être consulté sur la
documentation en ligne de python à cette adresse : math — Mathematical functions, ou bien en
exécutant l’instruction help("math") dans l’interpréteur.

Tableau 2: Liste non exhaustive de quelques fonctions et constantes du module math

Fonction ou variable Signification

factorial(x) Factoriel du nombre x
gcd(x1, x2, x3, x4, xn) Plus grand commun diviseur des nombres donnés en paramètres
ceil(x) L’entier le plus petit supérieur ou égal à x

26 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre V
floor(x) L’entier le plus grand inférieur ou égal à x
trunc(x) La partir entière de x
exp(x) Exponentiel de x
log(x) Logarithme népérien de x (ln(x))
log10(x) Logarithme décimal de x
sqrt(x) Racine carrée de x
degrees(x) Convertir l’angle x du degré au radian
radians(x) Convertir l’angle x du radian au degrés
acos(x), asin(x), atan(x) Arc cosinus, sinus, et tangente de x
atan2(y, x) Arc tangente de x prenant en compte les quatre quadrants
cos(x), sin(x), tan(x) Cosinus, sinus, et tangente de x
pi La constante π = 3.141592…
e La constante e = 2.718281…
inf Infini positif

Pour utiliser les fonctions et les constantes de ce module, il faut appeler la fonction en utilisant la forme
suivante :

# en général
[Link]()
# exemples
A = [Link](25)
omega = 2 * [Link] * 50
f = [Link](x)

Si on a besoin d’une seule fonction, ou de quelques-unes seulement, on peut choisir d’inclure d’importer
uniquement ce dont on a besoin, et éviter ainsi d’alourdir le programme inutilement. On le fait via
l’instruction suivante :

# en général
from module import fonction
# exemples
from math import sqrt
from math import pi

Dans ce cas, on fait appel à ces fonctions directement par leurs noms, sans écrire le nom du module avant
chaque appel. Car dans ce cas, les fonctions importées sont placées dans l’espace de nom principal, alors
que quand on importe un module en entier, l’ensemble de son contenu est enregistré dans un espace de
nom différent du principal, et qui porte le nom du module lui-même. On peut modifier le nom de cet
espace de nom en important le module en utilisant l’instruction suivante :

import math as m

Dans ce cas, l’appel aux fonctions du module en remplaçant le terme math par m :

A = [Link](25)

27 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre V
omega = 2 * [Link] * 50
f = [Link](x)

V.5.b. Créer son propre module

Sur python, il est possible de créer nos propres modules, qui rassembleront nos fonctions et constantes.
Dans ce cas, les fonctions devront être écrites dans un fichier .py, comme un programme ordinaire, mais
ce fichier n’est pas destiné à être exécuté via un double clic.

Comme exemple, on va créer un module dans lequel on va rassembler des fonctions utiles pour le module
Électrotechnique Fondamentale 1. Le fichier .py du module aura alors le contenu suivant :

from math import pi

def Zep(z1,z2):
# calcule l'impédance équivalente de deux impédances en parallèle
return 1/(1/z1 + 1/z2)

def Zes(z1,z2):
# calcule l'impédance équivalente de deux impédances en série
return z1 + z2

def p(u,z):
# calcule la puissance consommée par une impédance
i = u/abs(z)
return u*i*i

def Zl(l):
# calcule l'impédance d'une inductance
z = pi*l*100j
return z

def Zc(c):
# calcule l'impédance d'une capacité
z = -1j/(100*pi*c)
return z

On enregistre alors ce code dans un fichier qu’on va appeler [Link]. Pour l’utiliser, il suffit de l’importer
dans un programme qui va l’exploiter. Prenons l’exemple d’un programme qui va résoudre un exercice
d’électrotechnique :

import elt

print("Ce programme résout l'exercice 5 de la série de TD numéro 2")

c = 63e-6
l = 16e-3
r1 = 7
r2 = 17
# on calcule les impédances de C et L
zc = [Link](c)

zl = [Link](l)

# R2 et C sont en série, puis en parallèle avec L, et enfin le tout

# est en série avec R1
z1 = [Link](r2,zc)

28 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre V
z2 = [Link](z1,zl)
z = [Link](z2,r1)

print(zl)
print(zc)
print(z1)
print(z2)
print(z)

input("fini")

On exploite ici les équations du module elt pour résoudre un exercice. Exécuter ce programme donnera
le résultat suivant :

Ce programme résout l'exercice 5 de la série de TD numéro 2

5.026548245743669j
(-0-50.52537875933186j)
(17-50.52537875933186j)
(0.18206826728221837+5.513836083095217j)
(7.182068267282219+5.513836083095217j)
fini

On peut remarquer que le python prend nativement en charge les nombres complexes.

V.5.c. Quelques modules utiles

Python intègre plusieurs modules très utiles, en plus du modules math, on peut citer le module « cmath »
pour les calculs sur les nombres complexes, « fractions », qui permet de prendre en charge les fractions.
Il permet de créer des fractions à partir d’un nombre décimal, réaliser des opérations mathématiques, et
de simplifier les fractions.

D’autre modules sont utiles dans des domaines spécifiques, tel que « email » pour la gestion des emails,
« gzip » pour la manipulation des fichiers compressés, « html » pour la prise en charge du langage HTML,
« random » qui sert à générer des nombres pseudo aléatoires, ou bien encore « secrets » qui est utilisé
pour la cryptographie.

La liste complète des modules disponible dans python peut être consultée en exécutant l’instruction
help(‘modules’) dans l’interpréteur.

29 | P a g e
Dr. [Link]
 Chapitre VI.

Les Listes et Tuples

Cours Prog Python Avancée Génie électrique Chapitre VI

Chapitre VI. Les Listes et Tuples

VI.1. Introduction
Une liste, comme son nom l’indique, est une séquence de données, des valeurs d’un ou plusieurs types,
regroupée dans une seule variable au lieu que ce soit dans des variables différentes. Par exemple, pour
enregistrer les notes d’un étudiant, au lieu de créer des variables différentes pour chaque matière, il est
possible d’enregistrer directement la liste dans une seule variable de type liste.

Une liste peut contenir des données de même type, comme des entiers ou des chaînes de caractères, ou
bien contenir des données de types différents.

Elle permet de bien organiser les données, et facilite la gestion et la manipulation de grandes quantités
de données. Nous allons apprendre dans ce chapitre à les créer, éditer, et manipuler les listes.

Quand aux tuples, ce sont tout simplement des listes, mais qui sont non modifiables.

VI.2. Créer une liste

Pour créer une liste, il suffit d’écrire les valeurs qu’elle doit contenir entre crochets, en séparant les valeurs
par des virgules :

>>> maListe = [3, 5, 7, 11, 13, 17]

>>> maListe
[3, 5, 7, 11, 13, 17]

Et la fonction type montre bien que la variable est de type Liste :

>>> type(maListe)
<class 'list'>

On peut mettre n’importe quel type de données dans une liste, même d’autres listes. Voici des exemples :

# une liste de chaîne de caractères

noms = ['Ali', 'Said', 'Kamal', 'Farid']
# une liste de listes
listeNotes = [['Ali', 15], ['Said', 18], ['Kamal', 10], ['Farid', 8]]

VI.3. Accéder aux éléments d’une liste

Pour accéder aux éléments d’une liste, il suffit d’écrire le nom de la variable suivit de l’indice de l’éléments
auquel on veut accéder entre crochets. Notez que le premier élément d’une liste possède l’indice 0. Voici
un exemple :

>>> noms = ['Ali', 'Said', 'Kamal', 'Farid']

>>> noms[0]
'Ali'
>>> noms[1]
'Said'
>>> noms[2]

30 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre VI
'Kamal'
>>> listeNotes[1]
['Said', 18]

Une autre manière d’accéder aux éléments d’une liste est via la boucle for. C’est ici que son réel intérêt
apparaît, et elle est très utilisées pour parcourir les éléments d’une liste. L’exemple suivant montre
comment accéder aux éléments d’une liste en utilisant les deux façons, via un indice entre crochets, et en
utilisant la boucle for. On peut remplacer la boucle for par une boucle while, en créant une variable
compteur, et en mettant la longueur de la liste comme limite supérieur du compteur.

modules = ['Maths', 'Physique', 'Programmation Python', 'Arabe', 'Anglais']

notes = [15, 10, 18, 14, 13]

i = 0

print('Parcourir la liste en utilisant la boucle for')

for element in modules:
# la variable element prend les valeurs qu'il y a dans la liste modules
# une à une, en passant à la valeur suivante à chaque tour de boucle
print("la note de", element, "est", notes[i])
i += 1

print('-------------------------------------------------')

print('Parcourir la liste en utilisant la boucle while')

i = 0
while i < len(modules):
# la fonction len renvoi la taille de la liste modules
print("la note de", modules[i], "est", notes[i])
i += 1

input("fin du programme")

Ce programme donne le résultat suivant :

Parcourir la liste en utilisant la boucle for

la note de Maths est 15
la note de Physique est 10
la note de Programmation Python est 18
la note de Arabe est 14
la note de Anglais est 13
-------------------------------------------------
Parcourir la liste en utilisant la boucle while
la note de Maths est 15
la note de Physique est 10
la note de Programmation Python est 18
la note de Arabe est 14
la note de Anglais est 13
fin du programme

On voit bien que la boucle for parcours les éléments de la liste « modules », et les met un à un dans la
variable « element », en passant à l’élément suivant à chaque tour de boucle.

31 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre VI
VI.4. La fonction enumerate
La fonction « enumerate » permet de faciliter le parcourt d’une liste. Elle s’utilise avec la boucle for, et
permet d’obtenir à la fois les éléments de la liste ainsi que leurs indices correspondants dans des variables
séparées. Elle s’utilise de cette manière :

modules = ['Maths', 'Physique', 'Programmation Python', 'Arabe', 'Anglais']

print('Parcourir la liste en utilisant enumerate')

for i, element in enumerate(modules):
# la variable i prend l'indice, et la variable element prend l'éléments lui-même
print("i=", i)
print("la note de", element, "est", notes[i])

input("fin du programme")

On remarque que enumerate renvoi non pas une valeur mais deux. La première est l’indice des éléments
de la liste, qui commence par 0, et qu’on récupère dans la variable « i », et la deuxième est l’éléments lui-
même. Cette procédure donne le résultat suivant :

Parcourir la liste en utilisant enumerate

i= 0
la note de Maths est 15
i= 1
la note de Physique est 10
i= 2
la note de Programmation Python est 18
i= 3
la note de Arabe est 14
i= 4
la note de Anglais est 13
fin du programme

C’est très pratique, quand on a besoin de l’indice des éléments dans la boucle, sans avoir à créer
manuellement une variable compteur comme c’était le cas avec les méthodes précédentes.

VI.5. Manipuler et modifier les éléments d’une liste

VI.5.a. Ajouter un élément à la fin d’une liste
Il est possible d’ajouter des éléments à la fin d’une liste de deux façons différentes. La première consiste
à utiliser la fonction append :

>>> modules = ['Maths', 'Physique', 'Python', 'Arabe', 'Anglais']

>>> modules
['Maths', 'Physique', 'Python', 'Arabe', 'Anglais']
>>> [Link]('Machines électriques')
>>> modules
['Maths', 'Physique', 'Python', 'Arabe', 'Anglais', 'Machines électriques']

La deuxième méthode consiste à utiliser l’opérateur += :

>>> modules = ['Maths', 'Physique', 'Python', 'Arabe', 'Anglais']

>>> modules += ['Machines']
>>> modules
['Maths', 'Physique', 'Python', 'Arabe', 'Anglais', 'Machines']
32 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre VI
VI.5.b. Concaténer deux listes
Concaténation de deux listes veut dire les coller l’une après l’autre. C’est similaire à l’ajout d’éléments à
la fin d’une liste, qui se réalise donc de la même manière via le signe « += », mais qui devra être suivit
d’une liste au lieu que d’un seul élément.

>>> groupeA = ['Ali', 'Smail', 'Farid']

>>> groupeB = ['Yacine', 'Anes', 'Houdaifa']
>>> groupeA
['Ali', 'Smail', 'Farid']
>>> groupeA += groupeB
>>> groupeA
['Ali', 'Smail', 'Farid', 'Yacine', 'Anes', 'Houdaifa']
>>> groupeA += ['Youcef', 'Mohamed']
>>> groupeA
['Ali', 'Smail', 'Farid', 'Yacine', 'Anes', 'Houdaifa', 'Youcef', 'Mohamed']

Une autre méthode est d’utiliser la fonction « extend ».

>>> groupeA = ['Ali', 'Smail', 'Farid']

>>> groupeB = ['Yacine', 'Anes', 'Houdaifa']
>>> groupeA
['Ali', 'Smail', 'Farid']
>>> [Link](groupeB)
>>> groupeA
['Ali', 'Smail', 'Farid', 'Yacine', 'Anes', 'Houdaifa']

VI.5.c. Insérer un élément dans la liste

La fonction « insert » permet d’insérer des éléments à un endroit précis d’une liste. Elle s’écrit comme
suit :

>>> modules = ['Maths', 'Physique', 'Python', 'Arabe', 'Anglais']

>>> modules
['Maths', 'Physique', 'Python', 'Arabe', 'Anglais']
>>> [Link](2,'ELT')
>>> modules
['Maths', 'Physique', 'ELT', 'Python', 'Arabe', 'Anglais']

Dans la ligne 4 du code ci-avant, on demande d’insérer l’élément ‘ELT’ dans la case portant l’indice 2 (qui
est en fait la troisième case). De ce fait, Python décale tous les éléments qu’il y a après cet indice d’une
case pour faire de l’espace pour ce nouvel élément.

VI.5.d. Supprimer un élément d’une liste

On peut supprimer un élément d’une liste via la fonction « remove », qui prend en paramètre l’élément
à supprimer et non pas son indice. Elle parcourt toute la liste et supprimer uniquement la première
occurrence de cet élément :

>>> groupe = ['Ali', 'Smail', 'Farid', 'Youcef', 'Yacine', 'Anes', 'Houdaifa',

'Youcef']
>>> [Link]('Youcef')
>>> groupe
['Ali', 'Smail', 'Farid', 'Yacine', 'Anes', 'Houdaifa', 'Youcef']
>>> [Link]('Youcef')

33 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre VI
>>> groupe
['Ali', 'Smail', 'Farid', 'Yacine', 'Anes', 'Houdaifa']

La deuxième méthode est l’utilisation du mot clé « del », qui est l’abréviation du mot Delete. C’est un
mot-clé réservé à python qui permet de supprimer des données et des variables. Il s’utilise comme suit :

>>> groupe = ['Ali', 'Smail', 'Farid', 'Youcef', 'Yacine', 'Anes', 'Houdaifa',

'Youcef']
>>> del groupe[3]
>>> groupe
['Ali', 'Smail', 'Farid', 'Yacine', 'Anes', 'Houdaifa', 'Youcef']
>>> del groupe
>>> groupe
Traceback (most recent call last):
File "<python-input-51>", line 1, in <module>
groupe
NameError: name 'groupe' is not defined.

Le mot-clé del requiert l’indice de l’élément à supprimer, et non pas l’élément lui-même, comme on le
voit dans l’exemple ci-avant. Cet exemple montre aussi que ce mot-clé permet d’effacer toute une
variable, ici la variable groupe, en indiquant tout simplement le nom de la variable à supprimer.

VI.5.e. Quelques fonctions utiles sur les listes

Certaines fonctions s’appliquant aux listes ont déjà été vue précédemment, tel que remove, append, et
extend. On en trouve d’autre, tel que :

A. Ordonner une liste

Pour ordonner une liste on utilise la fonction « sort », elle s’utilise comme suit :

[Link]() # Organiser les éléments par ordre ascendant

[Link](reverse = True) # Organiser les éléments par ordre descendant

Mettre « reverse = True » entre les parenthèses permet d’avoir un ordre descendant des éléments.

B. Inverse une liste

La fonction « reverse » permet d’inverser l’ordre des éléments d’une liste :

[Link]()

C. Compter le nombre de répétition d’un élément

Pour savoir combien est répété un élément donné d’une liste, on utilise la fonction « count » :

[Link](valeur)

VI.6. Les Tuples

Un Tuple est tout simplement une liste, mais qui a la particularité d’être non modifiable après sa création.
Il est possible de le créer et de le parcourir, mais les fonctions d’ajout ou de suppression d’éléments ne

34 | P a g e
Dr. [Link]
Cours Prog Python Avancée Génie électrique Chapitre VI
s’applique pas à lui. Il se déclare exactement de la même manière qu’une liste, mais en utilisant des
parenthèses à la place des crochets.

>>> modules = ('Maths', 'Physique', 'ELT', 'Python', 'Arabe', 'Anglais')

>>> modules
('Maths', 'Physique', 'ELT', 'Python', 'Arabe', 'Anglais')
>>> type(modules)
<class 'tuple'>
>>> modules[2]
'ELT'
>>> [Link]('ELT')
Traceback (most recent call last):
File "<python-input-88>", line 1, in <module>
[Link]('ELT')
^^^^^^^^^^^^^^
AttributeError: 'tuple' object has no attribute 'remove'
>>> del modules[2]
Traceback (most recent call last):
File "<python-input-89>", line 1, in <module>
del modules[2]
~~~~~~~^^^
TypeError: 'tuple' object doesn't support item deletion
>>> [Link](2,'Un autre module')
Traceback (most recent call last):
File "<python-input-92>", line 1, in <module>
[Link](2,'Un autre module')
^^^^^^^^^^^^^^
AttributeError: 'tuple' object has no attribute 'insert'

On remarque dans cet exemple qu’il est possible d’utiliser un tuple comme une liste, mais l’insertion et la
suppression d’éléments ne s’applique pas à lui. C’est très utile quand on a besoin d’une liste d’élément
qui ne doit pas être modifiée ni altérée.

35 | P a g e
Dr. [Link]