Apprendre Python et s'initier à la programmation

Une seconde façon de construire des expressions booléennes consiste à en combiner plusieurs pour en construire une nouvelle, en utilisant des opérateurs logiques. Python propose trois opérateurs logiques repris à la figure 2.

Le premier opérateur logique permet d'inverser la valeur d'une expression booléenne. Appliquée à une expression booléenne qui vaut True, elle produit donc comme valeur False, et inversement :

a = not 8 > 2         # a vaut False

La valeur de l'expression 8 > 2 valant True, puisque kitxmlcodeinlinelatexdvp8finkitxmlcodeinlinelatexdvp est strictement plus grand que kitxmlcodeinlinelatexdvp2finkitxmlcodeinlinelatexdvp, la valeur de l'expression not 8 > 2 vaut donc False.

Les deux autres opérateurs logiques combinent deux expressions booléennes. Le résultat du « et » logique ne vaut True que si les deux expressions combinées valent True, et il vaut False sinon. Le résultat du « ou » logique vaut True si au moins une des deux expressions combinées vaut True, et il vaut False sinon.

La figure 3 résume les résultats de ces deux opérateurs, sous la forme d'un tableau appelé table de vérité. Une telle table fournit la valeur d'expressions booléennes composées pour toutes les combinaisons possibles des expressions booléennes sur base desquelles elles sont construites.

Voici deux exemples d'expressions booléennes complexes construites avec des opérateurs logiques :

a = 8 > 2 and 12 <= 4                # a vaut False
b = 5 != 5 or 'PY' == 'P' + 'Y'      # b vaut True

Dans la première expression, la valeur de l'expression à gauche de l'opérateur and est True puisque kitxmlcodeinlinelatexdvp8finkitxmlcodeinlinelatexdvp est strictement plus grand que kitxmlcodeinlinelatexdvp2finkitxmlcodeinlinelatexdvp, mais celle de l'expression à droite vaut False puisque kitxmlcodeinlinelatexdvp12finkitxmlcodeinlinelatexdvp n'est pas plus petit ou égal à kitxmlcodeinlinelatexdvp4finkitxmlcodeinlinelatexdvp. Dès lors, la variable a reçoit la valeur False puisque les deux expressions combinées par l'opérateur logique and ne valent pas toutes les deux True.

Pour la seconde expression, l'expression à gauche de l'opérateur or vaut False puisque kitxmlcodeinlinelatexdvp5finkitxmlcodeinlinelatexdvp n'est pas différent de kitxmlcodeinlinelatexdvp5finkitxmlcodeinlinelatexdvp, et celle de l'expression à droite vaut True puisque la chaine de caractères PY est bien égale à la concaténation des chaines P et Y. Puisqu'au moins une des deux expressions combinées par le or vaut True, la variable b vaut True.

III-A-1-a-i. Propriété de court-circuit▲

a = False and c       # a vaut False, peu importe la valeur de c
b = True or c         # b vaut True, peu importe la valeur de c

Tout comme les opérateurs arithmétiques vus précédemment, les opérateurs de comparaison et les opérateurs logiques possèdent un certain niveau de priorité. Ces opérateurs sont effectués après tout ceux qu'on a déjà rencontrés, dans l'ordre suivant :

• les quatre comparaisons : <, <=, > et >= ;
• les égalités : == et != ;
• le « non » logique : not ;
• le « et » logique : and ;
• le « ou » logique : or.

De nouveau, on peut utiliser les parenthèses pour rendre explicite l'ordre dans lequel vous souhaitez qu'une expression soit évaluée. La figure 4 montre quelques exemples d'expressions ainsi que l'expression complètement parenthésée équivalente.

Enfin, on peut enchainer les opérateurs de comparaison pour effectuer deux opérations de comparaison qui ont en commun une valeur. Prenons, par exemple, une variable x dont on voudrait savoir si sa valeur est comprise entre kitxmlcodeinlinelatexdvp0finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp20finkitxmlcodeinlinelatexdvp. Pour cela, on peut écrire :

