Université Sultan Moulay Slimane

Faculté Polydisciplinaire
BENI MELLAL

Algorithmique et Programmation
Python

Pr: OUATIK FAROUK

[Link]@[Link]

2025/2026
Les langages de programmation
 Le langage de programmation est l'intermédiaire entre
l'humain (anglais)et la machine(binaire).
 Il existe des milliers de langages de niveau élevé, pour
tous les goûts et toutes les applications.
 Quelques uns des plus connus: C, C++, Java, PHP,…
Les langages de programmation
 Haut niveau : proche de l’homme, plus facile à
apprendre et à utiliser grâce à son haut niveau
d'abstraction qui masque les détails techniques du
système
➢ C++, Java,Python, PHP,…
 Bas niveau : proche de la machine offrant plus de
contrôle et d'efficacité mais nécessitant une grande
connaissance de l'architecture matérielle.
➢ Assembleur
Compilation et interpréteur

 Compilation: permet de traduire le code source du

programme vers le langage natif (objet) de la
machine(ou parfois vers du code intermédiaire).
Compilation et interpréteur

Interpréteur: permet de traduire et d’exécuter chaque

instruction du programme. Ce mécanisme est utilisé
pour le passage d’un programme précompilé à un
pseudo-code (cas de Java).
Définition d'algorithme
 Une suite finie et non-ambiguë d’opérations
élémentaires (ou d'instructions) permettant de
résoudre un problème sans aucun exercice
d'intelligence par une machine.
 Un algorithme prend en entrée des données et fournit
un résultat permettant de donner la réponse à un
problème pour chaque instance après un nombre fini
d'opérations élémentaires
Exemple
 Exemples d'algorithmes
 Recettes de cuisine ;
 Instructions pour le montage d'un meuble ;
 Les règles arithmétiques pour exécuter l'addition, la
soustraction, la multiplication et la division de deux
nombres ;
 Les démarches bureaucratiques pour l'obtention d'un
passeport.
pgdc(n, m) : Algorithme d'Euclide
1. r ← n (mod m)
2. si r = 0, le résultat est m, FIN
3. n ← m, m ← r
4. retourner au Pas 1.
Programme et langage de programmation
 Un programme est un algorithme écrit dans un
langage de programmation.
 Un langage est un ensemble de phrases.
Exemples de phrases :
 en français (« Je m’appelle Paul. ») ;
 en anglais (« The book is on the table ! ») ;
 en arithmétique (« 1 + 2 = 3 ») ;
langage de programmation
 Un langage de programmation est un langage qui sert
a codifier des algorithmes afin de les rendre «
compréhensibles » par la machine.
 Exemple en Python :
def succ(x=0):
return x + 1
Différents langages de programmation
Il existe plusieurs langages de programmation :
 impératifs (C, Pascal, FORTRAN, . . .) ;
 fonctionnels (Lisp, Haskel, Scheme, ML, . . .) ;
 orientés objet (SmallTalk, C++, Java, . . .) ;
 déclaratif (PROLOG).
Le langage Python
 C'est un langage de scripts (de petits programmes très
simples charges d'une mission très précise sur votre
ordinateur) ;
 Un langage impératif interprété (c'est-a-dire que les
instructions que vous lui envoyez sont \transcrites" en
langage machine au fur et à mesure de leur lecture)
contrairement a un langage compile (C/C++)
Le langage Python
Python est un langage de programmation.
Un langage de programmation se définit par :
 La façon de représenter les données
c’est la manière dont le langage permet de définir,
structurer et manipuler les informations(les types de
données, la syntaxe utilisée)
 La façon de gérer le contrôle des programmes (que
faire et dans quel ordre)
c’est la manière dont le langage indique l’ordre
d’exécution des instructions, c’est-à-dire quoi faire et
quand le faire (les structures de contrôle, la gestion des
fonctions et des modules)
Pourquoi python
 Gratuit
 Syntaxe simple
 Portable (Mac OS, Unix, Windows, Android, etc.)
 Compilé et interprété avec une machine virtuelle
 Multi-paradigme (impératif, orienté objet et fonctionnel)
 Moderne (dynamiquement typé, multi-threadé,
extensible, etc.)
 Utilisé dans des nombreux projets industriels :
 Arts, business, éducation, ingénierie, gouvernement,
scientifique, etc.
 En évolution
Les types de données
Comme tout langage de programmation, Python fournit
un certain nombre de types de données prédéfinis
(booléens, entiers, flottants, chaine de caractères, listes)
et de structure de contrôle (les boucles for, while et les
conditions if then else ).
Les types de données
On va se limiter à quelques types :
 le type des nombres entiers int. On peut les
additionner, les multiplier, les comparer,…
 le type des nombres à virgule float 8. On peut aussi
les multiplier, les comparer,… et se servir de nombres
entiers comme s’ils étaient des nombres à virgule.
 le type des chaînes de caractères str. On peut les
afficher, les concaténer,…
 le type des booléens bool, qui valent soit True (vrai),
soit False (faux).
Les nombres : entiers et flottants
 Tous les entiers (en anglais integer) au sens
mathématique peuvent être représentés en python.
Les flottants (en anglais float) représentent les
nombres non-entiers. Ces nombres comportent un
point séparant la partie entière et la partie
fractionnelle.
 Par exemple 1.5 est un flottant. Sa partie entière est 1
