Algorithmique et programmation : les bases (Python) Corrigécregut.perso.enseeiht.fr/ENS/2015-apad-algo1/algo1-apad...ALGORITHMIQUE ET PROGRAMMATION 1 Algorithmique et programmation

PAD – INPT

ALGORITHMIQUE ET PROGRAMMATION 1

Cours Python, Semaine 1

avril–mai 2016

Algorithmique et programmation : les bases(Python)Corrigé

Résumé

Ce document décrit l’écriture dans le langage Python des éléments vus en algorithmique.

Table des matières1 Pourquoi définir notre langage algorithmique ? 3

2 Structure d’un algorithme 32.1 Exemple d’algorithme : calculer le périmètre d’un cercle . . . . . . . . . . . . . 32.2 Structure de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.3 Identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.4 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3 Variables 53.1 Qu’est ce qu’une variable ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53.2 Définition d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

4 Types fondamentaux 64.1 Les entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64.2 Les réels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74.3 Les booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74.4 Les caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74.5 Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

5 Constantes 8

6 Expressions 8

7 Instructions d’entrée/sorties 97.1 Opération d’entrée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97.2 Opération de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

8 Affectation 10

Cours Python, Semaine 1 c© INPT–PAD 1/23

ALGORITHMIQUE ET PROGRAMMATION 1 Algorithmique et programmation : les bases (Python)

9 Structures de contrôle 129.1 Enchaînement séquentiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129.2 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

9.2.1 Conditionnelle Si ... Alors ... FinSi . . . . . . . . . . . . . . . . . 129.2.2 Conditionnelle Si ... Alors ... Sinon ... FinSi . . . . . . . . . . 149.2.3 La clause SinonSi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159.2.4 Conditionnelle Selon . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

9.3 Instructions de répétitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179.3.1 Répétition TantQue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179.3.2 Répétition Répéter ... JusquÀ . . . . . . . . . . . . . . . . . . . . . . . 209.3.3 Répétition Pour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229.3.4 Quelle répétition choisir ? . . . . . . . . . . . . . . . . . . . . . . . . . 23

Liste des exercicesExercice 1 : Cube d’un réel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Exercice 2 : Permuter deux caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Exercice 3 : Cube d’un réel (avec une variable) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Exercice 4 : Une valeur entière est-elle paire ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Exercice 5 : Maximum de deux valeurs réelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Exercice 6 : Signe d’un entier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Exercice 7 : Réponse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Exercice 8 : Somme des premiers entiers (TantQue) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Exercice 9 : Saisie contrôlée d’un numéro de mois . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Exercice 10 : Plusieurs sommes des n premiers entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Exercice 11 : Saisie contrôlée d’un numéro de mois . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21Exercice 12 : Somme des premiers entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22



1 Pourquoi définir notre langage algorithmique ?

2 Structure d’un algorithme

2.1 Exemple d’algorithme : calculer le périmètre d’un cercleUn exemple d’algorithme/programme est donné ci-dessous. Il décrit comment obtenir le pé-

rimètre d’un cercle à partir de son diamètre. Cet exemple est volontairement très simple.

Listing 1 – Programme Python pour calculer le périmètre d’un cercle1 # -*- coding: utf-8 -*-2 """3 ROLE : Déterminer le périmètre d’un cercle à partir de son rayon4 Attention : aucun contrôle sur la saisie du rayon ==> non robuste !5 EXEMPLE : Le périmètre d’un cercle de rayon 5 est 31.41596 AUTEUR : Claude Monteil <[email protected]>7 VERSION : 1.1 - 04/20168 """9

10 # CONSTANTE11 PI = float(3.14159)12 # VARIABLES13 rayon = float() # le rayon du cercle saisi au clavier14 perimetre = float() # le perimetre du cercle15 #16 print ("Périmètre d’un cercle")17 #1.Saisir le rayon18 rayon = float(input("Rayon = "))19 #2.Calculer le perimetre20 perimetre = 2 * PI * rayon # par definition21 #3.Afficher le perimetre22 print ("Le périmètre est : ", perimetre)

2.2 Structure de l’algorithmeLa structure d’un programme Python est celle d’un algorithme avec les 3 parties spécifica-

tions (rôle du programme), déclarations (définition des constantes et variables qui seront utili-sées) et opérations (actions proprement dites qui vont modifier des variables ou interagir avecl’utilisateur par des saisies ou affichages d’informations).

Un programme Python correspond à un fichier-texte d’extension .py, par exemple ici calculer-perimetre.py.

Dans l’environnement SPYDER, il faut créer un fichier (menu Fichier > Nouveau fichier..., ou icône Nouveau fichier, ou raccourci Ctrl-N, le N étant l’initiale de New ou Nouveau)qui contiendra le code du programme. Lorsqu’un niuveau fichier est créé dans SPYDER, il estinitialisé avec les lignes suivantes :

1 # -*- coding: utf-8 -*-



2 """3 Created on [la date et l’heure de creation]45 @author: [votre_nom]6 """

Il faut conserver la 1re ligne telle quelle : elle indique que le codage des caractères textuelscorrespond au jeu de code standard utf-8. C’est notamment utile pour le traitement des caractèresaccentués.

Les lignes encadrées par les 2 lignes contenant chacune trois guillemets (le caractère guillemet-double, et non la répétition de deux quotes) s’appellent en Python une docstring, cést-à-direune spécification de documentation (chaîne de caractères). On prendra l’habitude de toujoursla renseigner, avec en particulier les rubriques suivantes repérée par un nom en majuscule :

1 """2 ROLE : indiquer le rôle du programme [INDISPENSABLE !]3 EXEMPLE : si possible, donner au moins un exemple d’exécution avec des données4 et le résultat correspondant. Cela permet ainsi de tester le programme et d’avoir une5 meilleure confiance en lui.6 AUTEUR : c’est une bonne habitude de préciser le nom du ou des auteurs7 VERSION : c’est une bonne habitude d’indiquer un numéro de version et sous-version8 ainsi que la date à laquelle cette version a été achevée9 """