check = 0 <= x <= 20

Ce que l'interpréteur va faire, c'est effectuer les comparaisons une à une, les combinant avec un « et » logique. L'instruction ci-dessus équivaut donc à l'expression suivante :

check = 0 <= x and x <= 20

Ce type d'enchainement d'opérateurs de comparaison peut se faire avec n'importe quel opérateur. On peut par exemple écrire l'expression suivante :

2 == x < 4

En plus d'un bloc de code qui n'est exécuté que si une condition est satisfaite, on peut également définir un second bloc qui ne sera exécuté que dans le cas contraire, c'est-à-dire si la condition n'est pas satisfaite. Une telle exécution alternative se déclare avec le mot réservé else.

Voici un exemple de programme qui utilise une instruction if-else :

grade = 9.5
if grade >= 10:
    print("vous avez réussi")
else:
    print("vous avez raté")

Le bloc if sera donc exécuté si la condition placée après le mot réservé if est satisfaite, et sinon, c'est le bloc else qui sera exécuté. Ensuite, le programme continue son exécution après l'instruction if-else. La figure 6 montre l'organigramme correspondant à ce programme.

Avec ce qu'on vient de voir, on peut donc définir une ou deux branches d'exécution différentes, en fonction de la valeur d'une condition. Comment pourrait-on faire si on désire plus de deux branches ?

Supposons que l'on souhaite écrire un programme qui contrôle la température de l'huile d'un moteur d'une voiture. Tant que celle-ci est sous les kitxmlcodeinlinelatexdvp100^\circfinkitxmlcodeinlinelatexdvpC, tout est normal, si elle est entre kitxmlcodeinlinelatexdvp100^\circfinkitxmlcodeinlinelatexdvpC et kitxmlcodeinlinelatexdvp130^\circfinkitxmlcodeinlinelatexdvpC, il faut émettre un avertissement et enfin si elle dépasse les kitxmlcodeinlinelatexdvp130^\circfinkitxmlcodeinlinelatexdvpC, il faut faire retentir une alarme de danger.

Pour cela, on va utiliser deux instructions if-else que l'on va imbriquer l'une dans l'autre. Ce qu'on va faire, c'est qu'on va utiliser comme contenu du bloc else de la première instruction if-else, une seconde instruction if-else :

temp = 126
if temp < 100:
    print("tout va bien")
else:
    if 100 <= temp <= 130:
        print("attention")
    else:
        print("danger")

La figure 7 montre l'organigramme de ce programme. Les deux instructions if-else y sont encadrées, ce qui fait bien ressortir qu'elles sont imbriquées l'une dans l'autre. La seconde a été imbriquée dans le bloc else, mais on aurait très bien pu la placer dans le bloc if si on voulait. La raison pour laquelle on ne l'a pas fait est que Python propose une écriture simplifiée lorsque l'imbrication se fait dans le bloc else.

Vous aurez remarqué que comme le contenu du bloc else est une instruction if-else, cette dernière doit être indentée. Par conséquent, les instructions des blocs if et else de cette dernière ont un niveau d'indentation double. Si on continue à ajouter d'autres branches, on va se retrouver avec des niveaux d'indentation trop grands. Pour éviter cela, Python propose l'instruction elif (contraction de else if) permettant une écriture simplifiée des instructions conditionnelles à plus de deux branches. L'exemple précédent se réécrit comme suit :

temp = 126
if temp < 100:
    print("tout va bien")
elif 100 <= temp <= 130:
    print("attention")
else:
    print("danger")

On est maintenant capable d'écrire un programme complet pour chercher les racines d'un trinôme du second degré, dont le code se trouve au listing suivant. Faites attention aux commentaires qui ont été utilisés, ainsi qu'à la mise en page globale du code.

# Programme de recherche des racines d'un trinôme
# du second degré de la forme ax^2 + bx + c
# Auteur : Sébastien Combéfis
# Version : 7 aout 2015