et sa partie fractionnelle est le 5. C’est le point qui
permet à python de reconnaître un flottant. Ainsi 1.0
et 1. sont des flottants, même si leur partie
fractionnelle est nulle.
Les nombres : entiers et flottants
Opérateurs
 Une opération est constituée d’un opérateur et d’un
ou plusieurs opérandes.
Les nombres : entiers et flottants
 Les opérateurs suivants opèrent aussi bien sur les
opérandes entières que flottantes. Les opérateurs dits
unaires admettent une seule opérande, alors que les
opérateurs dits binaires en admettent deux.
Les nombres : entiers et flottants
Pour la division on a : la division réelle (/) et la division
euclidienne (//)
Les nombres : entiers et flottants
 L’ordre d’évaluation des opérateurs:
 Dans une expression il peut y avoir plusieurs
opérateurs et, dans certains cas, l’ordre dans lequel on
effectue ces opérations peut influer sur le résultat du
calcul.
 La priorité des opérateurs :
Les nombres : entiers et flottants
 L’ordre d’évaluation des opérateurs:
 Exemple : on commence par les parenthèses les plus
profondes
Les nombres : entiers et flottants

Les règles :
 Commencer par effectuer les opérateurs de plus haut
niveau de priorité ;
 Lorsque plusieurs opérateurs ont le même niveau de
priorité, effectuer les opérations en commençant par
les opérateurs les plus à gauche ...
 sauf lorsqu’il s’agit de l’opérateur puissance (où on
commence par les opérateurs les plus à droite).
Les nombres : entiers et flottants
 Exemple :
 -3**2//2+3*-7-5
 3**2 = 9
 -9//2 + 3*-7 – 5
 -9 // 2 = -5 (car division entière en Python → arrondi
vers le bas).
 -5 + 3*-7 – 5
 3 * -7 = -21
 -5 + (-21) – 5
 -5 - 21 - 5 = -31
Les chaînes de caractères:

Python permet de manipuler du texte. Les données

représentant un texte sont de type chaîne de caractères (en
anglais character string ou simplement string). Une chaîne de
caractères est une juxtaposition de caractères. Il peut s’agir
de caractères entrés au clavier :
 des lettres minuscules ou majuscules ;
 des chiffres ;
 des caractères espace, tabulation, retour à la ligne ;
 d’autres caractères visibles : @, &, #, $, £, (, {, [ etc.
 Mais les caractères peuvent aussi être invisibles (par
exemple lorsque la chaîne n’a pas été entrée par
l’utilisateur mais provient de la lecture d’un fichier).
Les chaînes de caractères:

Les chaînes de caractères définies de façon explicite (en

anglais string literals) sont toujours encadrées par des
apostrophes (en anglais quotes) ou des guillements (en
anglais double quotes) de façon équivalente. Voici des
exemples de chaînes de caractères : "bonjour" ou
encore ’fzlseher@lh’.
Les chaînes de caractères:

les opérateurs:
 + : l’opérateur de concaténation ;
 * : l’opérateur de duplication.
Les chaînes de caractères:

L’opérateur de concaténation + doit avoir deux

opérandes de type chaîne de caractères. L’expression
résultante est aussi une chaîne de caractères obtenue
en juxtaposant les deux opérandes.
 Exemple :
Les chaînes de caractères:

L’opérateur de duplication * doit avoir une opérande de

type chaîne de caractères et une opérande de type
entier. L’expression résultante est aussi une chaîne de
caractères obtenue en répétant la chaîne de caractères.
Le nombre de répétitions est donné par l’opérande
entière.
Les chaînes de caractères:

 Exemple:
Les chaînes de caractères:

 Conversions explicites:
Les chaînes de caractères:

 Attention!
Les chaînes de caractères:

 On peut aussi convertir un int à float ou l’inverse:

Les chaînes de caractères:

 len : la longueur d’une chaîne

 Si s est une chaîne de caractères, alors la valeur de
len(s) est un entier représentant le nombre de
caractères qui constituent s.
 Par exemple len(’coucou’) vaut 6.
Les chaînes de caractères:

 Les séquences d’échappement

Les chaînes de caractères:

 Exemple :
 Les variables
La plupart des langages de programmation permettent
d’associer une valeur donnée à un nom.
Par exemple en python, on peut écrire :
Taille=8
Cette instruction associe le nom taille à la valeur 8. Après cette
instruction, lorsque Python rencontrera le mot taille, il
l’interprétera comme l’entier 8. On dit qu’une variable a été
définie.
Les variables
 L’instruction qui associe un nom à une valeur est
appelée une définition.
 Une définition crée une variable.
 Une variable est caractérisée par une valeur, un type
et un nom (appelé aussi identificateur).
 Cet identificateur peut être constitué de lettres
(minuscules ou majuscules), de chiffres et de _
(underscore). Le premier caractère ne doit pas être un
chiffre.
Les variables
 Exemple:
Les variables
 L’opérateur =, malgré sa ressemblance avec l’égalité
mathématique, n’est pas symétrique. Autrement dit a
= b n’est pas équivalent à b = a.
 Le membre de gauche doit être constitué d’une
variable.
 Le membre de droite peut être constitué de
