375 lines
9.7 KiB
Markdown
375 lines
9.7 KiB
Markdown
# TD - Les instructions conditionnelles
|
||
|
||
> « _Si j'aurais su, j'aurais pas venu_ », réplique du Petit Gibus dans le film "La Guerre des boutons" d'Yves Robert.
|
||
|
||
## 1. Définition
|
||
|
||
> Une __instruction conditionnelle__ permet de faire des choix en fonction de la valeur d’une __condition__. On parle souvent d’une instruction _si-alors_, ou _if-else_ en anglais.
|
||
|
||
En reprenant (et corrigeant) la citation du Petit Gibus, l'instruction conditionnelle devient « _Si j'avais su alors je ne serais pas venu_ ».
|
||
|
||
> Une __condition__ est une instruction qui est soit vraie, soit fausse. On parle alors d’une _instruction booléenne_ ou _variable booléenne_.
|
||
|
||
Par exemple, si une variable `note_francais` vaut 5 et qu’une variable `note_anglais` vaut 10 alors la condition `note_francais < note_anglais` est une condition qui est vraie, tandis que les conditions `note_francais > note_anglais` et `note_francais == note_anglais` sont fausses.
|
||
|
||
## 2. Comparaisons de variables
|
||
|
||
Les opérateurs de comparaisons sont :
|
||
|
||
- `<` : inférieur
|
||
- `<=` : inférieur ou égal
|
||
- `>` : supérieur
|
||
- `>=` : supérieur ou égal
|
||
- `==` : est égal à
|
||
- `!=` : est différent de
|
||
|
||
Le résultat d'une comparaison est toujours un booléen
|
||
|
||
- `True` si la comparaison est vraie
|
||
- `False` si la comparaison est fausse
|
||
|
||
Remarque : on ne peut comparer que des objets comparables
|
||
|
||
⚠ ___ATTENTION___ : le test d'égalité entre deux variables se fait avec un double égal `==` (car le simple `=` permet d'affecter une valeur à une variable, cf. Activité 1).
|
||
|
||
### 2.1 À faire
|
||
|
||
1. Déterminer (sans les exécuter) chaque instruction ci-dessous :
|
||
|
||
```python
|
||
>>> a = 5
|
||
>>> b = 18
|
||
>>> c = 12.3
|
||
>>> mot1 = "Hello"
|
||
>>> mot2 = "World"
|
||
#
|
||
>>> print(a > b)
|
||
#
|
||
>>> print(b // a == 3)
|
||
#
|
||
>>> print(b % a == 3)
|
||
#
|
||
>>> print(a - b > 2)
|
||
#
|
||
>>> print(type(c) == float)
|
||
#
|
||
>>> print(mot1 != mot2)
|
||
#
|
||
>>> print(mot1 < mot2)
|
||
#
|
||
>>> print(mot1 > 2)
|
||
```
|
||
|
||
2. Vérifier les résultats attendus avec les résultats constatés
|
||
|
||
Dans une suite d'instructions on est souvent amené à faire des choix.
|
||
|
||
## 3. Cas : Si...Alors
|
||
|
||
**Si** une ou plusieurs conditions sont réalisées **Alors** on exécute une ou plusieurs instructions
|
||
|
||
La structure en Python : On __indente__ (une tabulation) les instructions qui doivent s'exécuter si la condition est vérifiée
|
||
|
||
```
|
||
if condition :
|
||
instruction1
|
||
instruction2
|
||
```
|
||
|
||
Exemple qui affiche si les variables `a` et `b` sont des entiers pairs
|
||
|
||
```python
|
||
a = 12
|
||
if a % 2 == 0:
|
||
print(a, " est un entier pair")
|
||
|
||
b = 13
|
||
if b % 2 == 0:
|
||
print(b," est un entier pair")
|
||
```
|
||
|
||
## 4. Cas : Si ...Alors...Sinon
|
||
|
||
Dans cette structure, si la ou les conditions sont vraies, les instructions 1 et 2 sont exécutées. Sinon c'est l'instruction3 qui est exécutée.
|
||
|
||
```
|
||
if condition:
|
||
instruction1
|
||
instruction2
|
||
else:
|
||
instruction3
|
||
```
|
||
|
||
Exemple :
|
||
|
||
```python
|
||
a = 12
|
||
|
||
if a % 2 == 0:
|
||
print(a, " est un entier pair")
|
||
else:
|
||
print(a," est un entier impair")
|
||
```
|
||
|
||
## 5. Cas : Si...Alors...Sinon Si
|
||
|
||
Dans cette structure on teste plusieurs conditions
|
||
|
||
```
|
||
if condition1:
|
||
instruction1
|
||
elif condition2:
|
||
instruction2
|
||
instruction3
|
||
elif condition3:
|
||
instruction4
|
||
else:
|
||
instruction5
|
||
```
|
||
|
||
Exemple :
|
||
|
||
Imaginons les conditions de passage d'un piéton en fonction du feu de signalisation et du nombre de voitures passantes :
|
||
|
||
```python
|
||
if feu == 'VERT':
|
||
print('Piéton, vous pouvez passer')
|
||
elif voitures == 0: # le feu est rouge
|
||
print('Piéton, vous pouvez passer mais attention')
|
||
else: # le feu est rouge et il y a des voitures
|
||
print('Piéton, vous ne pouvez passer')
|
||
```
|
||
|
||
### À Faire
|
||
|
||
Soit l'algorithme qui détermine la réponse de Yoda en fonction de la taille qui lui est communiquée :
|
||
|
||
```txt
|
||
Demander la taille
|
||
Si la taille est supérieure à 1m80 alors
|
||
la réponse est 'Maître, vous vous prenez pour Chewbacca'
|
||
Sinon si la taille est supérieure à 1m20 alors
|
||
la réponse est 'Maitre, vous vous prenez pour Luc Skywalker'
|
||
Sinon si la taille est supérieure à 0.80m alors
|
||
la réponse est "Maitre, ce n'est pas la taille qui compte"
|
||
Sinon la réponse est 'Maitre, vous vous sous-estimez'
|
||
```
|
||
|
||
Compléter le code suivant pour qu'il implante l'algorithme ci-dessus :
|
||
|
||
```python
|
||
taille = input('Combien mesures-tu ?')
|
||
...
|
||
print(reponse)
|
||
```
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
## Exercices
|
||
|
||
### Exercice 1
|
||
|
||
L’indice de masse corporelle (IMC) est le seul indice validé par l’Organisation mondiale de la santé pour évaluer la corpulence d’un individu et donc les éventuels risques pour la santé.
|
||
|
||
La formule de calcul a été vu lors de l'activité 1 sur les variables.
|
||
|
||
L'OMS fournit l'interprétation suivante de l'état de santé en fonction de l'IMC :
|
||
|
||
| Indice de masse corporelle (IMC) | Interprétation (d'après l'OMS) |
|
||
| :--: | :--: |
|
||
| moins de 18,5 | Insuffisance pondérale (maigreur) |
|
||
| 18,5 à 25 | Corpulence normale |
|
||
| 25 à 30 | Surpoids |
|
||
| 30 à 35 | Obésité modérée |
|
||
| 35 à 40 | Obésité sévère |
|
||
| plus de 40 | Obésité morbide ou massive |
|
||
|
||
Voici une liste de caractéristiques de célébrités anonymisées (i.e le nom a été changé par décence).
|
||
|
||
| Célébrité | Taille (en cm) | Poids (en kg) |
|
||
| :--: | :--: | :--: |
|
||
| B | 169 | 56 |
|
||
| E | 157 | 48 |
|
||
| A | 175 | 90 |
|
||
| M | 205 | 200 |
|
||
| V | 163 | 42 |
|
||
| P | 170 | 75 |
|
||
| S | 191 | 113 |
|
||
|
||
Écrire un programme qui permet d'afficher l'état de santé en fonction de l'IMC, selon l'OMS. Vous pouvez compléter le tableau en fonction de vos résultats.
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 2
|
||
|
||
1. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le minimum des 3 entiers
|
||
2. Écrire un programme qui demande 3 entiers de manières consécutives et affiche le maximum des 3 entiers
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 3
|
||
|
||
Écrire un programme pour vérifier si un nombre saisi par un utilisateur est divisible par 3 et 13 ou non,
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 4
|
||
|
||
Écrire un programme pour vérifier si un caractère saisi par l'utilisateur est une voyelle ou une consonne.
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 5
|
||
|
||
Écrire un programme pour entrer le numéro du jour de la semaine (1-7) et affiche le nom du jour de la semaine correspondant
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 6
|
||
|
||
Modifier le code suivant pour qu'il y ait 4 couleurs différentes en fonction de la position(abscisse) de la souris
|
||
|
||
**mouseX** renvoie l'abscisse de la souris (0 pour le coin supérieur gauche de la fenêtre)
|
||
|
||
( 0 à 50 , 50 à 100, 100 à 150 et 150 à 200)
|
||
|
||
```python
|
||
from p5 import *
|
||
|
||
def setup():
|
||
createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels
|
||
|
||
def draw():# cette fonction s'exécute en boucle 60 fois par seconde...
|
||
# les conditions pour la couleur du fond d'écran
|
||
if mouseX > 0 and mouseX < 100: # teste la position (abscisse) de la souris sur la moité gauche (0 à 100)
|
||
background(255,120,0) #
|
||
elif mouseX > 100 and mouseX < 200:# teste la position (abscisse) de la souris sur la moité droite (100 à 200)
|
||
background(0,255,120) #
|
||
else:
|
||
background(0,0,255) # fond bleu
|
||
run()
|
||
```
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 7
|
||
|
||
Reprendre le code précédent(copier-coller) et en utilisant les instructions **mouseX** et **mouseY** (qui renvoie abscisse et ordonnée de la souris), faites en sorte qu'il y ait 4 couleurs différentes qui s'affichent suivant la position de la souris dans les quadrants:
|
||
|
||
- 0 < mouseX <100 et 0 < mouseY < 100, la couleur affichée doit être le bleu
|
||
- 100 < mouseX < 200 et 0 < mouseY < 100, la couleur affichée doit être le vert
|
||
- 0 < mouseX < 100 et 100 < mouseY < 200, la couleur affichée doit être le rouge
|
||
- 100 < mouseX < 200 et 100 < mouseY < 200, la couleur affichée doit être le jaune
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 8
|
||
|
||
Dans le code suivant on affiche dans la fenêtre 4 cercles et la couleur de fond change si la souris survole l'un des cercles.
|
||
|
||
- l'instruction **circle(50,50,40)** dessine un cercle de centre (50,50 ) et de diamètre 40.
|
||
- l'instruction **dist(x1,y1,x2,y2)** calcule la distance entre les points de coordonnées (x1,y1) et (x2,y2).
|
||
- **dist(mouseX,mouseY,50,50) < 20** teste si la souris est dans l'un des cercles.
|
||
|
||
Compléter le code de façon que le fond change de couleur au survol des 4 cercles.
|
||
|
||
```python
|
||
from p5 import *
|
||
|
||
def setup():
|
||
createCanvas(200,200) # crée une fenêtre de 200 x 200 pixels
|
||
|
||
def draw():# cette fonction s'exécute en boucle 60 fois par seconde...
|
||
if dist(mouseX,mouseY,50,50) < 20:
|
||
background(255,255,0)
|
||
# à modifier ici
|
||
else:
|
||
background(51,51,51)
|
||
# ne pas modifier...
|
||
fill(0,0,0)
|
||
circle(50,50,40)
|
||
circle(150,150,40)
|
||
circle(150,50,40)
|
||
circle(50,150,40)
|
||
|
||
run()
|
||
```
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 9
|
||
|
||
Le code ci-dessous montre "une balle" se déplaçant sur un axe horizontal dans une fenêtre en rebondissant sur les bords.
|
||
|
||
Compléter le code de telle sorte que la balle se déplace aussi dans la verticale en rebondissant sur les bords inférieur et supérieur de la fenêtre.
|
||
|
||
```python
|
||
from p5 import *
|
||
|
||
def setup():
|
||
global bx,by,vx,vy,r
|
||
r = 20
|
||
bx = 50
|
||
by = 50
|
||
vx = 4
|
||
vy = 5
|
||
createCanvas(400,200) # crée une fenêtre de 200 x 200 pixels
|
||
|
||
def draw():# cette fonction s'exécute en boucle 60 fois par seconde...
|
||
global bx,by,vx,vy,r
|
||
background(0,0,0)# fond noir
|
||
# mouvement du cercle sur l'axe horizontal
|
||
bx = bx + vx
|
||
# rebond sur les bords gauche et droit
|
||
if bx < r or bx > 400 - r:
|
||
vx = -vx
|
||
# dessin du cercle
|
||
fill(255,0,0)
|
||
circle(bx,by,2*r)
|
||
|
||
run()
|
||
```
|
||
|
||
|
||
```python
|
||
|
||
```
|
||
|
||
### Exercice 10
|
||
|
||
Reprendre le code précédent et faire en sorte que la "balle" change de couleur à chaque rebond
|
||
|
||
Pour utiliser une couleur aléatoire, on pourra utiliser l'instruction: `fill(random(255),random(255),random(255))`
|
||
|
||
|
||
```python
|
||
|
||
```
|