Python Course

Programmation
Informatique (Partie 2)
Prof. M. Lahlou
Département de Statistique et de d'Informatique Appliquées
Bases de Python
Variables & Principaux types de données
Python est un langage à typage dynamique, ce qui signifie qu’il n’est pas nécessaire de
déclarer les variables avant de pouvoir leur affecter une valeur. La valeur que l’on affecte
possède un type qui dépend de la nature des données (nombre entier, nombre à virgule,
chaîne de caractères, etc.). Le type du contenu d’une variable peut donc changer si on
change sa valeur.
Wednesday, October 7, 2020 Prof. M. LAHLOU 44

Variables
• Une variable est une zone de la mémoire de l'ordinateur dans laquelle une valeur
est stockée. Aux yeux du programmeur, cette variable est définie par un nom, alors
que pour l'ordinateur, il s'agit en fait d'une adresse, c'est-à-dire d'une zone
particulière de la mémoire.
• En Python, la déclaration d'une variable et son initialisation (c'est-à-dire la
première valeur que l'on va stocker dedans) se font en même temps. Pour vous en
convaincre, testez les instructions suivantes après avoir lancé l'interpréteur :
• Ligne 1. Dans cet exemple, nous avons déclaré, puis initialisé la variable x avec la
valeur 2. Notez bien qu'en réalité, il s'est passé plusieurs choses :
• Python a « deviné » que la variable était un entier. On dit que Python est un langage au typage
dynamique.
• Python a alloué (réservé) l'espace en mémoire pour y accueillir un entier. Chaque type de variable
prend plus ou moins d'espace en mémoire. Python a aussi fait en sorte qu'on puisse retrouver la
variable sous le nom x.
• Enfin, Python a assigné la valeur 2 à la variable x.
Variables (suite)
• Lignes 2 et 3. L'interpréteur nous a permis de connaître le contenu de la

variable juste en tapant son nom. Retenez ceci car c'est une spécificité de
l'interpréteur Python, très pratique pour chasser (debugger) les erreurs
dans un programme. Par contre, la ligne d'un script Python qui contient
seulement le nom d'une variable (sans aucune autre indication) n'affichera
pas la valeur de la variable à l'écran lors de l'exécution (pour autant, cette
instruction reste valide et ne générera pas d'erreur).
• Sachez par ailleurs que l'opérateur d'affectation = s'utilise dans un certain
sens. Par exemple, l'instruction x = 2 signifie qu'on attribue la valeur située à
droite de l'opérateur = (ici, 2) à la variable située à gauche (ici, x). D'autres
langages de programmation comme R utilisent les symboles <- pour rendre
l'affectation d'une variable plus explicite, par exemple x <- 2.
• Enfin, dans l'instruction x = x - 3, l'opération x - 3 est d'abord évaluée et
ensuite le résultat de cette opération est affecté à la variable x.

Noms de variables
• Les noms de variables sont des noms qu’on choisit assez librement
• De préférence assez courts, mais aussi explicites que possible, pour exprimer
clairement ce que la variable est censée contenir:
• altitude, altit ou alt (au lieu de x ) pour exprimer une altitude
• prix_unit pour exprimer un prix unitaire, etc.
• Quelques règles pour les noms de variables sous Python :
1. Un nom de variable est une séquence de lettres (a à z , A à Z) et de chiffres (0 à 9), qui doit
toujours commencer par une lettre.
2. Seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles, les espaces,
les caractères spéciaux tels que $, #, @, etc. sont interdits, à l'exception du caractère _
(souligné).
3. La casse est significative (les caractères majuscules et minuscules sont distingués). Attention
: Altitude, altitude, ALTITUDE sont donc des variables différentes. Soyez attentifs !
4. Prenez l'habitude d'écrire l'essentiel des noms de variables en caractères minuscules (y
compris la première lettre). Il s'agit d'une simple convention, mais elle est largement
respectée. N'utilisez les majuscules qu'à l'intérieur même du nom, pour en augmenter
éventuellement la lisibilité, comme dans TableDesMatieres.
Algorithmique et Programmation 40
Mots réservés
• En plus de ces règles, il faut encore ajouter que vous ne pouvez
pas utiliser comme noms de variables les 29 «mots réservés» au
langage ci-dessous :
and assert break class continue def
del elif else except exec finally
for from global if import in
is lambda not or pass print
raise return try while yield
Typage des variables
• Sous Python, il n'est pas nécessaire d'écrire des lignes de programme spécifiques pour
définir le type des variables avant de pouvoir les utiliser. Il vous suffit en effet
d'assigner une valeur à un nom de variable pour que celle-ci soit automatiquement
créée avec le type qui correspond au mieux à la valeur fournie.
• Ceci constitue une particularité intéressante de Python, qui le rattache à une famille
particulière de langages où l'on trouve aussi par exemple Lisp, Scheme, et quelques
autres. On dira à ce sujet que le typage des variables sous Python est un typage
dynamique, par opposition au typage statique qui est de règle par exemple en C++ ou
en Java.
• Le typage statique est préférable dans le cas des langages compilés, parce qu'il
permet d'optimiser l'opération de compilation (dont le résultat est un code binaire
« figé »).
• Le typage dynamique quant à lui permet d'écrire plus aisément des constructions
logiques de niveau élevé (métaprogrammation, réflexivité), en particulier dans le
contexte de la programmation orientée objet (polymorphisme). Il facilite également
l'utilisation de structures de données très riches telles que les listes et les
dictionnaires.
Les types des données

Python est un langage dont le typage est automatique. Cela signifie que bien que
gérant différents types, lorsqu'une variable est affectée, l'interpréteur trouvera
automatiquement son type.
Liste des types
int Nombre entier optimisé
long Nombre entier de taille arbitraire
float Nombre à virgule flottante
complex Nombre complexe
str Chaîne de caractère
list Liste de longueur variable
dict dictionnaire
bool Booléen
La fonction type()
Pour connaître le type d’une donnée ou le type de la valeur d’une variable, il
suffit d’utiliser la fonction type().
Exemples :
Le type int (entier) et le type float (réelle)

Le type int est utilisé pour stocker un entier, en anglais integer. Pour cette
raison, on appelle ce type int.
Le type float est utilisé pour stocker des nombres à virgule flottante,
désignés en anglais par l’expression floating point numbers. Pour cette
raison, on appelle ce type : float. En français, on parle de flottant.
Exemples :

Opérations sur les types numériques
• Les quatre opérations arithmétiques de base se font de manière simple sur
les types numériques (nombres entiers et floats) :
• Remarquez toutefois que si vous mélangez les types entiers et floats, le

résultat est renvoyé comme un float (car ce type est plus général). Par
ailleurs, l'utilisation de parenthèses permet de gérer les priorités.
• L'opérateur / effectue une division. Contrairement aux opérateurs +, - et *,
celui-ci renvoie systématiquement un float :
Opérations sur les types numériques (suite)

L'opérateur puissance utilise les symboles ** :
Pour obtenir le quotient et le reste d'une division entière (voir ici pour un petit rappel sur
la division entière), on utilise respectivement les symboles // et modulo % :
Les symboles +, -, *, /, **, // et % sont appelés opérateurs, car ils réalisent des opérations
sur les variables.
Enfin, il existe des opérateurs « combinés » qui effectue une opération et une affectation
en une seule étape :
L'opérateur += effectue une addition puis affecte le résultat à la
même variable. Cette opération s'appelle une « incrémentation ».
Les opérateurs -=, *= et /= se comportent de manière similaire
pour la soustraction, la multiplication et la division.

Opérateurs mathématiques
symbole effet exemple

+ addition 6+4 == 10
- soustraction 6-4 == 2
* multiplication 6*4 == 24
/ Division réelle 6/4 == 1.5
** élévation à la puissance 12**2 == 144
// division entière 6//4 == 1

% reste de la division entière 6%4 == 2
Le type str (chaîne de caractères)

Sous Python, une donnée de type str est une suite quelconque de caractères
délimitée soit par des apostrophes (simple quotes), soit par des guillemets
(double quotes). str est l’abréviation de string, qui veut dire chaîne en
français.

Opérations sur les chaînes de caractères
Pour les chaînes de caractères, deux opérations sont possibles,
l'addition et la multiplication :
• L'opérateur d'addition + concatène (assemble) deux chaînes de caractères.

• L'opérateur de multiplication * entre un nombre entier et une chaîne de caractères
duplique (répète) plusieurs fois une chaîne de caractères.
Attention
Vous observez que les opérateurs + et * se comportent différemment s'il s'agit
d'entiers ou de chaînes de caractères : 2 + 2 est une addition alors que "2" + "2" est
une concaténation. On appelle ce comportement redéfinition des opérateurs.
Opérateurs de chaînes
symbole effet exemple
Concaténation de deux chaînes de

+
caractères
La fonction len() retourne la longueur

len()
(length) de la chaîne de caractères
* Répetition d’une chaîne de caractère
\ Séquence d'échappement
Indique si une sous-chaine de caractères

in
est contenu dans une chaine de caractères
• Extraction de sous-chaînes
• La méthode find(): recherche une chaîne de caractères passée en

argument.
• La méthode split(): découpe la ligne en champs, en utilisant comme
séparateur les espaces ou les tabulations. Il est possible de modifier le
séparateur de champs.
Séparateur « : »
Le type bool (booléen)
Le type bool est utilisé pour les booléens. Un booléen peut prendre les
valeurs True ou False.
Remarque : la fonction not est un opérateur logique qui renvoie l’opposé de

la valeur booléenne transmise. Pour True, on obtient False. Réciproquement,
il renvoie False quand on lui transmet True.
Opérateurs logiques
• Les expressions avec un opérateur logique sont évaluées à True ou
False
• X or Y : OU logique, si X évalué à True, alors l'expression est True et Y n'est
pas évalué. Sinon, l'expression est évaluée à la valeur booléenne de Y.
• X and Y : ET logique, si X est évalué à False, alors l'expression est False et Y

n'est pas évalué. Sinon, l'expression est évaluée à la valeur booléenne de Y.
• not X : évalué à la valeur booléenne opposée de X.
Opérateurs de comparaisons
• Tout comme les opérateurs logiques, les opérateurs de comparaison
renvoient une valeur booléenne True ou False. Les opérateurs de
comparaisons s'appliquent sur tous les types de base.
• < strictement inférieur
• > strictement supérieur
• <= inférieur ou égal
• >= supérieur ou égal
• == égal
• != différent
• X is Y : X et Y représentent le même objet.
• X is not Y : X et Y ne représentent pas le même objet
• Il est possible d'enchaîner les opérateurs : X < Y < Z, dans ce cas, c'est Y
qui est pris en compte pour la comparaison avec Z et non pas
l'évaluation de (X < Y) comme on pourrait s'y attendre dans d'autres
langages.
Conversion de types
• En programmation, on est souvent amené à convertir les types, c'est-à-dire
passer d'un type numérique à une chaîne de caractères ou vice-versa. En
Python, rien de plus simple avec les fonctions int(), float() et str(). Pour vous en
convaincre, regardez ces exemples :
• Conversions sont essentielles dans le cas de l’utilisation de fichiers ou de