n’importe quelle expression composée d’une ou
plusieurs constantes ou variables.
 Le membre de gauche reçoit la valeur du membre de
droite
Les variables
Les variables
Opérateurs:
Dans certains langages (en particulier les langages
fonctionnelles), les variables gardent la même valeur
pendant tout le programme (on parle, malgré tout de
variables). Dans d’autres langages (en particulier en
python), on peut redéfinir une variable, c’est à dire y
associer une nouvelle valeur :
Les variables
 Opérateurs
Les variables
 Attention: Les variables de type chaîne de caractères
n’ont pas besoin d’être mis entre guillemets.
Les variables
Réciproquement, python essaiera d’interpréter comme
une variable toute suite de caractères qui ne se trouve
pas entre des apostrophes ou des guillemets. Par
exemple :
Les variables
L’utilité des variables
 Stocker pour ne pas refaire le calcul lorsqu’un même calcul
doit être fait à plusieurs endroits d’un programme, il vaut
mieux effectuer le calcul une fois et de mettre le résultat
dans une variable.
 Les valeurs littérales ne doivent apparaître qu’une seule
fois (Une valeur littérale est une valeur apparaissant dans
un programme sous la forme d’un chiffre. Une chaîne de
caractère littérale est une chaîne entourée d’apostrophe
ou de guillemets. Les données dans un programme
apparaissent soit sous la forme de valeurs littérales soit
sous la forme de variables.)
 La lisibilité : rendre le programme plus lisible
 Exemple :
 Un conducteur souhaite estimer le coût total de son
voyage entre deux villes aller-retour.
➢ Sa voiture consomme 4,57 litres de carburant pour
100 km.
➢ La distance entre les deux villes est de 613 km.
➢ Le prix du carburant est de 1,62 dirhams par litre.
➢ Le trajet comprend également un péage de 32,40
dirhams.
Les variables
Exemple
Nous voulons calculer le coût du voyage en utilisant des
variables.
D’abord, nous enregistrons les valeurs du problème
dans des variables :
 la voiture fait 4,57 litres au 100 km.
 la distance entre les deux villes est de 613 km.
 le prix du carburant est de 1,62dh le litre.
 le péage coûtera 32,40dh.
 Les variables

 Ensuite, nous calculons le coût du carburant pour un aller

simple en utilisant les variables appropriées :

 Nous calculons le coût total du voyage aller-retour :

Le type booléen
Une variable booléenne peut prendre deux valeurs :
True (vrai) ou False (faux). Attention la majuscule est
importante en python.
Le type booléen
Il existe en python d’autres opérateurs permettant de comparer deux expressions
:

Attention à ne pas confondre

l’opérateur "=" qui permet
l’affectation d’une valeur à une
variable et l’opérateur "==" qui
permet la comparaison entre
deux variables.
Le type booléen
Les opérations utilisant des opérateurs de comparaison retournent un booléen.
Le type booléen
On peut ainsi définir une variable booléenne comme n’importe quel
autre type de variable :
Le type booléen
On peut comparer des variables entre elles :
Le type booléen
On peut créer une variable contenant le résultat d’une opération de
comparaison :
Le type booléen
Comparaison entre nombres de types différents
En python les opérateurs de comparaison (sauf le "in" et "not in")
permettent de comparer tous les nombres quels que soient leur type
(entier, flottant...).
 Le type booléen

Les opérateurs "in" et "not in" permettent de tester l’appartenance ou non de

nombres dans des ensembles de nombres mais cela nécessite l’utilisation de
structures que nous n’avons pas encore vues dans ce cours.
Le type booléen
Comparaison entre chaînes de caractères et
Unicode
 Les opérateurs de comparaison sont également définis
pour comparer des chaînes de caractères (string).

 Pour pouvoir comparer des chaînes de caractères, il

faut définir un ordre permettant de dire pour tout
couple d’éléments lequel est supérieur ou inférieur.
Cet ordre dépend de la manière dont le texte est
encodé.
 Le type booléen

L’encodage est le processus qui assigne à chaque caractère (par

exemple "a", "A", "n", "2"...), un nombre unique appelé code
point. Python 3 utilise par défaut l’Unicode pour encoder les
chaînes de caractères.
Le type booléen
Le code point d’un caractère peut être affiché en utilisant la fonction
ord() :
Le type booléen
Lorsqu’on compare deux caractères avec un opérateur de comparaison,
ce sont les code points des caractères qui sont comparés.
Par exemple :
 Le type booléen
En pratique, il faut retenir que les lettres sont ordonnées par ordre
alphabétique et les chiffres sont ordonnés par ordre croissant. De plus,
l’ensemble des chiffres sont positionnés avant les lettres majuscules qui sont
elles même avant les lettres minuscules :
Le type booléen
 La comparaison de chaînes de caractères se fait caractère par
caractère.

 Pour les égalités "==", chaque caractère deux à deux doit être égal
pour retourner True et pour les différences "! =", il suffit d’un caractère
différent entre les deux chaînes pour retourner True.
Le type booléen
 Pour les inégalités strictes (">", "<"), les premier caractères de chaque
chaînes sont comparés, s’ils sont différents, l’expression peut être
évaluée (True ou False). Sinon les deux caractères suivants sont
comparés, etc.

 Si une chaîne est plus longue que l’autre et que la comparaison n’est