from math import sqrt

print("Recherche des racines de ax^2 + bx + c")
a = int(input("Coefficient a : "))
b = int(input("Coefficient b : "))
c = int(input("Coefficient c : "))

# Calcul du discriminant
delta = b**2 - 4 * a * c
print("Discriminant :", delta)

# Test des trois cas possibles et affichage des racines du trinôme
if delta < 0:
    print("Pas de racine réelle")
elif delta == 0:
    x = -b / (2 * a)
    print("Une racine réelle double :", x)
else:
    x1 = (-b - sqrt(delta)) / (2 * a)
    x2 = (-b + sqrt(delta)) / (2 * a)
    print("Deux racines réelles distinctes:", x1, "et", x2)

Une boucle se termine de manière naturelle lorsque sa condition devient fausse. Parfois, on peut vouloir la quitter prématurément, lorsqu'une autre condition est satisfaite. Python propose pour cela l'instruction break qui quitte directement une boucle, sans exécuter l'éventuel bloc else attaché à l'instruction while.

L'exemple suivant recherche le plus petit naturel non nul divisible par kitxmlcodeinlinelatexdvp38finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp46finkitxmlcodeinlinelatexdvp. Pour cela, on utilise une boucle qui parcoure toutes les valeurs entre kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp1000000finkitxmlcodeinlinelatexdvp et, pour chacune d'elles, teste avec une instruction if si elle divise kitxmlcodeinlinelatexdvp38finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp46finkitxmlcodeinlinelatexdvp grâce à l'opérateur modulo (le reste de la division est nul si c'est un diviseur). Dans ce cas, on a trouvé la valeur que l'on cherche et on peut arrêter la boucle, grâce à l'instruction break :

n = 1
while n <= 1000000:
    if n % 38 == 0 and n % 46 == 0:
        break
    n += 1
print(n, "est le plus petit nombre divisible par 38 et 46")

La figure 10 montre l'organigramme de ce programme, où vous pouvez clairement voir les deux chemins d'exécution possibles quittant la boucle. On voit également très bien que l'instruction break« casse » la boucle.

De manière générale, on peut se passer de l'instruction break en adaptant la condition de la boucle while. Au plus vous aurez de chemins d'exécution possibles, au plus votre code deviendra complexe à comprendre. Prenons, par exemple, la situation où votre boucle ne se termine pas quand elle le devrait. Afin de trouver le bug, il vous faudra examiner tous les chemins de sortie possibles, et il vaut donc mieux minimiser leur nombre. L'exemple précédent peut, par exemple, se réécrire comme suit, en intégrant la condition du if dans celle du while :

n = 1
while n <= 1000000 and not (n % 38 == 0 and n % 46 == 0):
    n += 1
print(n, "est le plus petit nombre divisible par 38 et 46")

Néanmoins, vous constaterez qu'on perd en lisibilité, la condition du while devenant complexe. Si l'on s'en réfère aux conventions, un code pythonique doit être concis et clair. Dans ce cas, la version du code avec l'instruction break est préférable.

Pour être complet, il faut également mentionner l'instruction continue. Celle-ci va faire en sorte d'interrompre l'exécution du corps de la boucle, et directement retourner à l'évaluation de la condition du while. Elle permet en quelque sorte de « passer un tour » de boucle. De nouveau, il est possible de s'en passer en modifiant le corps de la boucle. L'exemple suivant affiche tous les nombres pairs plus petits que kitxmlcodeinlinelatexdvp100finkitxmlcodeinlinelatexdvp :

n = 0
while n <= 100:
    n += 1
    if n % 2 != 0:
        continue
    print(n)

La première instruction augmente la valeur de la variable n. Ensuite, si celle-ci est impaire (le reste de la division par deux n'est pas nul), on arrête d'exécuter le corps de la boucle et on passe directement au tour suivant. Sinon, on affiche la valeur de n.