l’instruction input(). En effet, lorsqu'on lit ou écrit des nombres dans ces deux
cas, ils sont considérés comme du texte, donc des chaînes de caractères.
• Toute conversion d'une variable d'un type en un autre est appelé casting en
anglais, il se peut que vous croisiez ce terme si vous consultez d'autres
ressources.

Le type complex (complexe)
Python possède par défaut un type pour manipuler les nombres complexes.
La partie imaginaire est indiquée grâce à la lettre « j » ou « J ». La lettre
mathématique utilisée habituellement, le « i », n’est pas utilisée en Python
car la variable i est souvent utilisée dans les boucles.
Exemples :
Ordre d'évaluation des expressions

Opérateur Description
priorité faible
x or y ou logique
x and y et logique
not x Négation logique
<, <=, >, >=, ==, <>, != Opérateurs de comparaison
is, is not Test d’identité
in, not in appartenance à une séquence
x | y ou bits-à-bits
x ^ y ou exclusif bits-à-bits
x & y et bits-à-bits
x << y, x >> y Décalage de x par y bits
x + y, x - y addition ou concaténation / soustraction
x * y multiplication ou répétition
x / y, x // y, x % y Division réelle / Division entière / reste de division
-x négation unaire
priorité forte
Priorité des opérations
• Lorsqu'il y a plus d'un opérateur dans une expression, l'ordre dans lequel les
opérations doivent être effectuées dépend de règles de priorité. Sous Python, les
règles de priorité sont les mêmes que celles qui vous ont été enseignées au cours de
mathématique. Vous pouvez les mémoriser aisément à l'aide d'un « truc »
mémotechnique, l'acronyme PEMDAS :
1. P pour parenthèses. Ce sont elles qui ont la plus haute priorité. Elles vous permettent donc
de « forcer » l'évaluation d'une expression dans l'ordre que vous voulez.
Ainsi 2*(3-1) = 4, et (1+1)**(5-2) = 8.
2. E pour exposants. Les exposants sont évalués ensuite, avant les autres opérations.
Ainsi 2**1+1 = 3 (et non 4), et 3*1**10 = 3 (et non 59049 !).
3. M et D pour multiplication et division, qui ont la même priorité. Elles sont évaluées avant
l'addition A et la soustraction S, lesquelles sont donc effectuées en dernier lieu.
Ainsi 2*3-1 = 5 (plutôt que 4), et 2/3-1 = -1 (Rappelez-vous que par défaut Python effectue
une division entière).
4. Si deux opérateurs ont la même priorité, l'évaluation est effectuée de gauche à droite.
Ainsi dans l'expression 59*100/60, la multiplication est effectuée en premier, et la machine
doit donc ensuite effectuer 5900/60, ce qui donne 98. Si la division était effectuée en
premier, le résultat serait 59(rappelez-vous ici encore qu'il s'agit d'une division entière).
Remarques
• Lors de mélange de types numériques lors d’une opération, la
réponse sera du type de l’opérande la plus complexe.
• En Python, vrai signifie n’importe quel nombre différent de zéro ou

un objet non vide; faux signifie zéro, none et un objet vide (un ex.:
“a or b” retourne le premier qui est vrai et si les 2 sont faux,
retourne celui de droite (donc b)).
Exemples
• Écrire un programme qui affiche "Bonjour le monde"
print ("Bonjour le monde")
• Écrire un programme qui permet de saisir le nom de
l'utilisateur et de renvoyer "Bonjour", suivi de ce nom
name = input("Quel est votre nom?")
print("Bonjour "+(name)+"!")
• Écrire un programme qui demande à l'utilisateur la saisie
de a et b et affiche la somme de a et de b.
var_a = input ("Donnez moi la valeur de a : ")
var_b = input ("Donnez moi la valeur de b : ")
var_c = int(var_a)+int(var_b)
print("Voici le résultat de a + b :"+str(var_c)+"!")
Exemples
• Écrire un programme qui demande à l'utilisateur son année de naissance et qui affiche
son âge. L'année courante sera mise dans une variable.
nom = input ("Quel est votre nom?")
annee= input ("En quelle année êtes vous né ?")
annee_courante=2020
age=annee_courante-int(annee)
print("Bonjour "+(nom)+", vous avez "+str(age)+" ans!")
• Écrire un programme qui demande à l'utilisateur les coordonnées de deux points dans le
plan et qui calcule puis affiche la distance entre ces deux points selon la formule :
import math
xA = float(input("Donnez moi Xa"))
yA = float(input ("Donnez moi Ya"))
xB = float(input("Donnez moi Xb"))
yB = float(input ("Donnez moi Yb"))
distance = math.sqrt (((xB-xA)**2)+((yB-yA)**2))
print(« La distance qui sépare les deux points est de " + str(distance))
Exercices
• Ecrire un programme qui calcule à partir d’un prix hors taxe fournis par l’utilisateur la taxe et le prix TTC
(La valeur de la taxe étant de 20%).
• Écrivez un programme qui convertisse en radians un angle fourni au départ en degrés, minutes,
secondes.
• Écrivez un programme qui convertisse en degrés, minutes, secondes un angle fourni au départ en
radians.
• Écrivez un programme qui convertisse en degrés Celsius une température exprimée au départ en degrés
Fahrenheit, ou l'inverse. La formule de conversion est : TF=TC×1,8+32.
• Écrivez un programme qui calcule les intérêts accumulés chaque année pendant 20 ans, par
capitalisation d'une somme de 1000 dh placée en banque au taux fixe de 4,3%
• Une légende de l'Inde ancienne raconte que le jeu d'échecs a été inventé par un vieux sage, que son roi
voulut remercier en lui affirmant qu'il lui accorderait n'importe quel cadeau en récompense. Levieux
sage demanda qu'on lui fournisse simplement un peu de riz pour ses vieux jours, et plus précisément un
nombre de grains de riz suffisant pour que l'on puisse en déposer 1 seul sur la première case du jeu qu'il
venait d'inventer, deux sur la suivante, quatre sur la troisième, et ainsi de suite jusqu'à la 64ème case.
Écrivez un programme Python qui affiche le nombre de grains à déposer sur chacune des 64 cases du
jeu. Calculez ce nombre de deux manières :
• Le nombre exact de grains (nombre entier)
• Le nombre de grains en notation scientifique (nombre réel)
Exercices
• Écrivez un script qui détermine si une chaîne contient ou non le
caractère «e».
• Écrivez un script qui compte le nombre d'occurrences du caractère
«e» dans une chaîne.
• Écrivez un script qui recopie une chaîne (dans une nouvelle
variable), en insérant des astérisques entre les caractères. Ainsi
par exemple, «python» devra devenir «p*y*t*h*o*n»
• Écrivez un script qui recopie une chaîne (dans une nouvelle
variable) en l'inversant. Ainsi par exemple, «zorglub» deviendra
«bulgroz».
• En partant de l'exercice précédent, écrivez un script qui détermine
si une chaîne de caractères donnée est un palindrome (c'est-à-dire
une chaîne qui peut se lire indifféremment dans les deux
sens),comme par exemple «radar» ou «s.o.s».
Bases de Python
Les instructions simples entrées, sorties et affectation
Les entrées
• Dans un programme, il est très pratique de pouvoir
demander à l’utilisateur de saisir une chaîne de caractères.
• Pour cela, Python dispose d’une instruction : input().
input()
• Cette instruction va renvoyer une chaîne de caractères que

l’on pourra stocker dans une variable.
• Ainsi, si l’utilisateur tape l’entier 25, le résultat initial est ’25’.
• Si on veut convertir la chaîne de caractères en un entier, on
pourra alors utiliser la fonction int().
Thursday, October 15, 2020 Prof. M. LAHLOU 67

Les entrées: des exemples d’utilisation
Les sorties
• L’instruction principale est print qui permet d’afficher
surtout des chaînes de caractères.
• Cependant, comme pour l’instruction input(), si on lui
demande d’afficher un entier, il va automatiquement
convertir l’entier en chaîne de caractères pour pouvoir
l’afficher.
• A noter que l’instruction print provoque un saut de ligne
(comportement par défaut). Pour écrire une suite de
chaînes de caractères, on pourra utiliser la concaténation
de chaînes en utilisant l’opérateur « + ».

Instructions simples : Affectation
simple
• Le symbole d’affectation est le signe "=".
• Lors d’une première affectation, Python crée la variable et lui affecte la valeur spécifiée.
• Lors d’une seconde affectation, Python change le contenu de la variable en lui affectant la nouvelle valeur.
• Voici quelques exemples :
>>> a=5
>>> print(a)
5
>>> b=a
>>> print(b)
5
>>> a="une framboise"
>>> print(a)
une framboise
>>> print(b)
5
>>> a=2.
>>> print(a)
2.0
>>>
• Dans cet exemple, a=5 crée la variable a et lui affecte la valeur 5. Ensuite, b=a crée une variable b et lui
affecte la valeur contenu actuellement dans a, c’est-à-dire 5. La commande a="une framboise" remplace le
contenu de la variable a par cette chaîne de caractères. On peut alors vérifier que la variable b est
inchangée. Enfin, a=2. remplace la chaîne de caractères dans la variable a par le flottant 2.0.
Instructions simples : Affectations

simultanées
• Sous Python, on peut assigner une valeur à plusieurs variables
simultanément.
>>> x = y = 7
>>> x
7
>>> y
7
• La commande x = y = 7 affecte simultanément la valeur 7 à x et à y.
Instructions simples : Affectations
parallèles
• Voici quelques exemples :
>>> a,b=3,4
>>> print a, b
3 4
>>> a,b=b,a
>>> print a,b
4 3
• La commande a,b=3,4 affecte simultanément la valeur 3 à a et la

valeur 4 à b.
• Dans une cas, on pourrait aussi bien remplacer cette instruction
par a=3 et b=4.
• Par contre l’instruction a,b=b,a est plus intéressante car elle permet de
permuter les valeurs de a et b, ce qui ne peut se faire autrement qu’en
utilisant une troisième variable
Bases de Python
Tests (Instructions conditionnelles)
Les tests sont un élément essentiel à tout langage informatique si on
veut lui donner un peu de complexité car ils permettent à l'ordinateur
de prendre des décisions. Pour cela, Python utilise l'instruction if ainsi
qu'une comparaison que nous avons abordée au chapitre précédent.

Règles générales d’écriture
• Les identificateurs
Un identificateur est une suite de caractères servant à désigner les différentes entitées
manipulées par un programme : variables, fonctions, classes…
En Python, un identificateur est formé de lettres ou de chiffres. Il ne contient pas
d’espace. Le premier caractère doit obligatoirement être une lettre. Il peut contenir le
caractère « _ » (underscore, en français « souligné »). Il est sensible à la casse
(distinction entre majuscule et minuscule).
• Les mots-clés
Les mots réservés par le langage Python (if, for, etc.) ne peuvent pas être utilisés
comme identificateurs.
• Les commentaires
Les commentaires usuels:
Les commentaires en fin de ligne:
Bloc d’instructions - Indentation

• L’instruction if est la structure de test la plus simple. Sa syntaxe en Python
fait intervenir la notion de bloc. Nous allons d’abord étudier cette notion
plus en détail.
• Un bloc est défini par une indentation obtenue en décalant le début des
instructions vers la droite grâce à des espaces en début de ligne
(habituellement 4 espaces mais ce n’est pas obligatoire). Toutes les
instructions d’un même bloc doivent être indentées exactement au même
niveau (c’est-à-dire décalées à droite d’un même nombre d’espaces).
• Un bloc peut contenir une ou plusieurs instructions, et notamment des

instructions composées (tests, boucles, etc.).

Quelques bases rapides en Python
(suite)
• Les blocs d’instructions
Un bloc d'instructions est une suite d'instructions qui est alignée sur la même
tabulation. Les blocs d'instructions sont créés par les instructions de contrôles comme
if, while et for, ainsi que par les instructions permettant de déclarer des fonctions.
Sous Python, toutes les instructions composées ont toujours la même structure : une
ligne d'en-tête terminée par un double point, suivie d'une ou de plusieurs instructions
indentées sous cette ligne d'en-tête.
S'il y a plusieurs instructions indentées sous la ligne d'en-tête,

elles doivent l'être exactement au même niveau. Ces instructions
indentées constituent ce que nous appellerons désormais un bloc
d'instructions. Un bloc d'instructions est une suite d'instructions
formant un ensemble logique, qui n'est exécuté que dans certaines
conditions définies dans la ligne d'en-tête.
Instruction if
Syntaxe
condition est une expression booléenne, c’est-à-dire une

expression qui prend pour valeur True (Vrai) ou False (Faux).
L’instruction A n’est exécutée que si la condition est vérifiée
(c’est-à-dire si elle prend pour valeur True).
L’instruction if est une instruction composée. Le : (deux-points) à la fin de la ligne
introduit le bloc d’instructions qui sera exécuté si la condition est vérifiée.
Exemple 1 avec condition vraie : Exemple 1 avec condition fausse :
Affichage après exécution :

Exemple animé d’une structure
conditionnelle
x = int(input("x? "))
y = int(input("y? "))
if(x>=y):
max = x
else:
max = y
print("max = ", max)
mémoire affichage

conditionnelle
if(x>=y): x?
max = x
else:
max = y
mémoire affichage
conditionnelle
if(x>=y): x? 5
max = x y?
else:
max = y
x 5
mémoire affichage

conditionnelle
if(x>=y): x? 5
? max = x y? 19
y 19
else:
? max = y
x 5
mémoire affichage
conditionnelle
max 19 x? 5
if(x>=y):
max = x y? 19
y 19
else:
max = y
x 5
mémoire affichage

conditionnelle
max 19 x? 5
if(x>=y):
max = x y? 19
y 19
else: max = 19
max = y
x 5
mémoire affichage
Instruction if (suite)
Exemple 2 avec condition vraie : Exemple 2 avec condition fausse :
Dans ces exemples, le bloc après le if contient deux instructions. L’instruction

print("Fin") ne fait pas partie du bloc car elle n’est pas indentée.
Instruction if … else
Syntaxe
Exemple avec condition vraie : Exemple avec condition fausse :

Exemple: Equation de second degrés
La structure conditionnelle:
instructions imbriquées
• Pour traiter le cas des notes invalides (<0 ou >20), on peut imbriquer des instructions
conditionnelles :
l'instruction elif
• Une instruction elif (contraction de else if) est toujours associée à une instruction if
• Syntaxe
• Si l'expression 1 est vraie alors le bloc d'instructions 1 est exécuté, et on passe à la suite
du programme.
• Si l'expression 1 est fausse alors on teste l'expression 2 :
• si l'expression 2 est vraie on exécute le bloc d'instructions 2, et on passe à la suite du programme.
• si l'expression 2 est fausse alors on teste l'expression 3, etc...
• Le bloc d'instructions 4 est donc exécuté si toutes les expressions sont fausses (c'est le
bloc "par défaut").
l'instruction elif
• Exemple
Exercice
• a=7
b=12
if a>5:
b=b-4
if b>=10:
b=b+1
Que vaut la valeur finale de la variable b ?
• a=3
b=6
if a>5 or b!=3:
b=4
else:
b=2
Que vaut la valeur finale de la variable b ?
Exercice
• a=10
if a<5:
a=20
elif a<100:
a=500
elif a<1000:
a=1
else:
a=0
Que vaut la valeur finale de la variable a ?
• Le numéro de sécurité sociale est constitué de 13 chiffres auquel s'ajoute la clé de contrôle (2
chiffres).
La clé de contrôle est calculée par la formule : 97 - (numéro de sécurité sociale modulo 97)
Ecrire un script qui contrôle la validité d'un numéro de sécurité sociale.
Exercice
• Un patron décide de calculer le montant de sa participation au prix du
repas de ses employés de la façon suivante :
• S'il est célibataire participation de 20%
• S'il est marié participation de 25%
• S'il a des enfants participation de 10% supplémentaires par enfant
• La participation est plafonnée à 50%
• Si le salaire mensuel est inférieur à 6000dh la participation est majorée de
10%
• Écrire le programme qui lit les informations au clavier et affiche pour un
salarié, la participation à laquelle il a droit.
Bases de Python
Boucles
Les boucles s’utilisent pour répéter plusieurs fois l’exécution d’une partie du
programme. En programmation, on est souvent amené à répéter plusieurs fois une
instruction. Incontournables à tout langage de programmation, les boucles vont
nous aider à réaliser cette tâche de manière compacte et efficace.