plus possible car il manque un caractère, la chaîne la plus longue est
considérée supérieure à la chaîne plus courte.
Le type booléen
 Dans le premier cas, la comparaison du "j" et "J" permet de conclure
car ord("j") > ord("J").

 Dans le deuxième cas, la comparaison du "B" et "b" permet de

conclure car ord("B") < ord("b").

 Dans le troisième cas, tous les caractères sont égaux deux à deux, sauf
le dernier de la première chaine qui ne peut pas être comparé. La
première chaîne étant plus longue que la deuxième, elle est
considérée comme supérieure.
 Le type booléen
L’opérateur "in" renvoie True si chaque caractère de l’opérande gauche est
présent dans le même ordre dans l’opérande droit. Inversement, l’opérateur
"not in" renvoie True si la chaîne de caractère de l’opérande gauche n’est pas
présente caractère par caractère dans l’opérande droit.
Le type booléen
La comparaison de chaînes de caractères n’est pas forcément intuitive. Il
faut bien faire attention à la constitution des chaînes de caractères que
vous comparez avant de vous en servir dans vos programmes. Si elles ne
contiennent pas que des lettres par exemple, le résultat pourrait vous
surprendre.
Indentation

Les blocs de code (fonctions, instructions if, boucles for ou while etc.)
sont définis par leur indentation. L'indentation démarre le bloc et la
désindendation le termine. Il n'y a pas d'accolades, de crochets ou de
mots clés spécifiques. Cela signifie que les espaces blancs sont
significatifs et qu'ils doivent être cohérents.

a = -150
if a<0:
print 'a est négatif'

Ligne d'en-tête:
première instruction du bloc
...
dernière instruction du bloc
 Structure conditionnelle
Condition si
Les structures conditionnelles permettent d’exécuter différentes opérations
en fonction de l’évaluation d’une condition spécifique. Par exemple,
supposons que nous avons deux nombres quelconques stockés dans les
variables "x" et "y" ; nous voulons un programme qui retourne la chaîne de
caractère "x est plus grand que y" seulement si c’est le cas. Dans le cas
contraire, rien ne se passe.
Voici comment l’écrire en python :

En algorithmique :
si (x>y) alors
afficher “x est plus grand que y"
fin si
Structure conditionnelle
Évidemment il faut au préalable avoir affecté des valeurs à x et y.
Analysons la structure de cette condition :

Le mot clef if doit être suivi d’une condition. Généralement cela passe
par une proposition logique mettant en jeu un opérateur de comparaison
(par exemple a + b > 0 ou x! = 1). En d’autres termes, le mot clef if doit
être suivi d’un booléen. En effet, le résultat d’une comparaison renvoie
bien soit True soit False.
Structure conditionnelle
Dans ce cas, le programme afficherait toujours "c’est vrai", mais
n’afficherait jamais "c’est faux".
la condition après le if doit être suivie de " :" .
l’ensemble des instructions à effectuer si la condition est vraie (ici
seulement le print), doit être indenté sous le if.
Structure conditionnelle
Condition si ... sinon
Nous venons de voir comment faire pour effectuer une action seulement
si une condition est vraie. Mais comment faire pour effectuer une autre
action dans le cas où la condition est fausse ?
Ceci se fait grâce au mot clef else :

Dans ce cas là, une seule des deux phrases sera affichée en fonction du
résultat de x > y. Vous noterez que le mot clef else doit être au même
niveau que le if et doit être suivi des " :". Comme toujours, l’ensemble
des instructions à effectuer dans le cas else doit être indenté sous le else.
Structure conditionnelle
En algorithmique :

si (condition) alors
// instructions à exécuter si la condition est vraie
sinon
// instructions à exécuter si la condition est fausse
fin si
Structure conditionnelle
Condition si ... sinon si ... sinon
Enfin, que faire dans le cas d’une condition plus complexe ? Reprenons
l’exemple précédent avec la condition initiale x > y. Trois cas peuvent se
produire :
 x est strictement plus grand que y
 x est strictement plus petit que y
 x est égal à y
Si nous voulons que le programme indique dans quel cas nous somme, nous
avons besoin d’un nouveau mot clef : elif (contraction de else if ).
Structure conditionnelle
En algorithmique :

si (condition1) alors
// instructions si condition1 est vraie
sinon si (condition2) alors
// instructions si condition2 est vraie
Sinon
// instructions si aucune des conditions n'est vraie
fin si
Structure conditionnelle
 Le mot clef elif doit lui aussi être suivi d’une condition (c’est à dire d’un
booléen). Lors de l’exécution du programme, la condition du elif n’est
évaluée que si la condition précédente (ici celle du if ) est fausse.
 La figure ci-après est un diagramme des possibilités pour cet exemple :

 Dans cet exemple, un seul elif est requis, mais autant de elif que
nécessaire peuvent être ajoutés après un if. Chaque elif est alors
évalué seulement si toutes les conditions précédentes ont été
évaluées comme fausses.
Structure conditionnelle
Différence entre if ... if et if ... elif
Lorsque vous écrivez un programme, il est important de bien réfléchir au
type de structure conditionnelle que vous allez utiliser.
Prenons les deux exemples suivant :
Structure conditionnelle

