Instructions
Dans ce chapitre, nous ajoutons trois instructions à la déclaration et à l’affectation : la séquence, l’instruction conditionnelle et les boucles. Ces quelques instructions, à elles seules, suffisent à exprimer tous les algorithmes.
1. Instructions
1.1. Notions d’algorithme et de programme
Un algorithme est une suite finie d’opérations et d’instructions permettant de résoudre un problème, écrite de façon suffisamment détaillée pour être suivie même par quelqu’un n’ayant pas participé à l’élaboration de l’algorithme.
On compare souvent les algorithmes à des recettes de cuisine. Cette comparaison est assez judicieuse dans le sens où il n’est pas nécessaire de comprendre pourquoi le four doit être à 180°C et pas à 250°C pour réussir la recette ; elle atteint cependant ses limites quand la recette demande des gestes techniques pour lesquels une expérience en cuisine est nécessaire.
Un algorithme a cette autre particularité qu’il permet en réalité de résoudre une classe de problèmes similaires, et non pas un problème unique. Ainsi, un algorithme d’addition comme celui que l’on apprend à l’école primaire sert à calculer la somme de n’importe quels nombres et pas seulement la somme de deux nombres fixés.
Les algorithmes ont existé bien avant les ordinateurs, pour réaliser des tâches purement matérielles comme pour résoudre des problèmes très calculatoires. Avec l’apparition des premiers ordinateurs, il est cependant devenu possible de faire exécuter un algorithme de façon beaucoup plus rapide et sûre.
Le prix à payer est de devoir traduire cet algorithme sous une forme lisible par la machine. Un programme est la traduction d’un algorithme dans le langage informatique. Il est constitué d’un assemblage d’instructions, regroupées dans un fichier texte appelé le code source du programme.
L’exécution du programme commence à la première instruction, puis en exécute d’autres en suivant des règles précises. Le parcours des instructions au cours de l’exécution est appelé le flot d’exécution.
1.2. Instructions
Dans le chapitre précédent, nous avons vu que l’ensemble des variables définies à un instant donné de l’exécution d’un programme constituait un état de l’exécution du programme. On a également vu qu’il existait une instruction servant à déclarer une variable (déclaration) ou à changer la valeur d’une variable existante (affectation).
Exemple :
x = 2 Ceci est la déclaration et l’initialisation de la variable x x = x + 1 Ceci est une nouvelle affectation de la variable x
De manière plus générale, on appelle instruction un ordre de modification de l’état courant de l’exécution d’un programme.
Les instructions peuvent être :
• soit des instructions simples : elles manipulent alors directement l’état courant. Ce sont les instructions de déclaration et d’affectation.
• soit des instructions composées.
Les instructions composées sont au nombre de trois :
• la séquence, qui exécute deux instructions l’une à la suite de l’autre
• l’instruction conditionnelle, qui sert à n’exécuter une instruction que dans certains états
• la boucle, qui exécute plusieurs fois la même instruction dans un programme.
1.3. Entrées / Sorties
Dans un langage de programmation, on appelle entrées/sorties les instructions qui interrompent le flot d’exécution du programme pour communiquer avec l’utilisateur, donnant ainsi un aspect interactif au programme.
Il existe deux instructions particulières permettant de communiquer avec l’utilisateur :
• l’instruction
input(), qui a pour effet d’interrompre le déroulement du programme, pour prendre comme valeur celle tapée par l’utilisateur au clavier
• l’instruction print, qui affiche à l’écran les expressions qui lui sont données en argument. Par défaut, print écrit les différentes expressions qui lui sont données en arguments sur la même ligne, séparées par des espaces, puis revient à la ligne.
Exemple :
print ‘Bonjour,’, ‘ comment allez-vous ?’
1.4. Séquence d’instructions
La manière la plus simple d’assembler deux instructions consiste à les placer l’une à la suite de l’autre. L’exécution du programme commence par la première instruction, puis passe à la seconde.
Exemple : a = 1 a = a+1 a = a*2
Dans cet exemple, après exécution de la deuxième instruction, on passe dans l’état a = 2, puis après la troisième dans l’état a = 4.
L’ordre dans lequel sont exécutées les instructions est ici primordial. Ainsi, si on inverse l’ordre des deux dernières instructions dans l’exemple précédent, après exécution de la première instruction, on passe dans l’état a = 2 puis après la seconde dans l’état a = 3.
Il est possible de considérer des séquences de plus de deux instructions. On parle alors plus généralement de bloc d’instructions.
1.5. Quelques règles de bonne programmation
Bien programmer, c'est d'abord réfléchir avant d'écrire.
Avant de saisir un programme sur l'ordinateur, il faut toujours, en s'armant d'un papier et d'un crayon :
• Analyser le problème à résoudre.
• Déterminer les variables nécessaires à sa résolution.
• Élaborer un premier schéma d'algorithme.
Un programme doit pouvoir être lu et relu. Pour faciliter cela, quelques règles s'imposent :
• Utiliser des noms de variables et de fonctions explicites.
• Commenter les différentes étapes du programme (avec le caractère # en début de commentaire).
• Documenter les fonctions (cf. chapitre 5).
Enfin, quelques règles de présentation sont à respecter (elles ne sont pas obligatoires mais d’usage) :
• Ne pas placer d'espace avant une virgule, un point-‐virgule ou un deux-‐points
• Placer un espace de chaque côté d'un opérateur (+, -, *, =, ==, !=, +=, ...)
• Passer une ligne vide pour délimiter les différentes fonctions et blocs d’instructions
• Ne pas placer d'espace entre le nom d'une fonction et sa liste d'arguments
2. Instructions conditionnelles
2.1. Test simple
Une instruction conditionnelle n’est exécutée que si une condition donnée est vérifiée par l’état courant.
Pour traduire cela, on utilise l’instruction if, qui a en Python la syntaxe suivante : if condition:
bloc d’instructions
Le bloc d’instructions est exécuté uniquement si la condition spécifiée dans condition est vérifiée.
Attention ! La syntaxe est très importante en Python. Ne pas oublier les : à la fin de la condition ni d’indenter le bloc d’instructions. Indenter signifie ajouter un même nombre d’espaces (4 en Python) devant chacune des lignes définissant les instructions. Cette indentation doit être effectuée à chaque ligne du bloc d’instructions. Au sein d’un bloc, le niveau l’indentation doit donc être le même.
Exemple 1 :
Dans l’exemple qui suit, on ajoute 1 à la variable x seulement si, dans l’état courant, elle a une valeur impaire. Au contraire, si x a une valeur paire, l’instruction d’ajout est ignorée :
if x %2 == 1:
x = x + 1 Exemple 2 :
Dans l’exemple qui suit, le bloc d’instruction ne sera exécuté que si la valeur de x est différente de 0 :
if x != 0:
y = 3 y = y/x
Lorsqu’on exécute un programme Python possédant une erreur d’indentation, un message d’erreur suivant apparaît comportant l’information IndentationError.
Vérifier alors bien l’indentation de vos différents blocs d’instructions.
La première instruction qui suit une instruction conditionnelle et qui est placée au même niveau d’indentation que l’instruction if marque la fin du bloc. En effet, seules les instructions indentées font partie du bloc. L’usage veut que l’on saute une ligne à la fin d’une instruction conditionnelle.
En cas de seconde boucle if au sein d’une première boucle if, le second bloc doit avoir un niveau d’indentation double (donc 2×4=8 espaces d’idnentation).
Exemple :
if x != 0:
y = x*x
if y%2 == 0:
y = y + 1 x = x + y
Dans cet exemple, l’instruction y = y+1 n’est exécutée que si les deux conditions à la fois sont vérifiées (il faut donc que x soit différent de 0 et que y soit pair).
L’instruction x = x + y est quant à elle exécutée uniquement si la première condition est vérifiée (à savoir x différent de 0) puisque n’ayant qu’un niveau d’indentation, elle n’appartient qu’à la première boucle conditionnelle.
2.2. Test avec alternative et tests imbriqués
• Test avec alternative
L’instruction conditionnelle est enrichie de la syntaxe else pour effectuer un bloc d’instructions si la condition évaluée est vérifiée et un bloc d’instructions différent si cette condition se révèle fausse. Ce bloc d’instructions ne fonctionne donc que dans le cas où la valeur à tester ne peut prendre que deux valeurs (pair ou impair, positif ou négatif, vrai ou faux,…).
On parle alors de test avec alternative, dont la syntaxe en Python est la suivante : if condition:
bloc d’instruction 1 else:
bloc d’instruction 2 Exemple :
if x%2 == 1:
x = x + 1 else:
x = x + 2
Dans cet exemple, on ajoute à x la valeur 1 si celui-‐ci est impair et la valeur 2 s’il est pair.
• Tests imbriqués
L’utilisation de la syntaxe d’un test avec alternative (if puis else) ne fonctionne que dans le cas où la condition à tester ne peut prendre que deux valeurs (comme dans l’exemple précédent, où x est soit pair soit impair).
Pourtant, on peut également être amené à considérer une condition qui peut prendre plus de deux valeurs. On utilise alors un test imbriqué, avec l’instruction elif (que l’on peut utiliser autant de fois que nécessaire), selon la syntaxe suivante :
if condition1:
bloc d’instructions 1 elif condition2:
bloc d’instructions 2 else:
bloc d’instructions 3
Exemple : calcul et interprétation de la valeur d’indice de masse corporelle (IMC) poids = int(input(‘Entrez votre poids en kg’)
taille = float(input(‘Entrez votre taille en m’)
IMC = poids/taille**2 if IMC < 18.5:
print ‘Maigreur’
elif IMC < 25:
print ‘Corpulence normale’
elif IMC < 30:
print ‘Surpoids’
else:
print ‘Obesite
Dans cet exemple, la boucle conditionnelle s’arrête dès qu’une des conditions est vérifiée. Ainsi, si l’IMC calculé est de 22, les deux derniers tests de la boucle ne seront pas effectués.
3. Boucles
3.1. Boucle conditionnelle
• Définition et syntaxe
Une boucle conditionnelle est une instruction qui exécute un bloc d’instructions tant que le test est vérifié. Le terme boucle fait référence au flot d’exécution. Celui-‐ci boucle autour des instructions à exécuter tant que la condition est vérifiée. Le bloc d’instructions au sein de la boucle est appelé le corps de boucle et chaque passage dans ce bloc est appelé une itération. Lorsqu’on effectue la première itération, on dit qu’on entre dans la boucle. On en sort lorsque l’on a fini d’exécuter la dernière itération.
En Python, la syntaxe d’une boucle conditionnelle est la suivante : while condition:
bloc d’instructions (corps de boucle)
Attention ! Les contraintes d’indentation pour le bloc d’instructions sont les mêmes que pour une instruction conditionnelle et la fin du bloc est marquée par le retour au niveau d’indentation du while.
Exemple : calcul de la somme des 10 premiers entiers n = 1
somme = 0 # on initialise la somme à 0
while n <= 10: # on réalise la somme tant que n est inférieur à 10 somme = somme+n # on ajoute à la somme l’entier n
n = n+1 # on incrémente n de 1 pour passer à l’entier suivant
• Problème des boucles infinies
Certaines boucles peuvent ne jamais s’arrêter car la condition d’arrêt n’est jamais vérifiée. On dit alors que l’exécution est dans une boucle infinie, c’est-‐à-‐dire une boucle dans laquelle il n’y a pas de possibilité de sortir.
Ce type d’erreur de conception du programme est indétectable par l’ordinateur (c’est-‐à-‐dire que cette erreur n’apparaîtra pas dans le débogueur) et assez fréquent
Le seul moyen de sortir d’une boucle infinie est d’interrompre volontairement l’exécution du programme en pressant simultanément les touches Ctrl et C.
3.2. Boucle inconditionnelle
On a pu voir dans la partie précédente que les boucles conditionnelles étaient nécessaires pour effectuer des calculs lorsqu’il n’est pas possible de borner le nombre d’étapes nécessaires. En pratique, dans de nombreux cas, on connaît à l’avance le nombre d’itérations qu’il faudra effectuer, ce qui rend inutile d’utiliser une boucle conditionnelle. On utilise alors une boucle inconditionnelle : la boucle for.
• Syntaxe
La syntaxe d’une boucle inconditionnelle est la suivante : for i in range(n):
bloc d’instructions
Le programme va alors effectuer le bloc d’instructions n fois. Dans cette boucle, le compteur de boucle (i) parcourt les entiers de 0 à n-1. Le paramètre de la fonction range est donc la valeur avant laquelle on s’arrête. Le compteur de boucle i est entièrement géré par la boucle for, c’est-‐à-‐dire qu’il n’est pas nécessaire de le déclarer, ni de l’incrémenter, ni de tester qu’il ne dépasse pas une certaine limite.
Si on veut que le compteur de boucle (i) ne commence par à 0, la syntaxe à utiliser est la suivante : for i in range(6,n):
bloc d’instructions
Dans cet exemple, le compteur de boucle (i) parcourt les entiers de 6 à n-1.
Exemple : calcul de la somme des 10 premiers entiers
somme = 0 # on initialise la somme à 0
for i in range(1,11): # on réalise les instructions pour n allant de 1 à 10 somme = somme+i # on ajoute à la somme l’entier n
print somme
• Boucles imbriquées
Quand l’instruction à exécuter à l’intérieur d’une boucle est elle aussi répétitive, le corps de cette boucle contient une seconde boucle et on dit qu’elles sont imbriquées. Les bornes de la boucle interne dépendent souvent du compteur de la boucle externe.
4. Pour s’entraîner
4.1. Recherche de maximum et de minimum
1) Ecrire un programme qui détermine le maximum entre trois nombres entiers choisis par l’utilisateur et affiche ce maximum à l’écran.
2) Ecrire un programme qui détermine le minimum entre trois nombres entiers choisis par l’utilisateur et affiche ce minimum à l’écran.
3) Ecrire un programme qui détermine à la fois le minimum et le maximum entre trois nombres entiers choisis par l’utilisateur et affiche ces deux informations à l’écran.
4.2. Utilisation de boucles conditionnelles et inconditionnelles
1) Ecrire un programme qui calcule 𝑘!, où 𝑘 et 𝑛 sont deux entiers naturels quelconques pouvant être choisis par l’utilisateur, et affiche la valeur à l’écran.
Remarque : On écrira deux programmes différents : un qui utilise une boucle conditionnelle et un qui utilise une boucle inconditionnelle.
2) Ecrire un programme qui teste si un nombre entier 𝑛, entré par l’utilisateur du programme, est premier ou pas.
3) Ecrire un programme qui calcule les 10 premiers termes de la suite de Fibonacci.
Rappel : la suite de Fibonacci est définie par :
𝑢! =𝑢!=1
𝑢!!!=𝑢!!!+𝑢! (∀𝑛≥2)
