Module : ALGORITHMIQUE ET

PROGRAMMATION (PYTHON)
Chapitre 1
 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, vocabulaire
et syntaxe plus riches
• C++, Java, PHP,…
• C, Fortran,…
• Bas niveau : proche de la machine
 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 ») ;
• 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 tres simples charges d'une
mission tres precise sur votre ordinateur) ;
• Un langage imperatif interprete (c'est-a-dire
que les instructions que vous lui envoyez sont
\transcrites" en langage machine au fur et a
mesure de leur lecture) contrairement a un
langage compile (C/C++)
 Le langage Python
Python est un langage de programmation.
Ce qui définit un langage de programmation:
• La façon de représenter symboliquement les
structures de données.
• La façon de gérer le contrôle des programmes
(que faire et dans quel ordre)
 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 :
 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
 Les variables
Exemple
Nous allons refaire l’exercice du calcul du 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")
 Solution :

def conversion1(n):
h = n // 3600
m = (n - 3600*h) // 60
s = n % 60
print(h,"heures,",m,"minutes,",s,"secondes")