Dans le deuxième cas, la condition dans le elif est pourtant bien True.
Seulement, le programme ne l’a jamais évalué. Il a dans un premier
temps évalué la condition du if. Comme cette dernière est vraie, il a
exécuté les lignes de code indentées sous le if puis est sorti de la
structure conditionnelle.
Dans certaines situations, on est amené à exécuter plusieurs
fois des actions identiques ou du moins de même nature.
Une Itération est une séquence d’instructions destinée à
être exécutée plusieurs fois.
Selon que le nombre de répétitions soit connu à l’écriture du
programme ou pas, on utilisera une structure « for » ou
une structure « while ».
Les répétitions : la boucle for (pour)
En algorithmique :

pour variable allant de valeur_initiale à valeur_finale faire

// instructions à exécuter
fin pour
Exemple :

pour i allant de 1 à 5 faire

afficher i
fin pour
 Les répétitions : la boucle for
La boucle for permet de répéter un ensemble d’instructions. Cette boucle prend
la forme générale suivante :

L’interpréteur python s’attend à ce que :

 l’instruction for se termine par le caractère ’:’
 une ou plusieurs des instructions suivantes commencent par un caractère
tabulation ;
 une suite de caractères espace n’est pas équivalent à un caractère tabulation ;
 si l’instruction for commence déjà par un certain nombre de tabulations, alors
les instructions suivantes devront en avoir un de plus ;
Les répétitions : la boucle for
Dans ce cas, toutes les instructions suivant for et commençant par une
tabulation supplémentaire seront exécutées N fois. Dans l’exemple ci-
dessus, <instructionM> ne fait pas partie de la boucle et n’est pas
répétée. Par exemple :

bonjour
bonjour
bonjour
Tout va bien ?

Ce programme a répété l’exécution de print("bonjour") trois fois. On dit

qu’il y a eu 3 itérations.
Les répétitions : la boucle for
Le compteur de la boucle

L’identificateur qui suit for n’a pas besoin d’avoir été défini auparavant. Python fait de
cet identificateur une variable.
 À la première itération, cette variable vaut 0 ;
 à la deuxième itération, cette variable vaut 1 ;
 ...
 à la dernière itération, cette variable vaut n-1.
On l’appelle le compteur de la boucle.

0
1
2
Apres :
2
Les répétitions : la boucle for
 Il est possible de commencer les itérations avec un compteur non-nul,
en donnant un deuxième argument à l’opérateur range.

1
2
3
Apres :
3
Les répétitions : la boucle for
Boucles for imbriquées
À l’intérieur d’une boucle, on peut faire une deuxième boucle (voire une
troisième ou une quatrième si nécessaire). Par exemple :

(0,0)
(0,1)
(0,2)
(1,0)
(1,1)
(1,2)
Les répétitions : la boucle while(tant que )
La boucle tant que (ou while en anglais) est une structure de contrôle en
algorithmique utilisée pour répéter un ensemble d'instructions tant
qu'une condition est vraie. Contrairement à la boucle for, elle est
particulièrement utile lorsqu'on ne connaît pas à l'avance le nombre
d'itérations, mais qu'on sait qu'elles doivent se poursuivre tant qu'une
certaine condition est vérifiée.
En algorithmique :

tant que condition faire

// instructions à exécuter
fin tant que
Les répétitions : la boucle while(tant que )
Exemple :
i=1
tant que i <= 5 faire
afficher i
i=i+1
fin tant que

L’affichage :
1
2
3
4
5
Les répétitions : la boucle while
La boucle while permet de répéter le bloc d’instructions tant que la
condition est vraie.
Par exemple :
Les répétitions : la boucle while
Dans le cas de notre exemple, la sortie de ce code serait :
0
1
2
3
fin de boucle
Les répétitions : la boucle while
Vous aurez peut être remarqué que la boucle while de l’exemple
précédent peut être remplacée par la boucle for suivante :

Quand il s’agit d’implémenter des compteurs, la boucle for est

effectivement plus judicieuse. La boucle while est elle par contre très
utile lorsque le nombre d’itérations n’est pas connu à l’avance par le
programmeur.
Les répétitions : la boucle while
Imaginons que nous voulons écrire un programme qui demande à
l’utilisateur de résoudre une multiplication, par exemple 7x4. Le
programme doit afficher l’instruction autant de fois que nécessaire,
jusqu’à ce que l’utilisateur entre effectivement la solution. On ne peut
pas prédire à l’avance combien d’essais l’utilisateur va tenter. Ce code
s’écrirait alors ainsi :

La fonction input affiche la chaîne de caractères entre parenthèses et

attend que l’utilisateur entre quelque chose au clavier. L’entrée de
l’utilisateur est alors stockée dans la variable de sortie (ici
input_utilisateur) sous forme de string.
Les répétitions : la boucle while
Dans cet exemple, le programme commence par tester la condition du
while. Au début comme input_utilisateur vaut "0", il exécute l’intérieur
de la boucle et demande donc une valeur à l’utilisateur. Le programme
test de nouveau la condition du while, si l’utilisateur entre 28, le
programme sort de la boucle et affiche "Bravo", sinon il redemande une
nouvelle valeur à l’utilisateur, etc.
Les répétitions : la boucle while

Combinaison de propositions par opérateurs logiques