Boucles bornées et non bornées
• Boucle bornée
Quand on sait combien de fois doit avoir lieu la répétition, on
utilise généralement une boucle for.
• Boucle non bornée

Si on ne connait pas à l’avance le nombre de répétitions, on
choisit une boucle while.
Boucle for
• L’instruction for est une instruction composée, c’est-à-dire une instruction
dont l’en-tête se termine par deux-points :, suivie d’un bloc indenté qui
constitue le corps de la boucle.
• On dit que l’on réalise une itération de la boucle à chaque fois que le corps
de la boucle est exécuté.
• Dans l’en-tête de la boucle, on précise après le mot-clé for le nom d’une
variable (i dans l’exemple ci-dessus) qui prendra successivement toutes les
valeurs qui sont données après le mot-clé in. On dit souvent que cette
variable (ici i) est un compteur car elle sert à numéroter les itérations de la
boucle.
• Il est possible d’obtenir le même résultat sans donner la liste des valeurs,
mais en utilisant la fonction range().

Boucle for (suite)
• Pour parcourir les indices d’une liste, il est possible de combiner range() et
len() comme ci-dessous :
Rappel : La fonction len() renvoie le nombre d’éléments :
Boucle for (suite)

• Dans l’exemple suivant, nous allons illustrer que la variable indiquée après
for parcourt toutes les valeurs de la liste donnée après in :

Exemple animé de l’instruction for
n = int("Donner la valeur de l'entier n pour lequel vous voulez calculer : 1+2+...+n")

somme = 0
for i in range(1, n+1):
somme = somme + i
print (" La somme des ",n,"premiers entiers = ",somme)
mémoire
affichage

somme = 0
somme = somme + i
n 5 Donner la valeur de l'entier n pour lequel vous voulez calculer : 1+2+...+n 5
mémoire
affichage

somme = 0
somme = somme + i
somme 0
mémoire
affichage

somme = 0
somme = somme + i
i 1
somme 0
mémoire
affichage

somme = 0
somme = somme + i
i 1
somme 1
mémoire
affichage

somme = 0
somme = somme + i
i 2
somme 1
mémoire
affichage

somme = 0
somme = somme + i
i 2
somme 3
mémoire
affichage

somme = 0
somme = somme + i
i 3
somme 3
mémoire
affichage

somme = 0
somme = somme + i
i 3
somme 6
mémoire
affichage

somme = 0
somme = somme + i
i 4
somme 6
mémoire
affichage

somme = 0
somme = somme + i
i 4
somme 10
mémoire
affichage

somme = 0
somme = somme + i
i 5
somme 10
mémoire
affichage

somme = 0
somme = somme + i
i 5
somme 15
mémoire
affichage

somme = 0
somme = somme + i
i 6
somme 15
mémoire
affichage

somme = 0
somme = somme + i
La somme des 5 premiers entiers = 15

i 6
somme 15
mémoire
affichage
Exercices
1. L'utilisateur donne un entier supérieur à 1 et le programme
affiche, s'il y en a, tous ses diviseurs propres sans
répétition ainsi que leur nombre. S'il n'y en a pas, il
indique qu'il est premier. Par exemple :
Entrez un entier strictement positif : 12
Diviseurs propres sans répétition de 12 : 2 3 4 6 (soit 4 diviseurs propres)
Entrez un entier strictement positif : 13
Diviseurs propres sans répétition de 13 : aucun ! Il est premier
2. Écrire un programme qui approxime par défaut la valeur

de la constante mathématique e, pour n assez grand(56),
en utilisant la formule :

Boucle while
Syntaxe
Le mot-clé while signifie tant que en anglais.

Le corps de la boucle (c’est-à-dire le bloc d’instructions
indentées) sera répété tant que la condition est vraie.
Dans l’exemple ci-dessous, x sera multiplié par 2 tant que sa valeur reste
inférieure à 10.
Remarque : Si la condition est fausse au départ, le corps de la boucle n’est jamais
exécuté. Si la condition reste toujours vraie, alors le corps de la boucle est répété
indéfiniment.
Exemple de programme : Affichage après exécution :
Exemple animé de l’instruction while
print("Somme d'entiers positifs")

valeur = int(input ("Donnez une première valeur (ou -1 pour arrêter)"))
somme = 0
mémoire
while (valeur <> -1):
somme = somme + valeur
valeur = int(input ("Valeur suivante (ou -1 pour arrêter)"))
print("La somme des valeurs saisies est : ", somme)
affichage

valeur = int(input("Donnez une première valeur (ou -1 pour arrêter)"))
somme = 0
mémoire
while (valeur <> -1): Somme d'entiers positifs
somme = somme + valeur
affichage
valeur 8
valeur = int(input ("Donnez une première valeur (ou -1 pour arrêter)"))
somme = 0
mémoire
somme = somme + valeur Donnez une première valeur (ou -1 pour arrêter) 8

affichage
valeur 8
somme 0
somme = 0
mémoire

affichage
valeur 8
somme 0
somme = 0
mémoire
? somme = somme + valeur Donnez une première valeur (ou -1 pour arrêter) 8
? print("La somme des valeurs saisies est : ", somme)
affichage
valeur 8
somme 8
somme = 0
mémoire