On peut sauvegarder régulièrement le fichier par le menu Fichier > Enregistrer (ou icône En-registrer un fichier, ou raccourci Ctrl-S, le S étant l’initiale de Save ou Sauvegarder).

Nous détaillons dans la suite de ce document le contenu des 2 parties suivantes : les déclara-tions de constantes et variables, puis les opérations du programme

Les instructions en Python sont les mêmes que celles présentées en langage algorithmiqueavec simplement une écriture un peu différente.

2.3 IdentificateursUn identificateur est un mot de la forme : une lettre ou le caractère underscore (tiret-8) suivie

d’un nombre quelconque de lettres ou chiffres ou caractères underscore (tiret-8).Remarque : Minuscules et majuscules sont différenciées en Python !Attention : Bien qu’il soit possible en Python d’utiliser des lettres accentuées, cette pratiqueest à bannir pour des raisons de compatibilité entre les différents environnements de program-mation existants ! Selon la nature de l’identificateur (variable, constante, etc.), des conventionsd’écriture sont utilisées par la communauté des programmeurs Python pour faciliter la bonneconnaissance par le programmeur (et ses lecteurs) de la nature de ce qu’il manipule dans sonprogramme, ce qui améliore la fiabilité et la rapidité d’écriture des programmes. Nous précise-rons ces conventions au fur et à mesure de notre parcours.



2.4 CommentairesUn commentaire commence par # et se termine à la fin de la ligne. Il peut débuter en début

de ligne ou derrière une instruction.Ne pas hésiter à utiliser beaucoup de commentaires, en évitant cependant d’éviter de tomber

dans le verbiage : l’objectif fondamental des commentaires est d’expliciter les intentions du pro-grammeur pour rendre le plus clair et le plus lisible possibles la compréhension des instructionsassociées.

On accordera un statut particulier aux commentaires dénotant la trace des affinages del’analyse algorithmique effectuée en les commençant par un numéro, le cas échéant en utilisantplusieurs numéros séparés chacun par un point s’il y a plusieurs niveaux d’affinage :

#1.Saisir les données au clavier#1.1.Saisir d’abord le nombre d’éléments