Jusqu’à présent nous avons vu que les structures if elif if et les boucles for requerraient
une proposition souvent sous la forme d’une comparaison. Il est également possible
de tester plusieurs propositions en même temps en les combinant dans une "super"
proposition.
Par exemple :

Ici le programme affichera la valeur de a, seulement si la combinaison des

deux conditions est vérifiée, c’est-à-dire si a est supérieur à 0 et inférieur à
10.
La combinaison de conditions peut se faire en utilisant les mots clefs "and",
"or" et "not". and représente le ET logique et or le OU logique .
Il est possible de combiner autant de and et or que nécessaire dans une seule
condition. Du point de vue informatique, qu’il y ait une seule condition ou
plusieurs ne change rien. En effet, le résultat d’une comparaison ou d’une
combinaison de comparaisons est toujours une valeur booléenne :
Les répétitions : la boucle while

not permet la négation d’une proposition logique. not A est vraie si A est
fausse, et fausse si A est vraie.
Par exemple :
Les répétitions : la boucle while
Retour sur les priorités entre opérateurs

Nous avons déjà vu qu’il existe des priorités entre opérateurs permettant
à l’interpréteur python de savoir quelle opération effectuée en premier
lorsqu’il rencontre une combinaison d’opérations.
Les opérateurs de comparaison ainsi que les opérateurs logiques que
nous avons vus s’intègrent également dans cet ordre de priorité.
L’ensemble des opérateurs vus jusqu’à présent sont rangés par ordre de
priorité décroissant dans le tableau ci-après :
Les répétitions : la boucle while
 La figure suivante montre un exemple de l’ordre d’exécution des opérations en python :
Exercice : écrire un programme calculant la somme d’une suite
d’entiers saisie par l’utilisateur se terminant par 0 (exemple
5, 4, 9, 0 renverra 18).
Solution :

somme,n = 0,1
while n != 0:
n = int (input("Entrez un nombre (0 pour arrêter) : "))
somme += n
print("la somme des entiers saisis vaut",somme)
 Sous-programmes
Principe

◼ Un sous-programme est un bloc d’instructions réalisant

une certaine tâche.

◼ Il possède un nom et est exécuté lorsqu’on l’appelle.

◼ Un script bien structuré contiendra un programme dit

“principal”, et plusieurs sous-programmes dédiés à des
fonctionnalités spécifiques.
 Sous-programmes
Principe

Programme
appel du sous-
instructions programme
Toto
...
Toto
Retour au bloc d’instructions du sous-
... programme
programme Toto
instructions
...

◼ Quand un programme dit « principal » fait appel à un sous–

programme, il suspend son propre déroulement, exécute le
sous–programme en question, et reprend ensuite son
fonctionnement.
 Sous-programmes
Trois grands avantages

1. Éviter la duplication de code.

appel/retour

appel/retour

Ici le bloc de code en Ici on crée un sous-programme correspondant à ce

rouge est dupliqué bloc, et on l’appelle quand on en a besoin.
 Sous-programmes
Trois grands avantages.

2. Favoriser la réutilisation.

◼Un sous-programme écrit pour résoudre un problème

donné pourra servir de nouveau dans un autre contexte.

◼On pourra ainsi créer des « librairies » de sous-

programmes.
 Sous-programmes
Trois grands avantages.

3. Améliorer la conception.

Programme initial très complexe

Sous-programme Sous-programme
complexe simple

Sous-sous- Sous-sous- Sous-sous-

programme programme programme
simple simple simple
 Sous-programmes
Notion de paramètre

◼ Un sous-programme sert donc à effectuer un traitement

générique.

◼ Ce traitement porte sur des données, dont la valeur

pourra ainsi changer d’un appel du sous-programme à un
autre.

◼ Ce que l’on appelle “paramètres” ce sont justement ces

données transmises au sous-programme par le
programme principal.
 Sous-programmes
Notion de paramètre

◼ Lors de l’implémentation d’un sous-programme, on va

donc préciser la liste de tous les paramètres qu’il va
utiliser.

para1 Toto
para2
bloc d’instructions du sous-programme
Toto, qui traite para1, para2, ....paraN
paraN
 Sous-programmes
Notion de paramètre

◼ Lors de l’utilisation d’un sous-programme, on va alors préciser la valeur de chacun

des paramètres qu’il possède.

Programme
Toto
instructions val1
...
val2 bloc d’instructions du sous-
Toto(val1,val2,...)
programme Toto qui traite para1,
...
para2, .... avec les valeurs val1, val2,
instructions valN
...
...
 Sous-programmes
Variables locales versus globales

◼ Pour fonctionner un sous-programme peut également

avoir besoin d’utiliser des variables qui lui sont propres.
On parle alors de “variables locales”.

◼ Ce sont par exemple des résultats de calculs

intermédiaires, des compteurs de tours dans une structure
itérative, etc.

◼ Ces variables ne sont accessibles qu’au sein du sous-

programme qui les définit et utilise.
 Sous-programmes
Variables locales versus globales

◼ Un sous programme reçoit donc des données à traiter, les

paramètres, et pour ce faire peut avoir besoin de
variables locales :

Toto
para1
bloc d’instructions du sous-
para2
programme Toto, qui traite para1,
para2, ....
paraN à l’aide de variables locales
var1, var2, ...
 Sous-programmes
Variables locales versus globales

◼ On a vu qu’un sous-programme pouvait utiliser des