affichage
valeur 5
somme 8
somme = 0
mémoire
valeur = int(input ("Valeur suivante (ou -1 pour arrêter)")) Valeur suivante(ou -1 pour arrêter) 5
affichage
valeur 5
somme 8
somme = 0
mémoire
? print("La somme des valeurs saisies est : ", somme)
affichage
valeur 5
somme 13
somme = 0
mémoire
affichage
valeur 12
somme 13
somme = 0
mémoire
print("La somme des valeurs saisies est : ", somme) Valeur suivante(ou -1 pour arrêter) 12
affichage
valeur 12
somme 13
somme = 0
mémoire
?
affichage
valeur 12
somme 25
somme = 0
mémoire
affichage
valeur 16
somme 25
somme = 0
mémoire
Valeur suivante(ou -1 pour arrêter) 16
affichage
valeur 16
somme 25
somme = 0
mémoire
?
affichage
valeur 16
somme 41
somme = 0
mémoire
affichage
valeur 7
somme 41
somme = 0
mémoire
affichage
valeur 7
somme 41
somme = 0
mémoire
?
affichage
valeur 7
somme 48
somme = 0
mémoire
affichage
valeur -1
somme 48
somme = 0
mémoire
Valeur suivante(ou -1 pour arrêter) -1
affichage
valeur -1
somme 48
somme = 0
mémoire
?
affichage
valeur -1
somme 48
somme = 0
mémoire
La somme des valeurs saisies est : 48
affichage
Comment choisir entre boucle for et
boucle while
En général, si on connaît avant de démarrer la boucle le nombre d’itérations à
exécuter, on choisit une boucle for. Au contraire, si la décision d’arrêter la
boucle ne peut se faire que par un test, on choisit une boucle while.
Note: Il est toujours possible de remplacer une boucle for par une boucle
while.
Transformation d’une boucle for en un boucle while
Le programme ci-dessus est équivalent à:
L’instruction break dans les boucles

• L’instruction break
L’instruction break permet de « casser » l’exécution d’une boucle (while ou for). Elle
fait sortir de la boucle et passer à l’instruction suivante.
Exemple

L’instruction break dans les boucles
(suite)
• Remarque : équivalent du repeat…until (do…until)
Dans de nombreux langages, il existe une instruction repeat…until qui permet de créer
une boucle pour laquelle on ne connaît pas à l’avance le nombre de répétition, mais
qui doit s’exécuter au moins une fois. Cette instruction n’existe pas en Python, mais on
peut facilement reproduire son fonctionnement de la façon suivante :
L’instruction continue dans les boucles

(suite)
• L’instruction continue: L’instruction continue permet de passer
prématurément au tour de boucle suivant. Elle fait continuer sur la
prochaine itération de la boucle.
Exemple

La clause else dans les boucles
(suite)
La clause else dans un boucle permet de définir un bloc d’instructions qui
sera exécuté à la fin seulement si la boucle s’est déroulée complétement sans
être interrompue par un break.
Contrairement aux instructions présentes après la boucle, qui s’exécutent
dans tous les cas (avec ou sans interruption par un break), le bloc
d’instructions défini dans la clause else ne s’exécutera pas lors de
l’interruption par un break. Après l’interruption, on passera directement aux
instructions après la boucle.
Autrement dit, le bloc de la clause else est exécuté lorsque la boucle se
termine par épuisement de la liste (avec for) ou quand la condition devient
fausse (avec while), mais pas quand la boucle est interrompue par un break.
Ceci est illustré dans la boucle suivante, qui recherche des nombres premiers:
PGCD et Algorithme d'Euclide

Exercices
A. 0/2/4
B. 0/1/2/3/4/5
C. 0/2/4/6
D. 2/4
Par quoi remplacer les ... pour que le programme

affiche successivement les valeurs 0 ; 3 ; 6 ; 9 ; 12 ?
A. n<12
B. n<=12
C. n<14
D. n**2<145
Par quoi remplacer les ... pour que le programme
affiche la plus petite valeur de n telle que n²+3n
dépasse 1000 ?
A. n²+3n<1000
B. n**2+3*n>1000
C. n<1000
D. n**2+3*n<1000
Exercices
1. On dispose d'une feuille de papier d'épaisseur 0,1 mm.
Combien de fois doit-on la plier au minimum pour que
l'épaisseur dépasse la hauteur de la tour Eiffel 324 m.
Écrire un programme en Python pour résoudre ce
problème.
2. Dans un pays connaissant une forte inflation, le taux
d’inflation mensuel est de 8 %. Un article coûte 500
MAD le 1er janvier 2020.
a. Calculer le prix de cet article au 1er février 2020 puis au
1er mars 2020.
b. Écrire un programme qui calcule le nombre de mois au
bout duquel le prix sera supérieur à 1000 euros, en
fonction du prix initial.

Programmation
Prof. M. Lahlou
Bases de Python
Les listes
Les listes (ou list / array ) en python sont une variable dans laquelle on
peut mettre plusieurs variables (équivalent de tableaux dans les autres
langages) .

Le type list (liste)
Sous Python, on peut définir une liste comme une collection d’éléments
séparés par des virgules, l’ensemble étant enfermé dans des crochets. Python
autorise la construction de liste contenant des valeurs de types différents (par
exemple entier et chaîne de caractères), ce qui leur confère une grande
flexibilité. Une liste est déclarée par une série de valeurs (n'oubliez pas les
guillemets, simples ou doubles, s'il s'agit de chaînes de caractères)
Exemple :
Le type list (utilisation)

• Un des gros avantages d'une liste est que vous pouvez appeler ses éléments
par leur position. Ce numéro est appelé indice (ou index) de la liste.
• Soyez très attentifs au fait que les indices d'une liste de n éléments
commence à 0 et se termine à n-1. Voyez l'exemple suivant :
• Par conséquent, si on appelle l'élément d'indice 4 de notre liste, Python

renverra un message d'erreur :

Définition d'une liste
1. Premièrement, nous définissons une liste de 5 éléments. Notez qu'ils

conservent leur ordre d'origine. Ce n'est pas un accident. Une liste est
un ensemble ordonné d'éléments entouré par des crochets.
2. Une liste peut être utilisée comme un tableau dont l'indice de base est
zéro. Le premier élément de toute liste non vide est toujours li[0].
3. Le dernier élément de cette liste de 5 éléments est li[4] car les listes sont
toujours indicées à partir de zéro.
Indices de liste négatifs
1. Un indice négatif permet d'accéder aux éléments à partir de la

fin de la liste en comptant à rebours. Le dernier élément de
toute liste non vide est toujours li[-1].
2. Si vous trouvez que les indices négatifs prêtent à confusion,
voyez-les comme suit : li[n] == li[n + len(li)].
Donc dans cette liste, li[-3] == li[5 - 3] == li[2].

Découpage d'une liste
1. Vous pouvez obtenir un sous-ensemble d'une liste, appelé une «tranche» (slice), en
spécifiant deux indices. La valeur de retour est une nouvelle liste contenant les
éléments de la liste, dans l'ordre, en démarrant du premier indice de la tranche (dans
ce cas li[1]), jusqu'à au second indice de la tranche non inclus (ici li[3]).
2. Le découpage fonctionne si un ou les deux indices sont négatifs. Pour vous aider,
vous pouvez les voir comme ceci : en lisant la liste de gauche à droite, le premier
indice spécifie le premier élément que vous désirez et le second indice spécifie le
premier élément dont vous ne voulez pas. La valeur de retour est tout ce qui se
trouve entre les deux.
3. Les listes sont indicées à partir de zéro, donc li[0:3] retourne les trois premiers
éléments de la liste, en démarrant à li[0] jusqu'à li[3] non inclus.
Raccourci pour le découpage
1. Si l'indice de tranche de gauche est 0, vous pouvez l'omettre et 0 sera implicite. Donc
li[:3] est la même chose que li[0:3] dans le premier exemple.
2. De la même manière, si l'indice de tranche de droite est la longueur de la liste, vous
pouvez l'omettre. Donc li[3:] est pareil que li[3:5], puisque la liste a 5 éléments.
3. Remarquez la symétrie. Dans cette liste de 5 éléments, li[:3] retourne les 3 premiers
éléments et li[3:] retourne les deux derniers. En fait li[:n] retournera toujours les n
premiers éléments et li[n:] le reste, quelle que soit la longueur de la liste.
4. Si les deux indices sont omis, tous les éléments de la liste sont inclus dans la tranche.
Mais ce n'est pas la même chose que la liste li; c'est une nouvelle liste qui contient
les même éléments. li[:] est un raccourci permettant d'effectuer une copie complète
de la liste.
Le type list (opérations)
• Tout comme les chaînes de caractères, les listes supportent l'opérateur + de
concaténation, ainsi que l'opérateur * pour la duplication :
• L'opérateur + est très pratique pour concaténer deux listes.

• Vous pouvez aussi utiliser la méthode .append() lorsque vous souhaitez ajouter un seul
élément à la fin d'une liste.
créer une liste vide ajouter deux éléments, l'un après l'autre, puis avec la méthode .append()
d'abord avec la concaténation
• Dans l'exemple ci-dessus, nous ajoutons des éléments à une liste en utilisant l'opérateur
de concaténation + ou la méthode .append(). Nous vous conseillons dans ce cas précis
d'utiliser la méthode .append() dont la syntaxe est plus élégante.
Le type list (opérations +)

Méthodes associées aux listes Explication Exemple
.insert() La méthode .insert() insère un objet

dans une liste avec un indice déterminé :
del L'instruction del supprime un élément

d'une liste à un indice déterminé :
.remove() La méthode .remove() supprime un

élément d'une liste à partir de sa valeur :
.sort() La méthode .sort() trie une liste :
.reverse() La méthode .reverse() inverse une liste :
.count() La méthode .count() compte le nombre

d'éléments (passés en argument) dans
une liste :