En Python, on peut aussi utiliser des commentaires multilignes commençant par trois guillemetsconsécutifs (""") et s’achevant de la même manière. Cette faculté est notamment utile en phase dedéveloppement d’un algorithme en saisissant directement dans Python la réflexion algorithmiqueen tant que commentaire multiligne, puis en transformant peu à peu ces commentaires sous formed’instructions Python.Remarque : Dans un programme finalisé, on ne laisse en principe comme commentaire multi-ligne que la docstring définissant les spécifications du programme en début de fichier.

3 Variables

3.1 Qu’est ce qu’une variable ?

3.2 Définition d’une variableEn Python, une variable se trouve implicitement créée dès lors qu’on lui effectue une affec-

tation (avec le caractère =) pour la première fois, cette première affectation pouvant avoir lieun’importe où dans le programme, et donc pas forcément dès le début.Attention : Pour des raisons de lisibilité et de compatibilité avec la notation algorithmique utili-sée dans le cadre de notre apprentissage, nous conviendrons de définir les constantes et variablesen début de programme, juste après les spécifications du programme. La définition d’une va-riable s’effectuera donc par une affectation (signe =) avec en partie gauche le nom de la variable,et en partie droite le type désiré suivi d’une paire de parenthèse.

Par convention en Python, les noms des variables seront toujours en minuscules, avecmise en majuscule de l’initiale des éventuels mots composant le nom de la variable s’il y ena plusieurs. Voici quelques exemples :

rayonrayonCerclerayonCercleInscrit



Remarque : On s’efforcera de toujours choisir des noms signifiants pour les variables, c’est-à-dire des noms tels que leur lecture permettra de comprendre très rapidement la nature de l’in-formation véhiculée par cette variable. Sauf cas très particuliers, on évitera l’utilisation de nomstrès courts sur une ou deux lettres. Dans la définition d’une variable, on peut préciser une valeurd’initialisation au sein de la paire de parenthèse, par exemple rayon = float(0). Si on ne le faitpas, il demeure indispensable de laisser la paire de parenthèses vide. Dans ce cas, une valeur pardéfaut est affectée à la variable (0 pour une variable entière ou réelle).Remarque : En Python, le type de la variable peut aussi être défini implicitement selon le typede la valeur (ou du résultat du calcul) indiqué en partie droite de l’affectation. Par exemple, n =0 définit une variable entière tandis que n = 0.0 définit une variable réelle.Attention : On précisera toujours explicitement le type d’une variable lors de sa définition.Les types et leur signification sont présentés dans la suite de ce document.

On peut déclarer plusieurs variables sur une même ligne à condition de séparer chaque défi-nition par un point-virgule, par exemple en écrivant :

a = float(0) ; b = float(0) # les deux coefficients de l’équation

Remarque : De manière générale, le point-virgule sert à séparer plusieurs instructions courtesau sein d’une même ligne d’instructions. On s’efforcera d’utiliser plutôt une seule instructionpar ligne, ce qui permet d’expliciter avec un commentaire le rôle que l’on entend faire jouer à lavariable considérée.Remarque : En Python, il est possible de pouvoir changer le type d’une variable par une nouvelleaffectation avec un résultat de type différent (ce qu’on appelle un "typage dynamique"). Nouséviterons systématiquement cette pratique dans le cadre de notre apprentissage algorithmique.

4 Types fondamentauxLes types fondamentaux élémentaires sont les types numériques entiers (int) et réels (float),

ainsi que les chaînes de caractères (str) et les booléens (bool).

4.1 Les entiersLe type entier se note int (en minuscules). La division entière s’effectue avec l’opérateur //,

et le reste de la division entière s’obtient avec l’opérateur %.In [1]: 20/3Out[1]: 6.666666666666667 # division réelleIn [2]: 20//3Out[2]: 6 # quotient de la division entière de 20 par 3In [3]: 20%3Out[3]: 2 # reste de la division entière de 20 par 3

Remarque : Les entiers de type int sont en principe limités en valeur absolue à environ 2 mil-liards (plus précisément 2**31-1 = 2 147 483 647). Ceci étant, lorsque un calcul entier aboutità des valeurs plus grandes, il y a conversion implicite dans un autre type entier (le type long)



qui n’a pas de limite de capacité autre que la mémoire allouée par l’ordinateur à l’interpréteurPython.

4.2 Les réelsLe type réel se note float. Il correspond à des réels en "virgule flottante" permettant une

quinzaine de chiffres significatifs et des valeurs absolues jusqu’à 10 puissance 300 environ !La valeur absolue s’obtient par la fonction prédéfinie abs (en minuscules).La partie entière d’un réel s’obtient par la fonction int, son arrondi avec la fonction round.In [4]: abs(-3.14)Out[4]: 3.14In [5]: int(3.14)Out[5]: 3In [6]: round(3.64)Out[6]: 4

4.3 Les booléensLe type booléen est bool.Les deux valeurs que peuvent prendre des variables booléennes se notent True et False. Bien

noter que l’initiale est en majuscule et le reste en minuscules !Les opérateurs logiques se notent and pour Et, or pour Ou et not pour Non. Ils sont tous 3 en

minuscules.Remarque : Les expressions booléennes peuvent ne pas être évaluées totalement dès lors qu’unrésultat partiel permet de connaître le résultat final. Par exemple, True or expression ne calcu-lera pas l’expression car on sait que le résultat sera forcément True quelle que soit la valeur del’expression.

4.4 Les caractèresLe type caractère n’existe pas en tant que tel en Python. Ce n’est qu’un cas particulier d’une

chaîne de caractères (cf. paragraphe suivant).Les fonctions algorithmiques Chr et Ord ont les mêmes noms mais en minuscules :In [7]: ord("A")Out[7]: 65 # 65 est le code ASCII de la lettre A majusculeIn [8]: chr(65)Out[8]: ’A’ # A majuscule est la lettre correspondant au code ASCII 65

4.5 Les chaînes de caractèresUne chaîne se déclare avec le mot-clé str (abréviation de string).

1 chaine = str("bonjour") # création d’une variable de type str avec initialisation à "bonjour"



5 ConstantesUne constante est un cas particulier de variable dont on spécifie que la valeur ne pourra en

aucune manière changer au cours de l’exécution du programme. En Python, une constante sedéclare comme une variable en précisant explicitement la valeur d’initialisation, qui est doncréputée ne plus changer au cours de l’exécution. Par convention en Python, afin de rapidementdifférencier une constante d’une variable, les noms des constantes seront toujours en majus-cules, avec usages du caractère underscore (tiret sous la touche 8) pour séparer les éventuelsmots composant le nom de la constante s’il y en a plusieurs. Voici quelques exemples :

PI = float(3.1416) # valeur abrégée du nombre PITITRE_MODULE = str("Algorithmique et programmation) # matière importante !NB_MAXI_ELEVES = int(150) # nombre maximum d’élèves par promotion

Les constantes sont usuellement déclarées avant les variables en tout début de programme, justeaprès la docstring précisant les spécifications du programme.

6 ExpressionsUne expression est une formule de calcul, usuellement de type numérique, mais on peut aussi

avoir des expressions booléennes (qu’on appelle des "conditions") ou encore des expressionstextuelles (de type chaîne de caractères). Les expressions utilisent des opérateurs et des fonctionsprédéfinies (on verra ultérieurement comment définir nos propres fonctions).

Les opérateurs numériques sont les opérateurs usuels +, -, *, /, ainsi que l’élévation à lapuissance **. Les entiers utilisent en plus les opérateurs // (quotient entier) et % (reste d’unedivision entière), comme déjà signalé.

Les priorités des opérateurs sont celles classiquement utilisées, avec usage de parenthèsespour forcer explicitement des priorités.

Les opérateurs + et * sont également utilisables avec les chaînes de caractères pour concaténerdes chaînes ou répéter des motifs.

Les opérateurs booléens, outre les opérateurs and, or et not déjà mentionnés, sont les opé-rateurs de comparaison entre les types fondamentaux : <, >, <=, >=, == (égal à) et != (différentde).Attention : Bien noter que le test d’égalité nécessite de redoubler le caractère =, celui-ci toutseul signifiant une affectation et non une comparaison. C’est une erreur très fréquente (en débutd’apprentissage) que d’écrire un test d’égalité avec un seul caractère =.

In [9]: 1+2*3Out[9]: 7

In [10]: (1+2)*3Out[10]: 9

In [11]: 10 * "=-" + "="Out[11]: ’=-=-=-=-=-=-=-=-=-=-=’



In [12]: 1+2*3 == 7Out[12]: True

7 Instructions d’entrée/sorties

7.1 Opération d’entréeEn standard, Python utilise la fonction input qui affiche sur la console le message d’invite

précisé entre parenthèses et renvoie une chaîne de caractères correspondant à ce que l’utilisateura tapé au clavier.

Si l’on veut affecter le résultat à une variable numérique, il faut explicitement convertir lachaîne saisie en un entier ou un réel.

In [13]: reponse = input("Oui ou non ? ")Oui ou non ? oui

In [14]: reponseOut[14]: ’oui’

In [15]: note = int(input("Quelle note (sur 5) mettez-vous ? "))Quelle note (sur 5) mettez-vous ? 5

In [16]: noteOut[16]: 5

In [17]: notePrecise = float(input("Et plus précisément ? "))Et plus précisément ? 4.5

In [18]: notePreciseOut[18]: 4.5

7.2 Opération de sortieL’affichage d’information se fait avec l’instruction print suivi de la liste d’informations à

afficher en utilisant la virgule comme séparateur. Si l’on indique des variables ou des expressions,c’est la valeur résultante qui est affichée. Par défaut, un espace est inséré entre chaque valeuraffichée. On peut spécifier un autre séparateur en utilisant en fin de liste la mention sep= suivi ducaractère (ou de la chaîne) de séparation à afficher.

In [19]: print("La note obtenue est donc",notePrecise)La note obtenue est donc 4.5

In [20]: print("télégramme","tout est clair", "on continue !",sep="-stop-")télégramme-stop-tout est clair-stop-on continue !

Exercice 1 : Cube d’un réelÉcrire un programme qui affiche le cube d’un nombre réel saisi au clavier.



Solution :1 R0 : Afficher le cube d’un nombre réel23 Tests :4 0 -> 05 1 -> 16 2 -> 87 -2 -> -88 1.1 -> 1,3319

10 R1 : Raffinage De « Afficher le cube d’un nombre réel »11 | Saisir un nombre réel x: out Réel12 | Afficher le cube de x x: in Réel1314 R2 : Raffinage De « Afficher le cube de x »15 | Écrire(x * x * x)

1 # -*- coding: utf-8 -*-2 """3 ROLE : afficher le cube dún nombre réel4 EXEMPLE : Le cube de 3 est 27.05 AUTEUR : Claude Monteil <[email protected]>6 VERSION : 1.0 - 04/20167 """89 # VARIABLE

10 x = float() # un nombre saisi par l’utilisateur11 #12 print("Cube d’un nombre")13 #1.Saisir un nombre réel14 x = float(input("Nombre = "))15 #2.Afficher le cube de x16 print ("Son cube est : ", x * x * x)

8 AffectationComme déjà évoqué lors de la déclaration de variables, l’affectation se note avec le signe =.

Lors d’une affectation, il y a d’abord calcul de la valeur de la partie à droite du signe =, puis en-suite affectation de cette valeur à la variable présente à gauche du signe = en début d’instruction.

Un cas particulier (et fréquent) est l’instruction de cumul, dans laquelle la variable apparaîtdes 2 côtés du signe = :

In [21]: n = 10

In [22]: n = n+1 # instruction à lire ainsi : "n reçoit : n plus un"

In [23]: nOut[23]: 11



Exercice 2 : Permuter deux caractèresÉcrire un programme qui permute la valeur de deux variables c1 et c2 de type caractère.Solution : Le principe est d’utiliser une variable intermédiaire (tout comme on utilise un réci-pient intermédiaire si l’on veut échanger le contenu de deux bouteilles).

1 # -*- coding: utf-8 -*-2 """3 ROLE : permuter deux caractères4 AUTEUR : Claude Monteil <[email protected]>5 VERSION : 1.0 - 04/20166 """7 # VARIABLES8 c1 = str() ; c2 = str() # les 2 caracteres à permuter [définis comme chaînes]9 tmp = str() # variable intermediaire

10 #11 print ("Permutation de caractères")12 #1.initialiser c1 et c213 c1 = "A"14 c2 = "Z"15 print ("Avant permutation : c1 =", c1, "et c2 =", c2)16 #2.permuter c1 et c217 tmp = c1 ; c1 = c2 ; c2 = tmp18 #3.afficher pour verifier19 print ("Après permutation : c1 =", c1, "et c2 =", c2)

Exercice 3 : Cube d’un réel (avec une variable)Reprenons l’exercice 1.3.1 Utiliser une variable intermédiaire pour le résoudre.Solution : On reprend le même R0 et les mêmes tests. En fait, seule la manière de résoudre leproblème change.

1 R1 : Raffinage De « Afficher le cube d’un nombre réel »2 | Saisir un nombre réel x: out Réel3 | Calculer le cube de x x: in Réel ; cube: out Réel4 | Afficher le cube56 R2 : Raffinage De « Afficher le cube de x »7 | cube <- x * x * x

1 # -*- coding: utf-8 -*-2 """3 ROLE : afficher le cube dún nombre réel (usage d’une variable)4 EXEMPLE : Le cube de 3 est 27.05 AUTEUR : Claude Monteil <[email protected]>6 VERSION : 1.0 - 04/20167 """89 # VARIABLE

10 x = float() # un nombre saisi par l’utilisateur11 cube = float() # le cube de x12 #



13 print("Cube d’un nombre (avec variable)")14 #1.Saisir un nombre réel15 x = float(input("Nombre = "))16 #2.calculer le cube de x17 cube = x * x * x18 #2.Afficher le cube de x19 print ("Son cube est : ", cube)

3.2 Quel est l’intérêt d’utiliser une telle variable ?Solution : L’intérêt d’utiliser une variable intermédiaire est d’améliorer la lisibilité du pro-gramme car elle permet de mettre un nom sur une donnée manipulée. Ici on nomme cube ladonnée x * x * x.

De plus, ceci nous a permis, au niveau du raffinage, de découpler le calcul du cube de son affi-chage. Il est toujours souhaitable de séparer calcul des opérations d’entrées/sorties car l’interfaceavec l’utilisateur est la partie d’une application qui a le plus de risque d’évoluer.3.3 Exécuter à la main l’algorithme ainsi écrit.Solution : À faire soi-même !

9 Structures de contrôle

9.1 Enchaînement séquentielLa séquence s’exprime comme en algorithmique.Si cela facilite la lisibilité, on peut écrire 2 instructions courtes sur une même ligne en les

séparant par un point-virgule.

9.2 Instructions conditionnelles9.2.1 Conditionnelle Si ... Alors ... FinSi

En Python, le Si devient if (en minuscules), le Alors est remplacé par deux-points, et lesinstructions associées à la partie Alors doivent être décalées d’une tabulation par rapport au if.Il n’y a pas de FinSi, celui-ci étant implicite dès lors qu’on écrit une instruction qui est réalignéesur le if.

nombre = int(input("Saisir un nombre entier : "))if nombre % 10 == 0 :

print("Le nombre", nombre, "est divisible par 10")print("Il y a donc", nombre//10, "dizaines"

print ("Merci pour votre aimable collaboration !"

Remarque : Il est possible d’utiliser des parenthèses autour de la condition si on préfère mieuxla mettre en valeur.Attention : Il ne faut surtout pas oublier de mettre les deux-points pour achever la ligne du if.C’est une erreur très fréquente en début d’apprentissage ! De même, le if doit impérativements’écrire en minuscules !



Exercice 4 : Une valeur entière est-elle paire ?Écrire un algorithme qui lit une valeur entière au clavier et affiche « paire » si elle est paire.Solution :

1 R0 : Afficher « paire » si une valeur entière saisie au clavier est paire23 tests :4 2 -> paire5 5 -> -----6 0 -> paire78 R1 : Raffinage De « Afficher ... »9 | Saisir la valeur entière n

10 | Afficher le verdict de parité1112 R2 : Raffinage De « Afficher le verdict de parité »13 | Si n est paire Alors14 | | Écrire("paire")15 | FinSi1617 R3 : Raffinage De « n est paire »18 | Résultat <- n Mod 2 = 0

Dans le raffinage précédent un point est à noter. Il s’agit du raffinage R2 qui décompose« Afficher le verdict de parité ». Nous n’avons pas directement mis la formule « n Mod 2 = 0 ».L’intérêt est que la formulation « n est paire » est plus facile à comprendre. Avec la formule,il faut d’abord comprendre la formule, puis en déduire sa signification. « n est paire » nousindique ce qui nous intéresse comme information (facile à lire et comprendre) et son raffinage(R3) explique comment on détermine si n est paire. Le lecteur peut alors vérifier la formule ensachant ce qu’elle est sensée représenter.

Raffiner est quelque chose de compliquer car on a souvent tendance à descendre trop vitedans les détails de la solution sans s’arrêter sur les étapes intermédiaires du raffinage alors quece sont elles qui permettent d’expliquer et de donner du sens à la solution.

Dans cet exercice, vous vous êtes peut-être posé la question : « mais comment sait-on quen est paire ». Si vous avez trouvé la solution vous avez peut-êre donnée directement la formulealors que le point clé est la question. Il faut la conserver dans l’expression de votre algorithmeou programme, donc en faire une étape du raffinage.

Si vous arrivez sur une étape que vous avez du mal à décrire, ce sera toujours une indicationd’une étape qui doit apparaître dans le raffinage. Cependant, même pour quelque chose de simple,que vous savez faire directement, il faut être capable de donner les étapes intermédiaires quiconduisent vers et expliquent la solution proposée. Ceci fait partie de l’activité de constructiond’un programme ou algorithme.Remarque : Il est généralement conseillé d’éviter de mélanger traitement et entrées/sorties.C’est pourtant ce qui a été fait ci-dessus. On aurait pu écrire le premier niveau de raffinagedifféremment en faisant.

1 R1 : Raffinage De « Afficher ... »2 | Saisir la valeur entière n: out Entier



3 | Déterminer la parité de n n: in ; paire: out Booléen4 | Afficher le verdict de parité paire: in Booléen56 R2 : Raffinage De « Déterminer la parité de n »7 | parité <- (n Mod 2) = 089 R2 : Raffinage De « Afficher le verdict de parité »

10 | Si paire Alors11 | | Écrire("paire")12 | FinSi

On constate ici que la variable intermédiaire « paire » permet d’avoir un programme pluslisible car on a donné un nom à la quantité (n Mod 2) = 0.

1 # -*- coding: utf-8 -*-2 """3 ROLE : afficher si un nombre saisi au clavier est pair4 AUTEUR : Claude Monteil <[email protected]>5 VERSION : 1.0 - 04/20166 """7 # VARIABLE8 n = int() # valeur saisie au clavier9 estPair = bool() # True si n est pair, False sinon

10 #11 print ("Parité d’un nombre")12 #1.Saisir une valeur entiere13 n = int(input("Nombre = "))14 #2.Déterminer sa parité15 estPair = (n % 2 == 0) # on affecte à estPair le résultat de la comparaison16 #3.Afficher le diagnostic de parité17 if estPair : # n est pair18 print (n,"est pair")

9.2.2 Conditionnelle Si ... Alors ... Sinon ... FinSi

On peut rajouter une clause else (en minuscules) alignée sur le if et suivie de deux-points.nombre = int(input("Saisir un nombre entier : "))if nombre % 10 == 0 :


else :print("Le nombre", nombre, "n’est pas divisible par 10")print("Tant pis !")


Attention : Il ne faut surtout pas oublier de mettre les deux-points derrière le else. C’est uneerreur très fréquente en début d’apprentissage ! De même, le else doit impérativement s’écrireen minuscules !

Exercice 5 : Maximum de deux valeurs réellesÉtant données deux valeurs réelles lues au clavier, afficher à l’écran la plus grande des deux.



Solution :1 R0 : Afficher le plus grand de deux réels saisis au clavier23 tests :4 1 et 2 -> 25 2 et 1 -> 16 3 et 3 -> 378 R1 : Raffinage De « Afficher le plus grand de deux réels ... »9 | Saisir les deux réels x1, x2 : out Réel

10 | Déterminer le maximum x1, x2 : in ; max : out Réel11 | Afficher le maximum1213 R2 : Raffinage De « Déterminer le maximum »14 | Si x1 > x2 Alors15 | | max <- x116 | Sinon17 | | max <- x218 | FinSi

1 # -*- coding: utf-8 -*-2 """3 ROLE : Afficher le plus grand de deux réels saisis au clavier4 AUTEUR : Claude Monteil <[email protected]>5 VERSION : 1.0 - 04/20166 """7 # VARIABLES8 x1 = float() ; x2 = float() # les deux reels saisis au clavier9 max = float() # le plus grand de x1 et x2

10 #11 print ("Maximum de 2 nombres")12 #1.Saisir les deux reels13 x1 = float(input("Premier nombre reel : "))14 x2 = float(input("Second nombre reel : "))15 #2.Déterminer le maximum16 if (x1 > x2) :17 max = x118 else :19 max = x220 #3.Afficher le maximum21 print ("max (", x1, ",", x2, ") =", max)

9.2.3 La clause SinonSi

On peut rajouter autant de clauses elif que nécessaire, chacune étant alignée sur le if initialet suivie d’une nouvelle condition achevée par deux-points.

nombre = int(input("Saisir un nombre entier : "))if nombre % 10 == 0 :




elif nombre % 5 == 0 :print("Le nombre", nombre, "est divisible par 5 mais pas par 10")

elif nombre % 2 == 0 :print("Le nombre", nombre, "est divisible par 2 mais pas par 10")

else :print("Le nombre", nombre, "n’est pas divisible par 2 ou 5")


Attention : Il ne faut surtout pas oublier de mettre les deux-points pour achever la ligne dechaque elif. C’est une erreur très fréquente en début d’apprentissage ! De même, le elif doitimpérativement s’écrire en minuscules !

Exercice 6 : Signe d’un entierÉtant donné un entier lu au clavier, indiquer s’il est nul, positif ou négatif.Solution :

1 R0 : Afficher le signe d’un entier23 tests :4 2 -> positif5 0 -> nul6 -1 -> négatif78 R1 : Raffinage De « Afficher le signe d’un entier »9 | Saisir un entier n n: out Entier

10 | Afficher le signe de n n: in1112 R2 : Raffinage De « Afficher le signe de n »13 | Si n > 0 Alors14 | | Écrire("positif");15 | SinonSi n < 0 Alors16 | | Écrire("positif");17 | Sinon { Non (n > 0) Et Non (n < 0) donc N = 0 }18 | | Écrire("nul");19 | FinSi

Le principe est d’utliser un SinonSi car les trois cas sont exclusifs.1 # -*- coding: utf-8 -*-2 """3 ROLE : Afficher le signe d’un entier4 AUTEUR : Claude Monteil <[email protected]>5 VERSION : 1.0 - 04/20166 """7 # VARIABLE8 n = int() # entier saisi au clavier9 #

10 print ("Signe d’un nombre")11 #1.Saisir un entier n12 n = int(input("Valeur entiere : "))13 #2.Afficher le signe de n14 if (n > 0) :15 print ("positif")



16 elif (n < 0) :17 print ("negatif")18 else :19 print ("nul")

9.2.4 Conditionnelle Selon

Ce type de conditionnelle n’existe pas en Python. On la remplace par l’instruction condition-nelle précédente contenant autant de elif que nécessaire.

Exercice 7 : RéponseÉcrire un programme qui demande à l’utilisateur de saisir un caractère et qui affiche « affirmatif »si le caractère est un « o » (minuscule ou majuscule), « négatif » si c’est un « n » (minuscule oumajuscule) et « ? ! ? ! ? ! ? » dans les autres cas.Solution :

1 # -*- coding: utf-8 -*-2 """3 ROLE : Répondre par "affirmatif", "négatif" ou "?!?!?!?"4 NOTA : la structure algorithmique ’Selon’ n’existe pas en Python5 AUTEUR : Claude Monteil <[email protected]>6 VERSION : 1.0 - 04/20167 """8 # VARIABLE9 reponse = str() # caractere lu au clavier

10 #11 print ("Réponse affirmative ou négative")12 #1.saisir le caractère13 reponse = input("Votre reponse (o/n) : ")14 #2.afficher la reponse15 if (reponse == "o") or (reponse == "O") :16 print ("Affirmatif")17 elif (reponse.upper() == "N") : # usage d’une fonction renvoyant la majuscule18 print ("Negatif")19 else :20 print ("?!?!?!?")

9.3 Instructions de répétitions9.3.1 Répétition TantQue

En Python, le TantQue devient while (en minuscules) et les instructions du corps de boucledoivent être décalées d’une tabulation par rapport au while. Il n’y a pas de FinTQ, celui-ci étantimplicite dès lors qu’on écrit une instruction qui est réalignée sur le while.

while condition : # préciser l’intention d’un pas de boucleinstruction 1instruction 2...

#ici, on est sorti du while



Exercice 8 : Somme des premiers entiers (TantQue)Calculer la somme des n premiers entiers.Solution : Une solution algorithmique sous forme de raffinages peut-être la suivante :

1 R0 : Afficher la somme des n premiers entiers23 R1 : Raffinage De « Afficher la somme des n premiers entiers »4 Saisir la valeur de n (pas de contrôle) n: out Entier5 { n >= 0 }6 Calculer la somme des n premiers entiers n: in; somme: out Entier7 Afficher la somme somme: in Entier89 R2 : Raffinage De « Calculer la somme des n premiers entiers »

10 somme <- 0 somme: out11 i <- 1 i: out Entier12 TantQue i <= n Faire i, n: in13 { Variant : n - i + 1 }

14 { Invariant : somme =∑i−1

j=0 j }

15 somme <- somme + i somme, i: in; somme: out16 i <- i + 1 i: in; i: out17 FinTQ

Intéressons nous à la condition après le TantQue. On a la propriété suivante :(i > n) -- sortie du TantQue : Non (i <= n)

Et (n - i + 1 >= 0) -- variant >= 0

Et (somme =∑i−1

j=1 j) -- invariant

Les deux premières expressions s’écrivent(i > n ) Et (i <= n+1)

On en déduit : i = n + 1.La troisième donne alors :

somme =n∑

j=1

j

C’est bien le résultat demandé !Bien entendu, il faut aussi prouver que le variant est toujours positif et qu’il décroit stric-

tement (on incrémente i de 1 donc on diminue le variant de 1). Il faut également prouver quel’invariant est toujours vrai.

Commençons par le variant. Montrons par récurrence sur le nombre de passage dans la boucleque la variant est toujours positif.

Si le nombre de passage est nul, donc avant le premier passage, on a : V0 = n − i1 =n− 1 + 1 = n. Par hypothèse sur n (saisie contrôlée), on a bien V0 ≥ 0

Supposons la propriété vraie pour le passage p. On a donc : Vp =≥ 0Montrons que Vp+1 est vraie. On notera avec des primes les variables de Vp+1 au lieu d’utiliser

des indices en p.On a : Vp+1 = n′ − i′ + 1



Si on parle de Vp+1 c’est qu’on est passé dans la boucle. Donc la condition du TantQue estvraie. On a donc i ≤ n.

Or on a n′ = n et i′ = i+ 1 (passage une fois dans la boucle).Donc Vp+1 = n− (i+ 1) + 1 = n− i+ 1− 1 = n− i Comme i ≤ n, on a bien Vp+1 ≥ 0.Par récurrence, on a montrer que le variant est toujours positif.Montrons que le variant décroit strictement. On Vp+1 = n′ − i′ + 1 = n − i + 1 − 1 =

(n− i+ 1)− 1 = Vp − 1. On a bien Vp+1 < Vp.On a donc montrer la terminaison de la boucle.

Remarque : Dans la formulation initiale du R1, j’avais oublié la propriété { n >= 0 }. Elle étaitbien sûr implicite. Essayer de montrer que le variant était toujours positif m’a permis de penserà l’expliciter.

Montrons maintenant que l’invariant est toujours vrai. On utilise aussi une récurrence surle nombre p de passage dans la boucle.

Avant le premier passage, on a∑i−1

j=0 j =∑0

j=0 j = 0 et on a somme = 0. Donc I0 est vrai.Supposons Ip vrai. On a donc : somme =

∑i−1j=0 j

Montrons que Ip+1 est vrai. Si on parle de Ip+1, c’est qu’on passe une nouvelle fois dans laboucle. On a donc : i ≥ n.

Les valeurs de n, i et somme deviennent :s′ = s+ ii′ = i+ 1n′ = ns′ =

∑i−1j=0 j + i par hypothèse de récurrence. s′ =

∑ij=0 j s

′ =∑(i+1)−1

j=0 j s′ =∑i′−1

j=0 jDonc on a bien Ip+1.Par récurrence, on montre donc que l’invariant est toujours vrai.

1 # -*- coding: utf-8 -*-2 """3 ROLE : Calculer la somme des n premiers entiers avec une instruction ’while’4 AUTEUR : Claude Monteil <[email protected]>5 VERSION : 1.0 - 04/20166 """7 # VARIABLES8 n = int() # valeur lue au clavier9 i = int() # index pour parcourir les entiers de 1 à n

10 somme = int() # somme des entiers de 0 à i11 #12 print ("Somme des n premiers entiers (avec tant que)")13 #1.Saisir la valeur de n (sans controle)14 n = int(input("Nombre d’entiers : "))15 #2.calculer la somme des n premiers entiers16 somme = 0 # initialisation de la somme a 017 i = 018 while i < n : # Invariant : somme = somme des i premiers entiers19 i = i + 120 somme = somme + i21 # ici, i=n ; donc, somme = somme des n premiers entiers22 #3.afficher la somme



23 print ("La somme est : ", somme)

Exercice 9 : Saisie contrôlée d’un numéro de moisOn souhaite réaliser la saisie du numéro d’un mois (compris entre 1 et 12) avec vérification. Leprincipe est que si la saisie est incorrecte, le programme affiche un message expliquant l’erreurde saisie et demande à l’utilisateur de resaisir la donnée.9.1 Utiliser un TantQue pour réaliser la saisie contrôlée.9.2 Généraliser l’algorithme au cas d’une saisie quelconque.Solution :

1 # -*- coding: utf-8 -*-2 """3 ROLE : Saisir le numero d’un mois avec controle ’TantQue’ (while)4 AUTEUR : Claude Monteil <[email protected]>5 VERSION : 1.0 - 04/20166 """7 # VARIABLE8 mois = int() # le numero du mois9 #

10 print ("Saisie contrôlée d’un numéro de mois (avec while)")11 #1.Saisir le numero de mois12 mois = int(input("Numero du mois : "))13 #2.Traiter les erreurs eventuelles14 while (mois < 1) or (mois > 12) : # tant que mois est incorrect, le ressaisir15 #2a.Signaler l’erreur de saisie16 print ("Donner un numero entre 1 et 12 !")17 #2b.Sasir un nouveau numero de mois18 mois = int(input("Numero du mois : "))19 #3.Afficher le numero saisi20 print ("Le numero du mois est donc :", mois)

9.3.2 Répétition Répéter ... JusquÀ

Cette forme de répétition n’existe pas en Python. On la remplace par un while (cf. l’exempleproposé).

Exercice 10 : Plusieurs sommes des n premiers entiersÉcrire un programme qui affiche la somme des n premiers entiers naturels, n étant un entier saisiau clavier. Le programme devra proposer la possibilité à l’utilisateur de recommencer le calculpour un autre entier.Solution : Le raffinage peut être décrit ainsi.

1 R0 : Afficher la somme des n premiers entiers avec possibilité de recommencer23 R1 : Raffinage De « R0 »4 | Répéter5 | | Afficher la somme des n premiers entiers6 | | Demander si l’utilisateur veut recommencer reponse: out7 | JusquÀ réponse est non



Le raffinage de « Afficher la somme des n premiers entiers » a déjà été donné dans un exerciceprécédent. On peut donc directement en déduire l’algorithme.

1 # -*- coding: utf-8 -*-2 """3 ROLE : Calculer la somme des n premiers entiers avec possibilité de recommencer4 (usage de 2 boucles imbriquées)5 AUTEUR : Claude Monteil <[email protected]>6 VERSION : 1.0 - 04/20167 """8 # VARIABLES9 reponse = str() # réponse de l’utilisateur

10 n = int() # valeur lue au clavier11 i = int() # index pour parcourir les entiers de 1 à n12 somme = int() # somme des entiers de 0 à i13 continuer = bool() # indicateur booléen valant True si on veut continuer14 #15 print ("Plusieurs sommes des n premiers entiers")16 continuer = True # a priori !17 while continuer : # effectuer un calcul de la somme des n premiers nombres18 #1.saisir la valeur de n (sans contrôle)19 n = int(input("Nombre d’entiers : "))20 #2.calculer la somme des n premiers entiers21 somme = 0 ; i = 0 #IMPORTANT : initialisation de i et de la somme à 0 !22 while (i < n) : # Invariant : somme = somme des entiers de 1 à i23 i = i + 124 somme = somme + i25 #3.afficher la somme26 print ("La somme est : ", somme)27 reponse = input("Encore(o/n) ? ")28 continuer = (reponse == "o") or (reponse == "O")

Exercice 11 : Saisie contrôlée d’un numéro de moisOn souhaite réaliser la saisie du numéro d’un mois (compris entre 1 et 12) avec vérification. Leprincipe est que si la saisie est incorrecte, le programme affiche un message expliquant l’erreurde saisie et demande à l’utilisateur de resaisir la donnée.

On utilisera un Répéter pour réaliser la saisie contrôlée.Généraliser l’algorithme au cas d’une saisie quelconque.

Solution :1 # -*- coding: utf-8 -*-2 """3 ROLE : Saisir le numero d’un mois avec controle ’JusquA’4 ’until’ n’existe pas en Python => usage de while avec un booléen5 AUTEUR : Claude Monteil <[email protected]>6 VERSION : 1.0 - 04/20167 """8 # VARIABLES9 mois = int() # le numero du mois

10 saisieIncorrecte = bool() # indicateur booléen valant True si on veut continuer11 #



12 print ("Saisie contrôlée d’un numéro de mois (avec équivalent de JusquA)")13 saisieIncorrecte = True # a priori !14 while saisieIncorrecte : # Saisir un mois et contrôler sa valeur15 #1.Saisir le numero de mois16 mois = int(input("Numero du mois : "))17 #2.Traiter les erreurs eventuelles18 if (mois < 1) or (mois > 12) : # Signaler l’erreur de saisie19 print ("Donner un numero entre 1 et 12 !")20 else : # basculer l’indicateur21 saisieIncorrecte = False # la saisie est correcte22 #3.Afficher le numero saisi23 print ("Le numero du mois est donc :", mois)

9.3.3 Répétition Pour

On utilise l’instruction for ... in associée à la fonction range qui précise la plage desvaleurs qui seront successivement utilisées dans la boucle, à l’exclusion de la dernière. Commepour un while, les instructions du corps de boucle sont décalées d’une tabulation par rapport aufor.

for n in range(1,4) :print("Passage numéro",n)

Le code ci-dessus provoquera les affichages suivants :Passage numéro 1Passage numéro 2Passage numéro 3

Par défaut, le pas entre chaque valeur vaut 1. On peut préciser une valeur différente dans range.for n in range(10,4,-2) :

print("Passage numéro",n)

Le code ci-dessus provoquera les affichages suivants :Passage numéro 10Passage numéro 8Passage numéro 6

Attention : La valeur finale indiquée dans le range n’est jamais exécutée : ainsi, pour traduireun Pour i <- 1 JusquÀ i = n Faire, il faut écrire for i in range(1,n+1) :. C’est une er-reur très fréquente en début d’apprentissage que de mettre n comme valeur finale du range et deconstater que cette valeur n’est pas exécutée ! De même, il ne faut pas oublier les deux-pointspour achever la ligne du for.

Exercice 12 : Somme des premiers entiersCalculer la somme des n premiers entiers.Solution :

1 # -*- coding: utf-8 -*-2 """3 ROLE : Calculer la somme des n premiers entiers



4 avec une repetition avec compteur (for)5 AUTEUR : Claude Monteil <[email protected]>6 VERSION : 1.0 - 04/20167 """8 # VARIABLES9 n = int() # valeur lue au clavier

10 i = int() # index pour parcourir les entiers de 1 a n11 somme = int() # somme des entiers de 0 a i12 #13 print ("Somme des n premiers entiers (avec for)")14 #1.saisir la valeur de n (sans controle)15 n = int(input("Nombre d’entiers : "))16 #2.calculer la somme des n premiers entiers17 somme = 018 for i in range(1,n+1) : # [ATTENTION : n+1 et non n car valeur finale EXCLUE]19 # Invariant : somme = somme de 1 à i20 somme = somme + i21 #3.afficher la somme22 print ("La somme est :", somme)

9.3.4 Quelle répétition choisir ?


Documents

Algorithmique et programmation : les bases (Python) Corrigécregut.perso.enseeiht.fr/ENS/2015-apad-algo1/algo1-apad...ALGORITHMIQUE ET PROGRAMMATION 1 Algorithmique et programmation