Les booléens sont un type de variables très courantes en informatique : ce sont des variables logiques qui ne peuvent prendre que deux valeurs : Vrai ou Faux (True , False).
Observez les retours pour chaque exécution des cellules suivantes, dans lesquelles on présente au passage tous les opérateurs de comparaison :
# infériorité ?
5 < 7
# supériorité ?
5 > 7
# inférieur ou égal ?
5 <= 7
# supérieur ou égal ?
5 >= 7
mligne# différence ?
5 != 7
# égalité ?
5 == 7
Remarquez en particulier l'expression pour tester l'égalité avec le double signe égal (pour ne pas le confondre avec l'opérateur d'affectation de valeur à une variable).
On peut directement affecter les valeurs True ou False à des variables :
a = True
b = False
c = 5 == 7 # rappel 5 == 7 vaut False (car 5 n'est pas égal à 7)
print(a, b, c)
De nombreux algorithmes proposent d'effectuer certaines tâches sous certaines conditions : un bloc de code ne sera exécuté que si une condition est remplie ; dans le cas où la condition ne serait pas remplie, l'algorithme pourra prendre une autre voie et exécuter un autre bloc de code.
Exemple 1 : si le temps est clément, je vais à la plage, sinon je vais au cinéma.
Exemple 2 : si le soleil brille, je vais à la plage, sinon si le temps est quand même correct, je vais faire un pique-nique, sinon (dans tous les autres cas), je vais au cinéma.
Python propose cette structure avec les mots clefs if ... elif ... else (elif est la contraction de else if).
À la fin de chacune de ces instructions, il y a un symbole deux points (:) et le bloc de code qui doit être exécuté si la condition est satisfaite doit être indenté.
Les conditions prennent la forme d'une variable booléenne qui en général est le résultat d'une test de comparaison (comme ceux vus dans la 1ere partie de ce notebook).
# voici une écriture en Python qui traduit l'exemple ci-dessus :
meteo = "soleil brille" # changez librement cette valeur pour faire des tests
if meteo == "soleil brille":
print("Je vais à la plage car le soleil brille.")
elif meteo == "temps correct":
print("Je vais faire un pique-nique car le soleil ne brille pas mais le temps est correct.")
else:
print("Le soleil ne brille pas et le temps n'est pas correct, alors je vais au cinéma !")
acces qui prend un nombre comme paramètre d'entrée (correspondant à un âge) et qui renvoie un code d'accès (0, 1, 2, ou 3) en fonction de l'âge :¶ - code 0 : accès aux majeurs uniquement
- code 1 : accès aux ados de 15 à 17 ans
- code 2 : accès aux enfants de 10 à 14 ans
- code 3 : accès à tous# à vous de jouer ci-dessous :
def acces(age):
if age >= 18:
return 0
elif age >= 15:
return 1
elif age >= 10:
return 2
else:
return 3
Si votre fonction est correctement écrite, vous devez pouvoir exécuter la cellule ci-dessous et ne voir aucun message d'erreur apparaître. Si vous avez commis une erreur, un message vous signalera la ligne qui pose un problème...
# cellule de tests (s'il n'apparait rien lors de son exécution, c'est bon signe !)
assert acces(20) == 0
assert acces(18) == 0
assert acces(17) == 1
assert acces(15) == 1
assert acces(12) == 2
assert acces(10) == 2
assert acces(8) == 3
Exemples :
>>> ecart(7, 5)
2
>>> ecart(5, 7)
2
>>> ecart(-7, 5)
12
>>> ecart(-7, -5)
2
>>> ecart(-5, 7)
12# à vous de jouer
def ecart(a, b):
dif = a - b
if dif < 0:
return -dif
else:
return dif
Vous pouvez exécuter la cellule suivante pour voir si votre fonction semble correcte :
# cellule pour faire des tests :
assert ecart(7, 5) == 2
assert ecart(5, 7) == 2
assert ecart(-7, 5) == 12
assert ecart(-7, -5) == 2
assert ecart(-5, 7) == 12
assert ecart(7, -5) == 12
assert ecart(-5, 5) == 10
assert ecart(5, 5) == 0
a = True
if a:
print("Tout va bien")
else:
print("Tout va mal !")
Les informaticiens ont horreur (à raison) de se répéter ! De ce point de vue, la paresse est bien perçue...
Les boucles permettent de répéter une action plusieurs fois. Les boucles non bornées répètent l'action (le bloc de code) tant qu'une condition reste satisfaite (on ne connaît pas à l'avance le nombre de fois que le bloc de code va se répéter, c'est en ce sens que la boucle est non bornée).
En Python, la condition à tester pour savoir si le bloc de code doit être répété est introduite par le mot clef while, et se termine par un deux-points.
Comme nous en avons maintenant l'habitude, le bloc de code à répéter doit être indenté.
Voyez l'exemple suivant qui multiplie un nombre par 2 tant que celui-ci reste inférieur à 150. On a ajouté un système pour compter les itérations (c'est à dire les passages dans le corps de la boucle).
n = 4 # définition de la valeur initiale du nombre
compteur = 1 # cette variable compteur permet de compter le nombre d'itérations de la boucle
while n < 150:
print("Itération n°", compteur, end=" ")
print("=> En entrant dans ce 'tour de boucle' n =", n)
n = 2 * n
compteur = compteur + 1 # on augmente la valeur du compteur pour comptabiliser cette itération
print("\nAprès avoir quitté la boucle, n =", n)
On a écrit une fonction mystere. Analyser le code de cette fonction et proposer un nom pertinent pour cette fonction.
def mystere(x, n):
"""
x est un nombre quelconque
n est un entier positif
"""
i = 0
total = 0
while i != n:
total = total + x
i = i + 1
return total
# vous pouvez utiliser cette cellule pour faire des appels à la fonction mystère :
mystere(-3.7, 2)
Écrire une fonction reste qui renvoie le reste r de la division euclidienne d'un nombre a par un nombre b.
Écrire une fonction quotient qui renvoie le quotient q de la division euclidienne d'un nombre a par un nombre b.
Dans les 2 cas, on cherchera à soustraire le nombre b du nombre a tant que le reste de cette soustraction est strictement positif.
Exemple : 17 = 5 x 3 + 2
reste(17, 5) vaut 2
quotient(17, 5) vaut 3# à vous de jouer
def reste(a, b):
while a >= b:
a = a - b
return a
def quotient(a, b):
n = 0
while a >= b:
a = a - b
n = n + 1
return n
print(quotient(17, 5), reste(17, 5))
# cellule de test des 2 fonctions reste et quotient
assert quotient(7968118, 16462) == 7968118 // 16462
assert reste(7968118, 16462) == 7968118 % 16462
Remarque : On peut regrouper ces 2 fonctions en une seule. En effet une fonction peut renvoyer 2 valeurs en une seule fois.
def division(a, b):
n = 0
while a >= b:
a = a - b
n = n + 1
return (n, a)
division(17, 5)
Si la condition de sortie de boucle n'est jamais satisfaite, alors la boucle ne s'arrête jamais !!!
Imaginez le programme suivant :
while True:
print("J'y suis, j'y reste !")
Les répétitions vont durer un moment... Une seule solution, mettre fin violemment au programme. Ceci peut se faire en cliquant dans le menu Kernel -> Interrupt (En Français : Noyau -> Interrompre).
# cellule idiote...
# exécutez la cellule et quand vous en avez marre (rapidement sans doute...),
# cliquez dans le menu Noyau et Interrompre.
while True:
print("J'y suis, j'y reste !")
Pourtant, vous rencontrerez ce genre d'écriture lors de l'étude des microcontrôleurs ! En effet si l'on veut qu'un programme soit continuellement "à l'écoute" d'une action de l'utilisateur, on écrit tout son code à l'interieur d'une telle boucle infinie.
Ce programme pourra par exemple réagir à des événements comme l'appui d'une touche sur le clavier ou un clic de souris... Cela s'appelle la programmation évènementielle. Ceci n'est pas du tout exceptionnel, le système d'exploitation de votre ordinateur est constamment à votre écoute et prêt à réagir à vos actions.
Il faudra cependant prévoir un événement particulier qui mettra fin au programme (le clic sur une croix par exemple).