données transmises par le programme principal sous
forme de paramètres.

◼ Il peut également manipuler directement des variables

définies par le programme principal. On parle alors de
“variables globales”.

◼ Il s’agit d’une possibilité mais également d’une mauvaise

pratique car cela limite énormément la réutilisabilité des
codes d’un projet à un autre.
 Sous-programmes
Variables locales versus globales

◼ Un sous-programme peut accéder aux variables globales définies dans le

programme principal :

Programme
Toto
instructions
Définition de variables globales bloc d’instructions du sous-
glob1, glob2, ... programme Toto qui traite para1,
... val1 para2, .... avec les valeurs val1, val2,
Toto(val1,val2,...) val2 ...
... à l’aide de variables locales
instructions var1, var2, ...
... valN Toto accède aux variables globales
glob1, glob2, ...
 Sous-programmes
Deux types de sous-programmes

En algorithmique on distingue deux types de sous-

programmes :

◼ Les procédures, qui modifient l’état du programme sans

retourner de résultat.

◼ Les fonctions, qui elles ont pour but de retourner un

résultat.
 Sous-programmes
Deux types de sous-programmes

Fonctions :

◼Il s’agit donc d’un sous-programme qui va retourner un

résultat au programme principal.

para1 Toto
para2 résultat
bloc d’instructions du sous-
programme Toto, qui traite para1,
paraN para2, ....
 Sous-programmes
Deux types de sous-programmes
Remarque :
◼ Tous les langages de programmation ne distinguent pas
nommément ces deux types de sous–programmes.

◼ En Python, en C et en C++, on ne manipule ainsi a priori que des

fonctions. Bien qu’en pratique la distinction se fasse.

◼ En Pascal par contre, les deux types sont clairement séparés.

 Les sous-programmes en Python
Les Fonctions
Le langage Python permet de réaliser ce que l’on nomme des fonctions. Il s’agit d’un
bloc d’instructions qu’on écrit une seule fois en leur attribuant un nom et qui dépend
ou non d’un certain nombre de paramètres.
La fonction, peut être utilisée en tout point d’un programme en utilisant juste un
appel avec le nom du sous programme (ou de la fonction) avec les paramètres
voulus.

Syntaxe générale d’une fonction :

def maFonction(para1,para2,...,paraN):
bloc d’instructions de la fonction
return valeur

Exemple : calcul du cube d’un nombre

def cube(x):
return x*x*x
 Les sous-programmes en Python
Les Fonctions
Remarques importantes :
◼Une fonction peut retourner plusieurs valeurs, il suffit de
séparer celles-ci par des virgules.
◼Une fonction peut contenir plusieurs fois la commande “return”,
mais elle cesse son fonctionnement dès qu’elle en rencontre une.

Exemple : calcul du minimum et du maximum de deux nombres

def calculMiniMaxi(x,y):
if x < y:
return x,y
else:
return y,x
 Les sous-programmes en Python
Les Fonctions

Utilisation d’une fonction :

◼On appelle la fonction par son nom, en lui passant autant de
paramètres qu’elle en possède.
◼Pour ne pas “perdre” la(les) valeur(s) retournée(s), on les
incorporera par exemple dans une opération d’affichage,
d’affectation, etc.

Exemples d’utilisations de fonctions :

print(cube(5))
a,b = 5,-2
min,max = calculMiniMaxi(a,cube(b))
print("Minimum :",min,", Maximum :",max)
 Les sous-programmes en Python
Les Fonctions
Duck Typing
Principe du “Duck Typing” :
◼En Python on ne précise pas les types attendus des paramètres
des sous-programmes.
◼Cela implique que l’on peut utiliser un sous-programme avec des
paramètres de n’importe quel type, à la condition que les
opérations du sous-programme soient compatibles avec les types
des paramètres.
Exemple de “Duck Typing” :
def addition(x,y):
return x + y
print(addition(666,1))
print(addition("Brown ",'Sugar'))
 Les sous-programmes en Python
Paramètres par défaut
◼ Les paramètres d’un sous-programme peuvent comporter des
valeurs par défaut.
◼ Deux cas possibles :
◼ Lors de l’appel on ne précise pas de valeurs pour les
paramètres en question et le sous-programme utilise celles
par défaut.
◼ Si on précise des valeurs ce sont celles-ci qui sont utilisées.

Exemple :
def rectangle(x=3,y=1):
print("périmètre :",2*(x+y),"aire :",x*y)
rectangle()
rectangle(2)
rectangle(7,5)
 Les sous-programmes en Python
Paramètres par défaut

Autre exemple :

def rectangle(x,y=1):
print("périmètre :",2*(x+y),"aire :",x*y)

rectangle(2)
rectangle(7,5)
 Les sous-programmes en Python
Paramètres immuables

◼ Les paramètres de type “int”, “bool”, “float”, “complex” et

“str” sont immuables.
◼ Cela signifie que si l’on passe une variable de l’un de ces types
comme paramètre à une fonction, celle-ci ne pourra pas en
modifier sa valeur.

Exemple : tentative pour doubler un nombre

def doubler(x):
x *= 2

a = 3
print("valeur de a avant :",a)
doubler(a)
print("valeur de a après :",a)
 Les sous-programmes en Python
Paramètres immuables

