Maintenant, nous savons quelques bases pour faire des petits programmes: on sait comment faire des opérations sur les données et comment communiquer avec l'utilisateur. Mais des fois, le programme va devoir faire des choix, comme faire un calcul dans un certain cas seulement, ou lorsqu'on veut qu'il indique si un nombre est au-dessus ou en-dessous d'une limite...
Pour cela, nous allons utiliser des conditions, qui vont permettre au programme d'effectuer des actions selon un test.
Prenons le cas le plus simple des conditions.
Imaginons que nous voulons faire un programme qui vérifie le chargement de camions. En effet, on ne doit pas charger avec plus de 1 tonne (1 000kg) un camion, car il est sinon en surcharge. Si la masse chargée est inférieure à 1 tonne, notre programme n'a donc rien à signaler. Par contre, si cela dépasse la limite, on doit afficher "Surcharge !!!" pour prévenir.
Pour programmer une telle condition en Python, on utilise cette écriture:
if test:
#Faire quelque chose
if permet donc d'effectuer une série d'actions si et seulement si un test est vrai. Remarquez bien que nous devons ajouter quatre espaces avant chaque actions à faire, pour bien indiquer que l'action ne se fait que si la condition est vrai, et la différencier d'une action "classique". Ainsi, dans le cas de nos camions, voici un programme qui fonctionne:
masse = float(input("Quelle est la masse du chargement ? "))
if masse > 1000.0:
print("Surcharge !!!")
Dans ce programme, nous demandons déjà un nombre, la masse chargée dans le camion, et nous mettons la valeur dans la variable masse. Ensuite, nous testons si la masse est plus grande que 1000kg. Si oui, alors on affiche "Surcharge !!!". C'est un programme plutôt simple !
Remarquez que j'ai mis ici une seule action dans la condition, mais que je pouvais en mettre autant que je veux. Il faut juste appliquer cette règle: on décale de quatre espaces tout ce qui est dans la condition. Sinon, l'interpréteur ne saura pas qu'il doit vérifier le test avant d'exécuter l'instruction. En réalité, l'interpréteur peut se contenter de tout nombre d'espaces, mais la convention demande quatre espaces, car c'est bien plus propre ! Respectez donc bien ceci.
Voici par exemple un programme qui dit "Surcharge !!!", mais aussi "Enlevez des choses du camion !!!":
masse = float(input("Quelle est la masse du chargement ? "))
if masse > 1000.0:
print("Surcharge !!!")
print("Enlevez des choses du camion !!!")
C'est bien beau, mais quels tests pouvons-nous faire ? Tout d'abord, nous pouvons comparer deux données entre elles. Par exemple, voir si elles ont la même valeur ou pas. Pour cela, il existe une liste d'opérations de comparaison :
a == b #Egalité
a != b #Inégalité
a < b #Plus petit que
a > b #Plus grand que
a <= b #Inférieur ou égal à
a >= b #Supérieur ou égal à
Parce que le signe = est déjà utilisée pour autre chose: il permet de donner une valeur à une variable. Or, nous n'avons pas à modifier une variable ici: nous devons prendre la première valeur, puis la deuxième et voir si elles sont égales. En faisant Python, les programmeurs ont donc dû utiliser deux symboles différents pour différencier les deux usages. Dans d'autres langages, comme OCaml, l'affectation de variable s'écrit := et non pas =, mais ce n'est au final pas très important.
Confondre les deux signes est une erreur courante de débutant, donc attention.
Nous avons vu le cas où l'on ne propose pas que de faire une action si un test est vrai, mais aussi une alternative.
Maintenant, jetons les camions par la fenêtre (faites attention, c'est lourd !) et imaginons un programme qui donne le prix d'entrée d'un musée (Quoi ? C'est bien les musées !). Pour cela, on n'a besoin que de l'âge de la personne. Si cette personne a moins de 13 ans, alors le ticket est gratuit. Sinon, le ticket coûte 3.50€. Nous n'avons plus à seulement écrire un message si l'enfant a moins de 13 ans, mais aussi à écrire un message dans le cas contraire !
Pour cela, on utilise l'écriture suivante:
if test:
#Actions
else:
#Alternatives
Les actions alternatives s'écrivent après le mot else, en utilisant encore une fois l'indentation de quatre espaces. Dans le cas du musée, cela donne ce programme:
age = int(input("Quel est ton âge ? "))
if age < 13:
print("Ce sera gratuit pour toi, bonne chance !") #Bon rapport au client
else:
print("3 euros 50, s'il vous plait !")
Je ne crois pas avoir à le redire, mais on peut écrire plusieurs actions dans les conditions. Pour cela, il suffit d'indenter de quatre espaces, comme dans le cas d'une condition "si..." simple. Quoi, je l'ai redit ?
Maintenant, passons encore à un degré au-dessus: et si nous avons besoin de faire plusieurs tests ?
Reprenons le musée (c'est difficile à jeter): maintenant, si la personne a moins de 13 ans, le ticket est gratuit, mais sinon, si elle a moins de 18 ans, le ticket coûte 2.00€. Dans les autres cas, cela coûte toujours 3.50€.
Maintenant, on n'a plus à faire un seul test: en effet, si la personne a plus de 13 ans, on doit vérifier si elle a moins de 18 ans ! Une manière de faire pour résoudre le problème serait de mettre une condition dans une condition: on fait un test si le deuxième est faux. Voici un code possible:
age = int(input("Quel est ton âge ?"))
if age < 13:
print("Ce sera gratuit pour toi, bonne chance !")
else:
if age < 18:
print("2 euros, s'il vous plait !")
else:
print("3.50 euros, s'il vous plait !")
Vous voyez bien que nous faisons une condition si le premier est faux. Pour mettre la deuxième condition dans la première, on respecte la règle et on indente de trois espaces toute la deuxième condition.
Ce programme est correcte, mais il est... un peu lourd. On utilise deux conditions et on a besoin d'indenter deux fois ! Et imaginez si on dit que le prix pour les personnes de plus de 50 ans est de 3.00€ ! Pour faire face à cela, Python nous permet une autre écriture plus simple pour notre problème. Voici un programme plus simple:
age = int(input("Quel est ton âge ?"))
if age < 13:
print("Ce sera gratuit pour toi, bonne chance !")
elif age < 18:
print("2 euros, s'il vous plait !")
else:
print("3.50 euros, s'il vous plait !")
Regardons de plus près. Tout d'abord, on demande l'âge, puis on teste si age < 13, comme avant. Si c'est faux, alors on teste si age < 18. La différence est que nous n'avons pas mis cette condition dans un else, mais qu'on l'a écrit après elif (qui est une abréviation de else if). Enfin, si le deuxième test est faux, on passe à else.
C'est beaucoup plus lisible que notre premier programme ! Et puis, deuxième avantage: on peut mettre autant de elif que besoin entre if et else ! Utiliser cette méthode est bien meilleure que la première ! Cependant, gardez en tête la première écriture: plus tard, nous allons voir d'autres structures qui ont besoin d'une indentation et savoir que l'ont peut mettre des if dans d'autres if va être intéressant pour la suite.
Maintenant que nous avons vu les conditions, nous pouvons parler plus précisément des tests en eux-mêmes. Qu'est-ce qu'un test en lui-même ? Comment Python permet de les utiliser dans des conditions ?
En fait, un test est une opération qui va donner en retour soit la valeur True ("vrai" en anglais), soit la valeur False ("faux"). Ces valeurs sont en fait les deux valeurs possibles d'un nouveau type que l'on va utiliser, les booléens. Les booléens sont tout simplement des types de données, comme int ou str, mais qui ne peuvent valoir que True ou False. On les utilise notamment pour les conditions, car les "tests" dont je parle depuis tout à l'heure sont en fait des opérations qui donnent des booléens. Dans un test, en réalité, si la valeur redonnée est True, alors Python considère le test comme vrai, logiquement.
On peut aussi combiner les tests: il existe des opérations qui prennent des booléens et renvoie un booléen. En voici la liste:
a and b #Renvoie "True" seulement si a et b valent "True"
a or b #Renvoie "True" seulement si a ou b valent "True"
not a #Renvoie l'inverse de a (False si a vaut True et True si a vaut False)
Ces opérateurs peuvent être utilisés pour écrire des tests plus compliqué. Par exemple, pour tester si 4 < x < 10, on peut utiliser and dans ce programme:
x = int(input())
if (4 < x) and (x < 10):
print("x est entre 4 et 10")
else:
print("x n'est pas entre 4 et 10.")
Dernière chose: comme les booléens sont un type de données, on peut mettre un booléen dans une variable, puis modifier la variable ou reprendre sa valeur. Cette possibilité ne semble pas très importante à première vue, mais on peut l'utiliser pour clarifier notre code. Par exemple, si un test est long à écrire, on utilise des fois les variables pour découper notre test en sous-tests. Imaginons que nous vérifier si un nombre est entre 0 et 10 et pair. On peut écrire ceci:
x = int(input())
bonne_intervalle = ((0 <= x) and (x <= 10))
est_pair = ((x % 2) == 0)
if bonne_intervalle and est_pair:
print("Ok !")
else:
print("Pas bon !")
On peut donc se servir des booléens comme d'une entité en elle-même et s'en servir dans nos programmes. Même si ils sont en réalité assez peu utilisés, pensez toujours que si vous devez tester des conditions assez complexes, vous pouvez toujours les manipuler. Ils peuvent en effet être aussi bien manipulés que les autre types de données et méritent leur place dans des programmes.
Les conditions permettent d'exécuter des instructions que si un test est vérifié.
Pour faire une suite d'action si un test est vérifié, on écrit ceci:
if test:
#Actions
Si jamais on veut proposer une alternative si le test est faux, on écrit cela:
if test:
#Actions
else:
#Alternative
Enfin, si l'on veut faire plusieurs tests alternatifs, on utilise cette syntaxe:
if test:
#Actions
elif autre_test:
#Alternative
elif troisieme_test:
#Alternative
... #On peut mettre autant de elif que nécessaire
else:
#Actions par défaut
Les "tests" sont en fait des expressions qui renvoient des booléens, qui sont un type de donnée pouvant simplement valoir True (vrai) ou False (faux). Nous pouvons entre autres utiliser des opérations de comparaison de cette liste:
a == b #Egalité
a != b #Inégalité
a < b #Plus petit que
a > b #Plus grand que
a <= b #Inférieur ou égal à
a >= b #Supérieur ou égal à
Les booléens ont aussi leurs opérateurs, les opérateurs booléens:
a and b #Renvoie "True" seulement si a et b valent "True"
a or b #Renvoie "True" seulement si a ou b valent "True"
not a #Renvoie l'inverse de a (False si a vaut True et True si a vaut False)
Ils peuvent aussi être mis dans des variables et donc manipulés comme toute valeur qui se respecte. On peut ainsi simplifier un code avec. Ils ne sont par contre pas aussi utilisés que les autres types.