NSI Première
NSI Première
Voila le moment de prendre des décisions !
En effet, suivant la valeur que prend telle ou telle variable, il est souvent nécessaire de faire exécuter au programme une suite différente d'instructions ...
D'où la nécessité de disposer d'instructions de test pour "aiguiller" le programme...
En Python, comme dans de très nombreux langages, un test se fait avec l'instruction if ( ='si' ).
if (condition) :
Instruction 1
Instruction 2
....
...qui peut se traduire par :
"SI la condition est VRAIE,
alors exécuter les instructions 1, 2,..."
if (condition) :
Instruction 1
Instruction 2
....
else :
Instruction 3
Instruction 4
....
...qui peut se traduire par :
"SI la condition est VRAIE,
alors exécuter le bloc d'instructions 1, 2,...
SINON, dans les autres cas ( donc, si la condition est fausse ),
exécuter le bloc d'instructions 3, 4,..."
if (condition A) :
Instruction 1
Instruction 2
....
elif (condition B) :
Instruction 3
Instruction 4
....
else :
Instruction 5
Instruction 6
....
...qui peut se traduire par :
"SI la condition A est VRAIE,
alors exécuter le bloc d'instructions 1, 2,...
SINON SI la condition B est VRAIE,
alors exécuter le bloc d'instructions 3, 4,...
SINON, dans tous les autres cas ( donc, si aucune des conditions précédentes n'est vraie ),
exécuter le bloc d'instructions 5, 6,..."
La (ou les) instruction(s) à exécuter selon la situation sont regroupées dans un même bloc logique.
Elles sont donc toutes indentées d'un retrait par rapport à l'instruction "parente" ( ici, les instructions if, elif ou else ) pour indiquer à Python qu'il s'agit du même bloc logique.
Plusieurs blocs elif ( = "else if" ) peuvent être placés les uns à la suite des autres, voire même imbriqués les uns dans les autres.
On peut ainsi écrire de très complexes tests en "imbriquant" plusieurs évaluations de condition, qui s'excluent mutuellement : le programme les évalue les unes après les autres, et dès qu'il en trouve une de vraie, exécute son bloc d'instructions et passe toutes les suivantes...
La condition est une expression booléenne plus ou moins complexe, à évaluer à l'aide d'opérateurs de comparaison, vus au chapitre précédent :
| Opérateur | Signification | Commentaire |
|---|---|---|
== |
égal à | ATTENTION : il s'agit bien d'un DOUBLE SIGNE ÉGAL... C'est une erreur classique de ne mettre qu'un seul égal, qui est l'instruction d'affectation ( qui est donc, elle, toujours vraie !!! ) |
!= |
différent de | |
> |
supérieur à | |
< |
inférieur à | |
>= |
supérieur ou égal à | |
<= |
inférieur ou égal à | |
in |
présent dans | C'est l'opérateur qui permet de tester l'appartenance d'un élément à un autre, par exemple un caractère particulier dans une chaîne, un élément dans un fichier ou une liste,...de manière générale, un élément dans une structure itérable. |
not in |
pas présent dans | C'est l'opérateur inverse, celui qui permet de tester l'absence d'un élément dans une structure itérable. |
Exemples :
if ( moyenne == 10 ) :
if ( nombreEleve > 35 ) :
if ( numero != 12 ) :
if ( 'a' in mot ) :
L'expression booléenne peut être plus complexe, permettant d'évaluer plusieurs conditions en même temps, en utilisant les opérateurs and ( ET ) et or ( OU ).
Exemples :
if ( valeur1 > 2 ) or ( valeur2 != 10 ) :
"si valeur1 est supérieure à 2 OU valeur2 est différente de 10,....."
if ( monAge >=18) and ( monAge <=65 ) :
"si monAge est supérieure ou égale à 18 ET inférieure ou égale à 65"
if stock <= 10 :
reponse = "Stock faible !"
if ( moyenne >= 10 ) and ( exclus != 0 ) :
reponse = "Elève admis."
if (score <= 100 ) :
reponse = "Petit joueur !"
elif ( score > 100 ) and (score < 200 ) :
reponse = "Pas mal..."
else :
reponse = "Champion !"
if nombre1 > nombre2 :
difference = nombre1 – nombre2
test = 1
elif nombre1 < nombre2 :
difference = nombre2 – nombre1
test = 0
elif nombre2 == nombre1 :
difference = 0
Non : il n'y a que deux possibilités pour la condition ( nombre1 > nombre2 ou nombre1 < nombre2 ), tous les autres cas correspondant à nombre1 = nombre2.
La troisième évaluation n'est donc pas nécessaire, et peut être remplacée par un simple else :
if nombre1 > nombre2 :
difference = nombre1 – nombre2
test = 1
elif nombre1 < nombre2 :
difference = nombre2 – nombre1
test = 0
else :
difference = 0
if nombre != 0 :
if nombre < 256 :
print("Valeur trop petite !")
elif nombre > 256 :
print("Valeur trop grande!")
else :
print('Parfait!')
else :
print('Tricheur!')
Bien observer l'indentation : il y a deux blocs logiques d'instructions, dont l'un est imbriqué dans l'autre.
Cet ensemble fonctionne ainsi :
Que s'affiche-t-il à la fin de l'exécution de chacun des scripts suivants ?
Pour chacune des fonctions écrites, tester leur fonctionnement en écrivant une ou plusieurs instructions d'appel avec des arguments différents.
Écrire une fonction plus_petite() qui demande de saisir 2 valeurs et qui renvoie la plus petite des 2 valeurs.
Écrire une fonction plus_longue() qui :
L'indice de masse corporelle (IMC) est une mesure basée sur deux données : la taille et le poids corporel.
La formule standard s’applique aux hommes et aux femmes d’âge adulte. La formule est simple : IMC = poids (kg) divisé par la taille (m) au carré.
Voici les différentes catégories d’IMC établies par les organismes officiels de santé:
calcul_imc() qui :
calcul_imc() avec ces argumentsÉcrire une fonction compte_caractere() qui :
Une exemple de ( long ) texte est donné dans la variable long_texte dans l'éditeur Python ci-dessous.
Ce type de traitement fait partie des calculs par accumulation, où on utilise une variable auxiliaire ( l'accumulateur ) que l'on incrémente à chaque fois que le caractère recherché est trouvé dans le texte.
On rappelle qu'une année est bissextile si elle comporte 366 jours et pas 365. Le jour supplémentaire éventuel est le 28 février.
Les années bissextiles sont :
Écrire une fonction qui prend comme paramètre une année, et qui renvoie un booléen True si celle-ci est ( ou était/sera ) bissextile, False sinon.
Pour tester le programme : 1900 n'était pas une année bissextile, 2000 et 2016 l'étaient. Et cette année ?
True ou False, réécrire la fonction en une seule
ligne !Il existe un algorithme qui permet de déterminer le jour de la semaine correspondant à une date donnée sous la forme : jour, mois , année entre le 1er janvier 1800 et le 31 décembre 2099.
Bien qu'apparemment complexe, il s'agit d'une simple suite d'évaluation de conditions sur les chiffres de cette date :
siecle ← les deux premiers chiffres de l'année
an ← les deux derniers chiffres de l'année
mois ← le mois
jour ← le jour
annee ← l'année
valeur ← an + quotient de la division entière de an par 4
si siecle vaut 18, rajouter 2 à valeur
sinon si siecle vaut 20, rajouter 6 à valeur.
si le mois est janvier et que l'année n'est pas bissextile, ajouter 1 à valeur
si le mois est février,
alors
si l'année est bissextile, ajouter 3 à valeur,
sinon ajouter 4 à valeur
si le mois est mars ou novembre, ajouter 4 à valeur
sinon si le mois est mai, ajouter 2 à valeur
sinon si le mois est juin, ajouter 5 à valeur
sinon si le mois est août, ajouter 3 à valeur
sinon si le mois est octobre, ajouter 1 à valeur
sinon si le mois est septembre ou décembre, ajouter 6 à valeur
( Noter qu'on n'ajoute rien à valeur pour avril et juillet...)
valeur = reste de la division entière de ( valeur + jour ) par 7
si valeur est égale à 1, le jour de cette date est dimanche
sinon si valeur est égale à 2, le jour de cette date est lundi
sinon si valeur est égale à 3, le jour de cette date est mardi
sinon si valeur est égale à 4, le jour de cette date est mercredi
sinon si valeur est égale à 5, le jour de cette date est jeudi
sinon si valeur est égale à 6, le jour de cette date est vendredi
sinon si valeur est égale à 0, le jour de cette date est samedi
Écrire une fonction jour_date() qui prend comme paramètres une date sous la forme requise par le programme ( siècle, an, mois et jour ), qui applique l'algorithme pour trouver le jour de la semaine
correspondant à cette date, et qui renvoie cette information.
Dans l'algorithme ci-dessus, on voit qu'il faut déterminer si l'année considérée est bissextile : pour cela, vous n'allez bien entendu pas réécrire le code de l'exercice précédent, mais
utiliser directement la fonction est_bissextile() : en effet, on peut très bien appeler une fonction à l'intérieur de la définition d'une autre.
Dans votre script, vous aurez donc deux fonctions, et le programme principal.
Cette façon de faire apporte de la modularité à un programme, en attribuant une fonction à chaque tache particulière à réaliser, plutôt que de tout faire dans une seule ( et énorme ! ) fonction, dont le code devient dès lors très compliqué à lire et très difficile à corriger !