• Test d'appartenance
L'opérateur in teste si un élément fait partie d'une liste.
La variation avec not permet, a contrario, de vérifier qu'un élément n'est pas dans une liste.
• Copie de listes
Il est très important de savoir que l'affectation d'une liste (à partir d'une liste préexistante) crée en
réalité une référence et non une copie :
Vous voyez que la modification de x modifie y aussi !

• Copie de listes
Pour éviter le problème de référenciation des listes, il va falloir créer une copie
explicite de la liste initiale. Observez cet exemple :
L'instruction x[:] a créé une copie « à la volée » de la liste x. Vous pouvez utiliser aussi
la fonction list() qui renvoie explicitement une liste:
Attention, ces deux astuces ne fonctionnent que pour les listes à une dimension,
autrement dit les listes qui ne contiennent pas elles-mêmes d'autres listes.

Filtrage de liste
1. L’expression de mutation est ici très simple (elle retourne juste la valeur de chaque élément),
observez plutôt attentivement l’expression de filtrage. Au fur et à mesure que Python parcours
la liste, il soumet chaque élément à l’expression de filtrage, si l’expression s’évalue à vrai,
l’élément passe par l’expression de mutation et le résultat est inclue dans la liste de résultat. Ici,
on filtre toutes les chaînes d’un seul caractère, il ne reste donc que les chaînes plus longues.
2. Ici, on filtre une valeur spécifique : b. Notez que cela filtre toutes les occurrences de b, puisqu’à
chaque fois qu’il apparaît, l’expression de filtrage s’évaluera à faux.
3. count est une méthode de listes qui retourne le nombre d’occurrences d’une valeur dans la
liste. On pourrait penser que ce filtre élimine les doublons de la liste, retournant une liste
contenant seulement un exemplaire de chaque valeur. Mais en fait, les valeurs qui apparaissent
deux fois dans la liste initiale (ici b et d) sont totalement éliminées. Il y a des moyens de
supprimer les doublons d’une liste mais le filtrage n’est pas la solution.
Filtrage de liste (exemple)

• Prenons un exemple simple. On veut obtenir une liste où les éléments sont les mêmes
qu’une autre liste, mais incrémentés. On peut alors naturellement déclarer une liste puis
la parcourir pour y traiter chaque élément :
• La méthode ci-dessus est simple et intuitive mais nous pouvons écrire ce bout de code
de manière plus succincte en Python grâce aux List Comprehension :
• Grâce à cette même expression, il nous est aussi possible de filtrer les éléments insérés
en plus d’effectuer un traitement sur ces mêmes éléments :
Tuesday, October 27, 2020 Prof. M. LAHLOU 156

Mélanger aléatoirement les éléments
d'une liste sous python
• Le programme suivant crée une liste de valeurs ordonnées
comprise entre 1 et 20, procède ensuite à un mélange aléatoire
des mêmes valeurs au sein de la même liste et à la fin prélève un
échantillon aléatoire de cinq éléments sans remise:
• Ce qui provoquera l’affichage suivant:
Des chaînes aux listes

• Pour « convertir » une chaîne en liste, on va utiliser une méthode de chaîne
nommée split (« éclater » en anglais). Cette méthode prend un paramètre
qui est une autre chaîne, souvent d'un seul caractère, définissant comment
on va découper notre chaîne initiale.
Séparateur « : »

Des listes aux chaînes
• Voyons l'inverse à présent, c'est-à-dire si on a une liste contenant plusieurs
chaînes de caractères que l'on souhaite fusionner en une seule. On utilise la
méthode de chaîne join (« joindre » en anglais). Sa syntaxe est un peu
surprenante :
La notion de séquences
• Un objet itérable est une séquence de données auxquelles il
est possible d'accéder à l'aide d'un indice. Voyons ça avec
l'aide d'un petit schéma d'une séquence de N éléments :
• Une séquence est une suite de données placées en mémoire

dans un ordre bien précis. Dans le schéma ci-dessus, on peut
voir l'indice associé à chaque donnée dans la séquence.
• Les indices commencent à 0 ! Ainsi, les indices d'une
séquence de longueur N iront de 0 à N-1 !

Les séquences: la fonction range()
• La fonction range() permet de créer une liste correspondant à une
suite de nombres, en voici quelque exemples.
Exercice
uneVal = input("Entrer un nombre STOP pour finir. ")
while uneVal <> "STOP":
if(int(uneVal) >= 10) and (int(uneVal) < 100):
print( uneVal, "est un nombre à deux chiffres.")
uneVal = input("Entrer un autre nombre STOP pour finir. ")
print("fin de l’algorithme")
a) Ce programme attend des données de la part de son utilisateur. Quels

affichages obtenez vous si vous lui fournissez les données suivantes : 23
142 STOP.
b) Commentez cet algorithme afin d’identifier clairement les différentes
parties du traitement itératif effectué par la boucle tant que.
c) Pourquoi la boucle while est-elle préférable ici à la boucle Répéter et à la
boucle for?

Exemple d’application
• On considère deux séquences d'entiers positifs. Ecrire un programme qui:
1. Lit la première série au clavier et la stocker dans une première liste
2. Lit la deuxième série au clavier et la stocker dans une seconde liste
3. Affiche les nombres communs aux deux séquences.
Exemple : séquence 1 :1 3 4 11 25 28 30
séquence 2 :1 2 3 5 11 24 25 29 30 34 39
résultat affiché : 1, 3, 11, 25, 30.
Exercice
Soit T un tableau qui contient n valeurs réelles non triés. Ecrire un
programme qui
1. lit le contenu de ce tableau,
2. le met dans une liste
3. le trie
4. lit aussi un nombre réel x,
5. et effectue l’insertion de x dans la liste, de telle manière que la
liste reste triée.
Exemple : Soit le tableau T de 8 nombres triés dans lequel on désire
insérer le nombre 40

Exercice
• Ecrire un programme pour construire et alimenter une matrice carrée
d'ordre n,
• vérifier si cette matrice représente un carré magique (On a la même somme
pour chaque ligne, colonne ou diagonale).
Éléments d'un programme

Les fonctions

Sous-programme : notion
Appel du sous-
programme monSousProg
Programme
appelant
Retour
Retour du sous-programme
Sous-programme : rôles et intérêts
• En informatique, la programmation modulaire reprend l'idée de fabriquer un

produit (le programme) à partir de composants (les modules).
• Elle décompose une grosse application en modules, groupes de fonctions, pour
pouvoir les développer et les améliorer indépendamment, puis les réutiliser dans
d'autres applications.
• Le développement du code des modules peut être attribué à des (groupes de)
personnes différentes, qui effectuent leurs tests unitaires indépendamment.
• Ce style de programmation facilite grandement l'amélioration progressive, la ré-
utilisabilité et le partage du code, et est particulièrement utile pour la réalisation
de bibliothèques.
Ainsi l’objectif principale est de : Découper un programme en

petites entités qui sont:
• Indépendantes ;
• Réutilisables ;
• Plus lisibles.

La syntaxe
• Vous pouvez choisir n'importe quel nom pour la fonction que vous créez, à l'exception des mots
réservés du langage, et à la condition de n'utiliser aucun caractère spécial ou accentué (le caractère
souligné « _ » est permis). Comme c'est le cas pour les noms de variables.
• Comme les instructions if et while que vous connaissez déjà, l'instruction def est une instruction
composée. La ligne contenant cette instruction se termine obligatoirement par un double point,
lequel introduit un bloc d'instructions que vous ne devez pas oublier d'indenter.
• La liste de paramètres spécifie quelles informations il faudra fournir en guise d'arguments lorsque
l'on voudra utiliser cette fonction (Les parenthèses peuvent parfaitement rester vides si la fonction
ne nécessite pas d'arguments).
• Une fonction s'utilise pratiquement comme une instruction quelconque. Dans le corps d'un
programme, un appel de fonction est constitué du nom de la fonction suivi de parenthèses. Si c'est
nécessaire, on place dans ces parenthèses le ou les arguments que l'on souhaite transmettre à la
fonction. Il faudra en principe fournir un argument pour chacun des paramètres spécifiés dans la
définition de la fonction, encore qu'il soit possible de définir pour ces paramètres des valeurs par
défaut (voir plus loin).
Fonction simple sans paramètres
• En entrant ces quelques lignes, nous avons défini une fonction très simple qui
calcule et affiche les 10 premiers termes de la table de multiplication par 7.
Notez bien les parenthèses, le double point, et l'indentation du bloc
d'instructions qui suit la ligne d'en-tête (c'est ce bloc d'instructions qui
constitue le corps de la fonction proprement dite).
• Pour utiliser la fonction que nous venons de définir, il suffit de l'appeler par son
nom. Ainsi :
• provoque l'affichage de :

Fonction avec paramètre
• Dans nos derniers exemples, nous avons défini et utilisé une fonction qui affiche
les termes de la table par 7. Supposons à présent que nous voulions faire de
même avec la table par 9. Nous pouvons bien entendu réécrire entièrement
une nouvelle fonction pour cela. Mais si nous nous intéressons plus tard à la
table par 13, il nous faudra encore recommencer. Ne serait-il donc pas plus
intéressant de définir une fonction qui soit capable d'afficher n'importe quelle
table, à la demande ?
• Lorsque nous appellerons cette fonction, nous devrons bien évidemment
pouvoir lui indiquer quelle table nous souhaitons afficher. Cette information que
nous voulons transmettre à la fonction au moment même où nous l'appelons
s'appelle un argument. Nous avons déjà rencontré à plusieurs reprises des
fonctions intégrées qui utilisent des arguments. La fonction sin(a), par exemple,
calcule le sinus de l'angle a. La fonction sin() utilise donc la valeur numérique de
a comme argument pour effectuer son travail. Dans la définition d'une telle
fonction, il faut prévoir une variable particulière pour recevoir l'argument
transmis. Cette variable particulière s'appelle un paramètre. On lui choisit un
nom en respectant les mêmes règles de syntaxe que d'habitude (pas de lettres
accentuées, etc.), et on place ce nom entre les parenthèses qui accompagnent
la définition de la fonction.
Fonction avec paramètre
• La fonction table() telle que définie ci-dessus utilise le paramètre base pour calculer les dix
premiers termes de la table de multiplication correspondante.
• Pour tester cette nouvelle fonction, il nous suffit de l'appeler avec un argument. Exemples :
• Dans ces exemples, la valeur que nous indiquons entre parenthèses lors de l'appel de la
fonction (et qui est donc un argument) est automatiquement affectée au paramètre base. Dans
le corps de la fonction, base joue le même rôle que n'importe quelle autre variable. Lorsque
nous entrons la commande table(9), nous signifions à la machine que nous voulons exécuter la
fonction table() en affectant la valeur 9 à la variable base.

Utilisation d'une variable comme
argument
• Dans les 2 exemples qui précèdent, l'argument que nous avons
utilisé en appelant la fonction table() était à chaque fois une
constante (la valeur 13, puis la valeur 9). Cela n'est nullement
obligatoire. L'argument que nous utilisons dans l'appel d'une
fonction peut être une variable lui aussi, comme dans l'exemple ci-
dessous.
• provoque l'affichage de :
Fonction avec plusieurs paramètres

• La fonction table() est certainement intéressante, mais elle n'affiche toujours
que les dix premiers termes de la table de multiplication, alors que nous
pourrions souhaiter qu'elle en affiche d'autres. Qu'à cela ne tienne. Nous allons
l'améliorer en lui ajoutant des paramètres supplémentaires, dans une nouvelle
version que nous appellerons cette fois tableMulti() :
• Cette nouvelle fonction utilise donc trois paramètres : la base de la table

comme dans l'exemple précédent, l'indice du premier terme à afficher, l'indice
du dernier terme à afficher. Essayons cette fonction en entrant par exemple :
tableMulti(8, 13, 17)
• ce qui devrait provoquer l'affichage de :

Valeurs par défaut pour les
paramètres
• Dans la définition d'une fonction, il est possible (et souvent souhaitable) de définir
un argument par défaut pour chacun des paramètres. On obtient ainsi une fonction
qui peut être appelée avec une partie seulement des arguments attendus. Exemples :
tableMulti(8) tableMulti(8,5) tableMulti(8,fin=5)
1x8=8 5 x 8 = 40 1x8=8
2 x 8 = 16 6 x 8 = 48 2 x 8 = 16
3 x 8 = 24 7 x 8 = 56 3 x 8 = 24
4 x 8 = 32 8 x 8 = 64 4 x 8 = 32
5 x 8 = 40 9 x 8 = 72 5 x 8 = 40
6 x 8 = 48 10 x 8 = 80
7 x 8 = 56
8 x 8 = 64
9 x 8 = 72
10 x 8 = 80
Fonction retournant des résultats