Exemple (suite) : contournement du problème précédent en

utilisant une fonction

def doubler(x):
return 2*x

a = 3
print("valeur de a avant :",a)
a = doubler(a)
print("valeur de a après :",a)
 Les sous-programmes en Python
Variables locales et globales
Variables locales :
◼Ce sont donc des variables définies à l’intérieur d’un sous
programme et qui ne sont accessibles qu’au sein de celui-ci.
◼Elles servent essentiellement au bon fonctionnement du sous-
programme.

Exemple : fonction calculant la somme des n premiers entiers,

avec deux variables locales “utilitaires”

def sommeEntiers(n):
somme = 0
for i in range(n+1):
somme += i
return somme
 Les sous-programmes en Python
Variables locales et globales

Exemple (suite) : tentative d’utilisation de la variable locale

somme en dehors de la fonction

def sommeEntiers(n):
somme = 0
for i in range(n+1):
somme += i
return somme

print(somme)
 Les sous-programmes en Python
Variables locales et globales
Variables globales :
◼Ce sont des variables définies en dehors de tout sous-
programme. Elles sont “globales” au sens où elles sont visibles et
utilisables dans tous les sous-programmes du module courant.

Ordre de recherche des variables dans un sous-programme

La rencontre d’un nom de variable dans un sous-programme
déclenche une recherche LGI (Locale Globale Interne) :
1. Recherche d’une variable Locale correspondant à ce nom.
2. Recherche d’une variable Globale correspondant à ce nom.
3. Recherche d’un nom Interne au langage.
 Les sous-programmes en Python
Variables locales et globales
Exemple 1 :
def exemple1():
print(i)

i = 666
exemple1()

Exemple 2 :
def exemple2():
i = 111
print(i)

i = 666
exemple2()
print(i)
 Les sous-programmes en Python
Variables locales et globales

Exemple 3 :

def exemple3():
print(i)
i = 111
print(i)

i = 666
exemple3()
 Les sous-programmes en Python
Variables locales et globales

Modification de la valeur de variables globales :

◼Les variables globales ne sont a priori pas modifiables par

des sous-programmes.

◼Pour que cela soit possible, il faut le signaler explicitement

dans le sous programme à l’aide de l’instruction “global”.

Syntaxe :
global var
 Les sous-programmes en Python
Variables locales et globales

Exemple 4 :

def exemple4():
global i
print(i)
i = 111
print(i)

i = 666
exemple4()
print(i)
 Les sous-programmes en Python
Exercice

Ecrire une fonction (procédure) prenant en paramètre une

durée en secondes et qui affiche la conversion de cette durée
en heures, minutes, secondes.
 Solution :

def conversion1(n):
h = n // 3600
m = (n - 3600*h) // 60
s = n % 60
print(h,"heures,",m,"minutes,",s,"secondes")
 Les sous-programmes en Python
Récursivité

Définition : un sous–programme (fonction) est dit récursif

s’il s’appelle lui même.
Idée : pour effectuer une tâche ou un calcul, on se ramène à
la réalisation d’une tâche similaire mais de complexité
moindre. On recommence jusqu’à obtenir une tâche
élémentaire.
Exemple classique : calcul de n! = 1 x 2 x 3 x … x n.
On montre facilement la relation de récurrence n! = n x (n-1)!
Si on sait calculer (n-1)!, on connaîtra donc la valeur de n!
Mais (n-1)! = (n-1) x (n-2)!
On est donc ramené au calcul de (n-2)!
Et ainsi de suite jusqu’à 1! dont on connaît la valeur : 1
 Les sous-programmes en Python
Récursivité
Exemple : calcul récursif de n!
def factorielleRecursive(n):
if n == 0 or n == 1:
return 1
else:
return n*factorielleRecursive(n-1)

Déroulement du programme : si par exemple n = 4

facto(4) = 4 x facto(3) facto(4) = 4 x 6 = 24

facto(3) = 3 x facto(2) facto(3) = 3 x 2 = 6

facto(2) = 2 x facto(1) facto(2) = 2 x 1 = 2

facto(1) = 1 facto(1) = 1
 Les sous-programmes en Python
Récursivité

Remarque importante :
Il est indispensable de prévoir une condition d’arrêt à la récurions
sinon le programme ne se termine jamais.

Exemple à ne pas suivre :

def factorielleRecursiveBadJob(n):
return n*factorielleRecursiveBadJob(n-1)
 Les sous-programmes en Python
Récursivité versus itération

◼ On peut toujours transformer un algorithme récursif en un

algorithme itératif et inversement.
◼ L’algorithme itératif sera plus rapide une fois implémenté dans
un langage de programmation mais souvent plus complexe à
écrire.

Exemple : version itérative du calcul de n!

def factorielleIterative(n):
resultat = 1
for i in range(2,n+1):
resultat *= i
return resultat
 Les sous-programmes en Python
Récursivité versus itération
Intérêts de la récursivité :
◼ Technique de programmation très élégante et lisible (elle évite
souvent le recours à de nombreuses structures itératives).
◼ Elle est très utile pour concevoir des algorithmes sur des
structures complexes.

Inconvénient majeur de la récursivité :

◼ Une fois implémentée dans un langage de programmation,
cette technique est très « gourmande » en mémoire.
◼ Elle peut même provoquer des débordements de capacité.