• Pour les puristes, les fonctions que nous avons décrites jusqu'à présent ne sont
pas tout à fait des fonctions au sens strict, mais plus exactement des
procédures[5]. Une « vraie » fonction (au sens strict) doit en effet renvoyer (ou
« retourner ») une valeur lorsqu'elle se termine. Une « vraie » fonction peut
s'utiliser à la droite du signe égale dans des expressions telles que y = sin(a). On
comprend aisément que dans cette expression, la fonction sin() renvoie une
valeur (le sinus de l'argument a) qui est directement affectée à la variable y.
• Commençons par un exemple extrêmement simple :

729

Fonction retournant une liste
• À titre d'exemple un peu plus élaboré, nous allons maintenant
modifier quelque peu la fonction table() sur laquelle nous avons
déjà pas mal travaillé, afin qu'elle renvoie elle aussi une valeur.
Cette valeur sera en l'occurrence une liste (la liste des dix premiers
termes de la table de multiplication choisie). Voilà donc une
occasion de reparler des listes. Nous en profiterons pour
apprendre dans la foulée encore un nouveau concept :
Fonction retournant plusieurs résultats

• À titre d'exemple un peu plus élaboré, nous allons maintenant
écrire une fonction qui calcule en même temps les trois
paramètres d’inférence statistiques (la moyenne, la variance et
l’écart-type):

Récursion
Une procédure récursive est une procédure qui s'appelle elle-
même.
• fact(4) = 4 × 3 × 2 × 1
• fact(N) = N × fact(N -1) la fonction fait appel à
elle-même (pour N > 0)
• fact(0) = 1 condition d'arrêt
Variables locales et variables globales

• Lorsqu'on manipule des fonctions, il est essentiel de bien comprendre
comment se comportent les variables. Une variable est
dite locale lorsqu'elle est créée dans une fonction. Elle n'existera et
ne sera visible que lors de l'exécution de ladite fonction.
• Une variable est dite globale lorsqu'elle est créée dans le programme
principal. Elle sera visible partout dans le programme.
• Ceci ne vous paraît pas clair ? Nous allons prendre un exemple
simple qui vous aidera à mieux saisir ces concepts. Observez le code
suivant :

Exécution étape par étape




A. 6.0
B. 8.0
C. 10.0
D. 12.0

• A) 5.0
• B) 1.0
• C) -1.0
• D) -5.0
A. 4
2
3
5
6
B. 4
2
3
5
puis message d'erreur
C. 4
2
D. 4

Exercices
• Définissez une fonction surfCercle(R). Cette fonction doit
renvoyer la surface (l'aire) d'un cercle dont on lui a fourni le
rayon R en argument. Par exemple, l'exécution de
l'instruction:
print(surfCercle(2.5)) doit donner le résultat 19.635
• Définissez une fonction volBoite(x1,x2,x3) qui renvoie le
volume d'une boîte parallélipipédique dont on fournit les
trois dimensions x1, x2, x3 en arguments. Par exemple,
l'exécution de l'instruction :
print(volBoite(5.2, 7.7, 3.3)) doit donner le résultat 132.13
• Définissez une fonction maximum(n1,n2,n3) qui renvoie le
plus grand de 3 nombres n1, n2, n3 fournis en arguments. Par
exemple, l'exécution de l'instruction :
print(maximum(2,5,4)) doit donner le résultat 5
Éléments d'un programme

Les fichiers

Lire et écrire un fichier texte
• Jusqu'à présent, les programmes que nous avons réalisés ne
traitaient qu'un très petit nombre de données. Nous
pouvions donc à chaque fois inclure ces données dans le
corps du programme lui-même (par exemple dans une liste).
Cette façon de procéder devient cependant tout à fait
inadéquate lorsque l'on souhaite traiter une quantité
d'information plus importante.
• Pour garder des résultats donnés par un programme, pour
coder des documents importants, il est indispensable de
savoir manipuler des fichiers avec PYTHON.
• Dans un premier temps, nous allons manipuler des fichiers ne
contenant que du texte (chaînes de caractères).
Les entrées/sorties Fichier
Écriture de données
Programme
Stockage
Lecture de données
Fichier
Disque

Créer un fichier texte et écrire
dedans
• L'instruction basique qui crée un fichier dans le même
répertoire que celui qui contient le programme est:
fichier=open("nom",'w')
• Où:
• fichier est le nom de votre fichier dans le programme python
• "nom" est le nom de votre fichier de sortie
• w signifie "write", on ouvre le fichier pour écrire dedans.
• Attention, si un fichier du même nom existe déjà dans le
répertoire il sera écrasé sans aucune alerte!!!!!!
• Pour écrire les infos dans le fichier, c'est simple:
fichier.write("info")
• Et on finit toujours (que ce soit en lecture ou écriture)
par:
fichier.close()
Exemple
•Dans cet exemple nous allons créer un fichier et
stocké dedans les 10 premier termes de la suite
de Fibonacci
•Ce qui devra donner le fichier suivant
•On remarquera que les valeurs de la série ont été

bien inscrites mais collées les uns au autres.
Exemple
• Pour remédier au problème de l’exemple précédant, il
faut ajouter après chaque nombre le "caractère" qui
produit un passage à la ligne: "\n"
• Ce qui devra donner le fichier suivant
Ouvrir un fichier texte et lire son

contenu
• L'instruction basique qui ouvre un fichier est:
fichier=open("nom",'r')
• Où fichier est le nom de votre fichier dans le programme python , "nom" est le nom de
votre fichier de sortie et « r » signifie "read", on ouvre le fichier en mode lecture.
• Pour lire dans un fichier, Python offre plusieurs possibilités:
• La méthode readlines qui lit toutes les lignes du fichier et les range dans une
séquence. Utile si on souhaite lire tout le fichier d'un coup:
toutesleslignes = fichier.readlines()
• La méthode readline (au singulier) qui lit une ligne dans le fichier. Indispensable pour
lire des lignes au coup par coup:
lalignesuivante = fichier.readline()
• Enfin, on peut aussi utiliser l'objet fichier comme un itérateur. Pratique si on souhaite
traiter l'une après l'autre toutes les lignes d'un fichier.
for ligne in fichier:
# ...
• C'est la troisième solution que nous allons utiliser: en effet, inutile de lire tout le
fichier d'un coup (il peut être excessivement volumineux – et de toute manière
nous pouvons traiter nos données ligne par ligne).

Exemple
• Dans cet exemple nous allons ouvrir le fichier
« fibonacci.txt » créé précédemment et lire et afficher son
contenu.
• Ce qui devrait provoquer l'affichage de :
• La méthode rstrip('\n') appliqué à la variable texte « line »

permet d’enlever le caractère de retour de ligne '\n'.
Exemple 2
« temperature.txt » est un fichier contenant une série de
mesures de températures à différents points (voir extrait ci-
joint). Le fichier se compose d’une ligne de titre suivit des
lignes de données composées du numéro du point de mesure
suivit d’un espace suivit de la mesure de la température.
Ecrire un programme pour calculer la moyenne des
températures

Programmation
Prof. M. Lahlou
Calculs scientifiques
Analyse numérique

Résolution numérique d'une équation
Pour résoudre l'équation f(x)=0, on cherche

un intervalle sur lequel on est certain que f
s'annule. C'est le cas pour [a;b] parce que
f(b) est négatif et f(a) est positif. La
méthode de dichotomie vise à resserrer un
tel intervalle. On constate dans l’exemple
suivant que la fonction f est traitée comme
une entrée de l'algorithme au même titre
que les bornes a et b de l'intervalle:
Exemple
• La résolution de l'équation x²-5=0 n'est pas terminée, puisque le script ci-dessus

n'a donné qu'une seule des deux solutions de cette équation. Par ailleurs, la
solution trouvée n'est affichée qu'à 10-14 près. L’exécution de ce programme
provoquera l’affichage suivant:

Calcul numérique de nombre dérivé
•Pour calculer le nombre dérivé d’une fonction
« f » en un point « x », on va utiliser
l'approximation:
•L’exécution de ce programme provoquera

l’affichage suivant:
10.00000082740371
Calcul numérique d'une intégrale
• La méthode des rectangles dit que

où et N est suffisamment grand pour que h soit petit (ci-
dessous N=1 000 000):
•L’exécution de ce programme provoquera

l’affichage suivant:
-7.333337333332162

Paramètres statistiques de base (1)
• Soit une liste de valeur tel que:
>>> test = [ 3, 5, 7, 9, 11, 13]
• La somme de cette liste est donnée par l’expression
suivante:
>>> sum(test)
48
• Pour calculer la moyenne des nombres qui sont dans
test, on les additionne et on divise la somme par le
nombre de nombres qu'il y a dans test:
>>> def moyenne(tableau):
return sum(tableau) / len(tableau)
>>> print(moyenne(test))
8.0
Paramètres statistiques de base (2)

• La variance est définie comme la moyenne des carrés des écarts à
la moyenne
>>> def variance(tableau):
m=moyenne(tableau)
return moyenne([(x-m)**2 for x in tableau])
>>> print(variance(test))
11.666666666666666
• L'écart-type est défini comme la racine carrée de la variance
>>> def ecartype(tableau):
return variance(tableau)**0.5
>>> print(ecartype(test))
3.415650255319866

Génération de nombres aléatoires
Pour créer un échantillon de 100 nombres aléatoires

entiers compris entre 1 et 100
La fonction randint(1,100) génère un nombre aléatoire
entier entre 1 et 100
50.3665
28.56636794816643
• Pour créer un échantillon de 100 nombres aléatoires réelles

compris entre 0.0 et 100.0
La fonction random() génère un nombre aléatoire réel compris
entre 0 et 1
49.745912210247546
28.997495489810333

Pour créer un échantillon de 100 nombres gaussiens

d'espérance 16 et d'écart-type 2 on utilise la fonction
gauss(moyenne, écart-type):
15.993753359028622
1.9889518438838354
Génération de plusieurs distributions

Estimation graphique de la valeur de pi
3.14044 3.141592653589793
Fonctions mathématiques de base

La bibliothèque math
• Pour disposer des fonctions mathématiques usuelles, la librairie d’origine du

python se nomme math. On peut alors importer juste les fonctions nécessaires
par:
from math import cos, log
ou toutes les fonctions mathématiques par:
from math import *
Dans ce cas on utilisera les fonctions de ma manière suivante:
>>> cos(3)
-0.9899924966004454
ou
import math
Dans ce cas on utilisera les fonctions de ma manière suivante:
>>> math.cos(3)
-0.9899924966004454
La bibliothèque math
import math
• Une fois un module importé on peut lister les fonctions
disponibles avec la fonction dir:
print(dir(math))
['__doc__', '__loader__', '__name__', '__package__', 'acos', 'acosh',
'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos',
'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial',
'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isfinite', 'isinf',
'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'pi',
'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
• Pour accéder à l'aide on utilise la fonction help:

help(math.log): pour obtenir de l’aide sur la fonction log de la
bibliothèque math
help(math): pour obtenir de l’aide sur toutes les fonctions de la
bibliothèque math

Quelque fonctions de la bibliothèque
« math »
fonction effet exemple Résultat
n = -100.5 100.5
Abs Valeur absolue
print(abs(n))
n = 100.7
100
Floor, ceil Partie entière print(math.floor(n))
101
print(math.ceil(n))
number = 1.23456 1 0 digits
print(round(number)) 1.0 0 digits
print(round(number, 0)) 1.2 1 digit
Round Arrondi
print(round(number, 1)) 1.23 2 digits
print(round(number, 2)) 1.235 3 digits, last one rounded
print(round(number, 3)) up to 5
values = [0.9999999, 1, 2, 3]
r = sum(values)
Sum, fsum 6.999999900000001
print(r)
6.9999999
r = math.fsum(values)
print(r)
Quelque fonctions de la bibliothèque

« math »
symbole effet exemple Résultat
a = math.pow(2, 3)
b = 2 ** 3 8.0
Pow puissance
print(a) 8
print(b)
value1 = 9
value2 = 16
3.0
value3 = 100
Sqrt Racine carrée 4.0
print(math.sqrt(value1))
10.0
Constantes print(math.e) 2.718281828459045
Pi, E
mathématiques print(math.pi) 3.141592653589793

Calcul vectoriel
La bibliothèque numpy: calcul vectoriel

en Python
• NumPy est une extension du langage de programmation
Python, destinée à manipuler des matrices ou tableaux
multidimensionnels ainsi que des fonctions
mathématiques opérant sur ces tableaux.
• Les tableaux dans l’extension numpy sont considérés
comme une collection indexable et contigüe d’éléments
de même type.
• La bibliothèque numpy contient des fonctions de
manipulation des tableaux pour le calcul numérique ainsi
qu’un bibliothèque mathématique importante.

La bibliothèque numpy: création d’un
tableau
Tableau de taille fixée, multidimensionnel contenant des éléments de même

type et de même taille. Ce tableau peut être définit par:
>>> import numpy as np
son contenu sous forme d’une liste de valeurs :
>>> a=np.array([1,3,5,7,9,11,13,17])
ses dimensions et son profil :
>>> b=np.array([[1,2,3],[4,5,6]])
son type d’élément :
>>> a=np.array([0.1, 0.0, 0.2],dtype=np.float)
>>> b=np.array([[1,2,3],[4,5,6]],dtype=np.int)
La bibliothèque numpy:
• Nous allons voir comment créer des tableaux avec la
fonction numpy.array() de NumPy. Ces tableaux
pourront être utilisés comme des vecteurs ou des
matrices grâce à des fonctions de NumPy (numpy.dot(),
numpy.linalg.det(), numpy.linalg.inv(), numpy.linalg.eig(),
etc.) qui permettent de réaliser des calculs matriciels
utilisés en algèbre.
• Premièrement, nous allons importer le module numpy.
Pour cela, il suffit de faire :

La bibliothèque numpy: Tableaux -
numpy.array()
• Pour créer des tableaux, nous allons utiliser numpy.array().
Tableaux monodimensionnels (1D)
• Pour créer un tableau 1D, il suffit de passer une liste de nombres
en argument de numpy.array(). Un liste est constituée de nombres
séparés par des virgules et entourés de crochets ([ et ]).
• Pour connaître le type du résultat de numpy.array(), on peut

utiliser la fonction type().
• On constate que ce type est issu du package numpy. Ce type est

différent de celui d’une liste.
La bibliothèque numpy: Tableaux

bidimensionnels (2D)
• Pour créer un tableau 2D, il faut transmettre à
numpy.array() une liste de listes grâce à des crochets
imbriqués.

La bibliothèque numpy: Tableaux
• La fonction numpy.size() renvoie le nombre d’éléments
du tableau.
• La fonction numpy.shape() (forme, en anglais) renvoie la

taille du tableau.
La bibliothèque numpy: Produit terme

à terme et Produit matriciel
• Il est possible de réaliser un
produit terme à terme grâce à
l’opérateur *.
Il faut dans ce cas que les deux
tableaux aient la même taille.
• Un tableau peut jouer le rôle

d’une matrice si on lui applique
une opération de calcul matriciel.
Par exemple, la fonction
numpy.dot() permet de réaliser
le produit matriciel.

La bibliothèque numpy: Autre
• Transposé:
• Lors de la manipulation des tableaux, on a souvent

besoin de récupérer une partie d’un tableau. Pour cela,
Python permet d’extraire des tranches d’un tableau
grâce une technique appelée slicing (tranchage, en
français). Elle consiste à indiquer entre crochets des
indices pour définir le début et la fin de la tranche et à
les séparer par deux-points : (comme pour le listes de
python).
La bibliothèque numpy: Autre

La bibliothèque numpy: Changement de
la taille d’un tableau
• Il est possible de changer
la taille d’un tableau en
utilisant l’attribut shape
de ce tableau.
• Obtention d’un tableau

2D ligne ou colonne
La bibliothèque numpy: Algèbre

linéaire

La bibliothèque numpy: Algèbre
linéaire
Opérations classiques sur la matrices

Opérations avancées sur la matrices
Exemple complet: création d’un

tableau 1D et un tableau 2D

Exemple: Opérations statistiques
Exercice
1. A l’aide de numpy résoudre les systèmes d’équations linaires suivants
d’inconnues x , y , z :
2. Déterminer tous les polynômes de degré au plus 2 prenant pour valeur
1, 4 et 3 respectivement en 0, 1 et 2.

Tracé graphique
La bibliothèque Matplotlib
•Une des grandes activités des scientifiques qui
touchent à la modélisation numérique c'est de
faire des courbes.
•Le module Matplotlib, comme son nom l’indique,
s’occupe du tracé graphique. Nous avons déjà vu
un exemple d’utilisation de ce module dans la
partie « Statistique inférentielle »

Ma première courbe: f(x)=x
Personnalisation des courbes
• Intéressons-nous 2 minutes aux options que je peux

passer à plt.plot() :
plot(abscisse, ordonnée, 'couleur forme_point forme_trait',
paramètres)
• Couleur : entre quote on met la première lettre anglaise de
la couleur : rouge : 'r', bleu : 'b', vert : 'g', jaune : 'y', noir : 'k'
• forme_point : l'allure des points : 'x' : croix, 's' : carré, 'd' :
losange, 'o' : rond ;
• forme_trait : l'allure des traits : '.' pointillé, '-' : ligne
continue, '..' : pointillé, '-.' : point tiret, '--' : ligne de tiret ;
• paramètres : différentes options comme l'épaisseur du trait :
linewidth= 1-5.

Deux courbes dans la même figure
Deux figures avec le même plot

Tracé de fonctions
Un histogramme et un affichage de
texte sur le graphique

Programmation
Prof. M. Lahlou
Bases de Python
Interfaces graphiques en Python avec Qt 5 et PyQt5:
Introduction

Programmation traditionnel
(Pascal, C, Basic, Python, etc.)
Dans les applications traditionnelles
• C'est l'application elle même, et non un événement, qui contrôle les parties
du code qui sont exécutées, ainsi que leur ordre d'exécution.
• Celle-ci commence à la première ligne de code et suit un chemin défini dans

l'application, appelant les procédures au fur et à mesure des besoins.
5 novembre 2020 Programmation structurée 250
Logiciel événementiel (event-driven program)
Dans une application événementielle:

• Le code ne suit pas un chemin prédéterminé.
• Différentes sections du code sont exécutées en réaction aux
événements:
• Ceux-ci peuvent être déclenchés par des actions de l'utilisateur,
• Par des messages provenant du système ou
• D'autres applications, voire même par l'application proprement dite.
• L'ordre de ces événements détermine l'ordre d'exécution du
code.
• Le chemin parcouru dans le code de l'application est donc
différent à chaque exécution du programme.
5 novembre 2020 Programmation structurée 251

Programmation événementielle
252
Programmation événementielle: principe

 Événement: en réalité un message qui provient:
 D’une action de l’utilisateur sur l’interface
 Cliquer bouton souris
 Bouger le curseur de la souris
 Enfoncer une touche du clavier …
 D’une action intrinsèque du système
 Premier chargement d’une fenêtre
 Déclenchement d’évènements cycliques (Timer)
 Destruction d’une fenêtre …
5 novembre 2020 Programmation structurée
253
 Chaque événement est:

 capté par le système
 mis dans une file d’attente (empilé sur une pile)
 La boucle de gestion des événements traite
séquentiellement chaque événement de la pile selon le
principe FIFO (First In First Out)
 Pour chaque événement:
 Analyse de l’objet qui a généré l’événement
 Recherche du sous-programme associé à cet événement
dans le cadre de l’objet en cause
 Exécution de ce sous-programme s’il existe
Interface Graphique
Action sur objet de

l'interface graphique
Création d'un
événement
Evénement sur
un objet de
l'interface
Périphériques Place
agissant sur l'événement sur
l'interface la pile
noyau
de
Pile d'événements WINDOWS
ensemble de
sous-programmes
Cho
ix du s
ous
-pro
Un sous-programme g ram
me Dépile l'événement
pour chaque événement adé
qua
de chaque objet . t le plus ancien
.
.
Analyse de l'évenement dépilé
255
 C'est le programmeur qui doit prévoir la procédure à

exécuter en réponse à un événement donné
 Après analyse et élaboration d'un cahier des charges, le

rôle du programmeur est:
 de concevoir l'interface
 prévoir les évènements à programmer
 d’écrire le code des procédures événement liées
aux différents composants de cette interface.

Création d’une première fenêtre
Pour créer une première fenêtre, on va utiliser la classe QWidget.
Voici un programme très simple de création d’une fenêtre graphique.
Exemple
Thursday, November 5, 2020 Prof. M. LAHLOU 256
Analyse du programme
• from PyQt5.QtWidgets import QApplication, Qwidget
Il importe le module QtWidgets pour que nous ayons accès à l’interface graphique.
• app = QApplication(sys.argv)
Il crée un objet d’application qui a accès à la boucle d’événements.
• fen = QWidget()
Nous devons ensuite créer un QtWidget, parce que nous allons utiliser cela comme
notre fenêtre de haut niveau et il a tout ce que nous voulons.
• fen.setWindowTitle('Basic Window Example')
setWindowTitle donne un titre à la fenêtre et elle peut être appelée quand vous en
avez besoin.
• fen.show()
Il est nécessaire pour montrer la fenêtre.
• app.exec_()
Nous avons besoin de démarrer cette boucle d’événement en utilisant la fonction.
Si nous ne le faisons pas, le programme va s’exécuter directement parce qu’il ne va pas
continuer à tourner sur lui-même et cette boucle d’événement ici attend des
événements de notre part pour s’exécuter là.

Position et taille de la fenêtre
• La méthode setGeometry() prend 4 entiers comme argument d’entrée qui sont
• Coordonnée X
• Coordonnée Y
• Largeur du cadre
• Hauteur du cadre
• Par conséquent dans l’exemple ci dessous,
la position de départ de la fenêtre est 300 x 50 et sa taille de 500 x 250 pixels.
Création de deux fenêtres

Création d’une fenêtre personnalisée
Si nous voulons à présent que notre fenêtre dispose d’autres fonctionnalités
que celles qui existent dans la classe QWidget, il nous faut créer une classe
dérivée pour laquelle nous pourrons ajouter des attributs et des méthodes
supplémentaires.
Exemple
Gestion des événements de la souris dans la

fenêtre
Pour interagir avec l’utilisateur, nous allons devoir effectuer de la programmation
événementielle. Il va ainsi s’agir de gérer les événements qui seront déclenchés par
l’utilisateur (appui sur la souris, etc.).
Nous allons voir comment traiter l’événement que constitue un appui sur un bouton de la
souris dans la fenêtre.
Gestion de l’appui sur un bouton de la souris dans la fenêtre
Exemple

Liste des gestionnaires d’événements issus de la
souris
mousePressEvent appui sur un bouton de la souris

mouseReleaseEvent relâchement d’un bouton de la souris
mouseDoubleClickEvent double clic sur un bouton de la souris
mouseMoveEvent mouvement de la souris (par défaut, quand un bouton est appuyé)
Utilisation de l’information associée à un événement

Les arguments transmis aux méthodes qui gèrent les événements de la souris sont des
objets de type QMouseEvent. Un objet de cette classe est automatiquement créé par
Python lors du déclenchement de l’événement. Cet objet contient de plus d’autres
informations. En particulier pour un appui sur le bouton de la souris, il contient une
information concernant le bouton qui a été appuyé. Cette information peut être
récupérée grâce à la méthode button. Les valeurs prises peuvent être comparées avec
les constantes prédéfinies ci-dessous :
Qt.LeftButton bouton gauche
Qt.RightButton bouton droit
Qt.MidButton bouton du milieu
Exemple avec gestionnaires d’événements issus

de la souris

Exemple avec gestionnaires d’événements issus
de la souris
• De même, les coordonnées de la position du curseur de souris au moment
de l’appui peuvent être obtenues au moyen des méthodes x et y.
Suivi des mouvements de la souris

Dans le cas du gestionnaire mouseMoveEvent, il est possible d’activer le suivi
des mouvements de la souris par la fenêtre même si aucun bouton n’est
appuyé. Pour cela, il faut utiliser la méthode setMouseTracking(True)
disponible pour la classe QWidget.
Exemple :

Bases de Python
Mise en forme
Gestion de la disposition
Le système de mise en page (layout) Qt fournit un moyen simple et puissant
d’organiser automatiquement les widgets enfants dans un widget parant.
• QHBoxLayout présente des widgets dans une ligne horizontale, de gauche à
droite.
• QVBoxLayout présente des widgets

dans une colonne verticale,
de haut en bas.
• QGridLayout présente des widgets dans

une grille bidimensionnelle.
Les widgets peuvent occuper plusieurs
cellules.
• QFormLayout présente des widgets dans
un style de champ d’étiquette
descriptif à 2 colonnes.

La notion de gestionnaire de mise en forme
Un gestionnaire de mise en forme permet de gérer la disposition (en anglais
layout) de plusieurs composants. Nous allons ici utiliser un gestionnaire de mise
en forme de la classe QVBoxLayout qui permet de positionner les composants les
uns sous les autres verticalement. Il possède une méthode addWidget() pour
ajouter les composants à gérer. Il faut indiquer à la fenêtre qu’elle doit utiliser ce
gestionnaire de mise en forme grâce à la méthode setLayout() de la classe
QWidget.
class QVBoxLayout
Gestionnaire de mise en forme qui crée une boite (en anglais box) dans laquelle
les composants seront disposés les uns sous les autres verticalement.
Horizontalement, ils occuperont toute la largeur de la boite.
addWidget(composant)
Ajoute un composant dans le gestionnaire de mise en forme.
Paramètres: composant – référence du composant à ajouter
Exemple de QVBoxLayout

Exemple dans une fenêtre personnalisée
Exemple avec positionnement horizontal

(QHBoxLayout())

Positionnement en grille
• QGridLayout est la classe de gestionnaire de mise en forme la plus
universelle. Il divise l'espace en lignes et colonnes.
• Normalement, chaque widget consomme une cellule de la grille, mais il est

aussi possible pour le widget d’occuper plus de cellules en utilisant des
lignes et des colonnes couvrant les nombres de la méthode surchargée
addWidget().
• addWidget (self, QWidget, row, column, rowSpan, columnSpan,

Qt.Alignment alignment = 0)
• Les troisième et quatrième paramètres sont l’espacement des lignes et des

colonnes, égal à un par défaut. Si l’espacement est de -1, le widget de cellule
s’étendra vers le bord droit ou le bord inférieur.
Exemple de disposition en grille

Exemple de disposition en formulaire
Bases de Python
Composants graphiques usuels

Le bouton
• Un composant graphique (appelé widget en anglais) est un élément de
base d’une interface graphique avec lequel un utilisateur peut interagir
(par exemple une fenêtre ou un champ de saisie de texte). Il existe de
nombreux composants susceptibles d’intervenir dans une interface
graphique. Afin d’étudier leur fonctionnement, nous allons aborder le cas
d’un composant graphique simple : un bouton.
• Création d’un bouton - QPushButton
On crée un bouton en utilisant le constructeur de la classe QPushButton, auquel on communique
le texte qu’on souhaite voir figurer à l’intérieur du bouton.
class QPushButton(text)
Bouton dont le constructeur reçoit un texte qui sera affiché sur le bouton.
Gestion du bouton
• On va connecter le signal clicked de la classe QPushButton avec l’appel
d’une fonction.

Gestion du bouton dans une fenêtre
personnalisée
Autres utilisation du bouton

• Bouton pour quitter l’application
• Affichage d’une info-bulle (tooltip en anglais)
• Affichage d’un « message box »

Etiquette - QLabel
Une étiquette (en anglais label) est un composant de type QLabel qui permet
d’afficher un texte non éditable par l’utilisateur, mais que le programme peut
faire évoluer.
class QLabel (texte)
Paramètres: texte (string) – texte initial qui sera affiché.
Méthode: setText () - Modifie le texte de l’étiquette.
Exemple
Exemple de QLabel avec modification du texte

Champ de texte - QLineEdit
Un champ de texte (aussi appelé champ de saisie de texte) est une zone de
texte éditable dans laquelle l’utilisateur peut entrer ou modifier un texte. Il
s’obtient en instanciant un objet de type QLineEdit.
Présentation
class QLineEdit(texte)
Paramètres: texte (string) – texte initial qui sera affiché.
Méthode: text() - Renvoie de le texte contenu dans le QLineEdit.
Méthode: setText (texte) - Modifie le texte dans le QLineEdit.
Exemple
Exemple d’application (avec les trois

Widgets)
• Créer une interface graphique à l’image de celle-ci dessous.
• Le bouton servira pour faire la somme des 2 QLineEdit au dessus et affiche
le résultat dans celui en dessous.
La partie import

La partie définition des Widgets
La partie traitement de signal

Suite de: class Fenetre(QWidget):
La procédure principale

Case à cocher - QCheckBox
Une case à cocher permet d’effectuer un choix (coché/non coché) pour une
case. Elle est instanciée grâce à la classe QCheckBox.
Présentation
class QCheckBox(text)
Paramètres: text (string) – libellé qui sera affiché à côté de la case
Méthode: checkState() - Renvoie la valeur de l’état de la case (state)
Méthode: setCheckState(state) - Fixe la valeur de l’état de la case.
state – état à prendre : Qt.Checked ou Qt.Unchecked
Combobox - QComboBox

Bases de Python
Dessin
Exemple de dessin

Dessin - QPainter
• Les opérations de dessin Bitmap dans Qt sont gérées par la classe
QPainter. Il s’agit d’une interface générique qui peut être utilisée
pour dessiner sur différentes surfaces, y compris celle de la fenêtre
principale.
• def paintEvent(self, event): Evènement se déclenchant après
l’affichage de la fenêtre
• painter = QPainter(self): permet de créer un objet painter
• painter.setPen(QPen(Qt.black, 2, Qt.SolidLine)): permet de définir
le format du stylet, les paramètres sont la couleur, l’épaisseur et le
format de la ligne.
Fin

Python Course

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python Course

Transféré par

Droits d'auteur :

Formats disponibles

Programmation

Wednesday, October 7, 2020 Prof. M. LAHLOU 44

Wednesday, October 7, 2020 Prof. M. LAHLOU 45

• Lignes 2 et 3. L'interpréteur nous a permis de connaître le contenu de la

Wednesday, October 7, 2020 Prof. M. LAHLOU 46

Les types des données

int Nombre entier optimisé

long Nombre entier de taille arbitraire

float Nombre à virgule flottante

complex Nombre complexe

str Chaîne de caractère

list Liste de longueur variable

Wednesday, October 7, 2020 Prof. M. LAHLOU 47

Le type int (entier) et le type float (réelle)

Wednesday, October 7, 2020 Prof. M. LAHLOU 48

• Remarquez toutefois que si vous mélangez les types entiers et floats, le

Wednesday, October 7, 2020 Prof. M. LAHLOU 49

Opérations sur les types numériques (suite)

Wednesday, October 7, 2020 Prof. M. LAHLOU 50

symbole effet exemple

/ Division réelle 6/4 == 1.5

** élévation à la puissance 12**2 == 144

// division entière 6//4 == 1

Le type str (chaîne de caractères)

Wednesday, October 7, 2020 Prof. M. LAHLOU 51

• L'opérateur d'addition + concatène (assemble) deux chaînes de caractères.

Wednesday, October 7, 2020 Prof. M. LAHLOU 52

symbole effet exemple

Concaténation de deux chaînes de

La fonction len() retourne la longueur

* Répetition d’une chaîne de caractère

Indique si une sous-chaine de caractères

• La méthode find(): recherche une chaîne de caractères passée en

Remarque : la fonction not est un opérateur logique qui renvoie l’opposé de

Wednesday, October 7, 2020 Prof. M. LAHLOU 54

• X and Y : ET logique, si X est évalué à False, alors l'expression est False et Y

• not X : évalué à la valeur booléenne opposée de X.

• Conversions sont essentielles dans le cas de l’utilisation de fichiers ou de

Wednesday, October 7, 2020 Prof. M. LAHLOU 53

Wednesday, October 7, 2020 Prof. M. LAHLOU 55

Ordre d'évaluation des expressions

• En Python, vrai signifie n’importe quel nombre différent de zéro ou

Wednesday, October 7, 2020 Prof. M. LAHLOU 14

• Cette instruction va renvoyer une chaîne de caractères que

Thursday, October 15, 2020 Prof. M. LAHLOU 67

Thursday, October 15, 2020 Prof. M. LAHLOU 68

Thursday, October 15, 2020 Prof. M. LAHLOU 69

Instructions simples : Affectations

• La commande a,b=3,4 affecte simultanément la valeur 3 à a et la

Wednesday, October 7, 2020 Prof. M. LAHLOU 14

Les commentaires en fin de ligne:

Wednesday, October 7, 2020 Prof. M. LAHLOU 13

Bloc d’instructions - Indentation

• Un bloc peut contenir une ou plusieurs instructions, et notamment des

Wednesday, October 7, 2020 Prof. M. LAHLOU 15

S'il y a plusieurs instructions indentées sous la ligne d'en-tête,

Thursday, October 15, 2020 Prof. M. LAHLOU 76

condition est une expression booléenne, c’est-à-dire une

Affichage après exécution :

Wednesday, October 7, 2020 Prof. M. LAHLOU 16

Exemple animé d’une structure

Exemple animé d’une structure

Exemple animé d’une structure

Dans ces exemples, le bloc après le if contient deux instructions. L’instruction

élévation à la puissance 122 == 144