Structures conditionnelles : if, elif, else
En programmation, on a souvent besoin d'exécuter un bloc de code seulement si une certaine condition est remplie. Python utilise les instructions if, elif et else pour cela.
if condition1:
# instructions exécutées si condition1 est vraie
elif condition2:
# instructions si condition1 est fausse et condition2 vraie
else:
# instructions si aucune condition n'est vraieLe elif (contraction de "else if") est optionnel et peut apparaître plusieurs fois. Le else est facultatif également. On peut avoir un simple if sans rien d'autre.
Opérateurs de comparaison
| Opérateur | Signification | Exemple |
|---|---|---|
== | égal à | x == 0 |
!= | différent de | x != 5 |
< | strictement inférieur | x < 10 |
> | strictement supérieur | x > 0 |
<= | inférieur ou égal | x <= 100 |
>= | supérieur ou égal | x >= 18 |
and | et logique | x > 0 and x < 10 |
or | ou logique | x < 0 or x > 10 |
not | négation | not (x == 3) |
def valeur_absolue(x):
if x >= 0:
return x
else:
return -xdef mention(moyenne):
if moyenne < 8:
return "Refusé"
elif moyenne < 10:
return "Rattrapage"
elif moyenne < 12:
return "Admis"
elif moyenne < 14:
return "Assez bien"
elif moyenne < 16:
return "Bien"
else:
return "Très bien"if doit être décalé d'un même nombre d'espaces.
Le module random
Pour simuler le hasard en Python, on importe le module random qui fournit plusieurs fonctions utiles.
import random en début de programme. Ensuite, on utilise les fonctions du module en les préfixant par random..
Les fonctions essentielles
| Fonction | Description | Exemple |
|---|---|---|
random.random() | Réel aléatoire dans $[0;1[$ | 0.3742... |
random.randint(a, b) | Entier aléatoire entre a et b inclus | random.randint(1,6) → 1,2,3,4,5 ou 6 |
random.uniform(a, b) | Réel aléatoire entre a et b | random.uniform(0,10) |
random.choice(liste) | Un élément au hasard d'une liste | random.choice(["pile","face"]) |
import random
de = random.randint(1, 6)
print("Le dé donne :", de)random.random() :
if random.random() < 0.5:
print("Pile")
else:
print("Face")random.random() donne un nombre uniforme dans $[0;1[$.
random.random() < p qui renvoie True avec probabilité $p$ et False sinon.
Simulation d'expériences aléatoires
On peut répéter une expérience aléatoire un grand nombre de fois pour estimer la probabilité d'un événement par la fréquence observée (loi des grands nombres).
- Définir une fonction qui simule une expérience et renvoie
Truesi l'événement cherché est réalisé,Falsesinon. - Répéter cette expérience $N$ fois (avec une boucle
for) en comptant le nombre deTrue. - La fréquence (nombre de succès / $N$) donne une estimation de la probabilité.
import random
def un_succes():
"""Simule 4 lancers, renvoie True si au moins un 6"""
for _ in range(4):
if random.randint(1, 6) == 6:
return True
return False
def estimation(N):
succes = 0
for _ in range(N):
if un_succes():
succes = succes + 1
return succes / N
print(estimation(100000)) # Environ 0.5177La probabilité exacte est $1 - (5/6)^4 \approx 0,5177$, ce que l'on retrouve approximativement.
def roulette():
numero = random.randint(0, 36)
return numero != 0 and numero % 2 == 0 # pair sauf 0
def simule(N):
gagne = 0
for _ in range(N):
if roulette():
gagne += 1
return gagne / N
print(simule(100000)) # ~0.486Exercices corrigés
Exercice 1 – Année bissextile
Écrire une fonction est_bissextile(annee) qui renvoie True si l'année est bissextile (divisible par 4, mais pas par 100 sauf si divisible par 400).
Solution :
def est_bissextile(annee):
if annee % 400 == 0:
return True
elif annee % 100 == 0:
return False
elif annee % 4 == 0:
return True
else:
return FalseExercice 2 – Lancer de pièces jusqu'à obtenir Pile
Écrire une fonction qui compte le nombre de lancers nécessaires pour obtenir Pile (pièce équilibrée). Simuler cette expérience 1000 fois et estimer l'espérance (nombre moyen de lancers).
Solution :
def un_jeu():
n = 0
while True:
n = n + 1
if random.random() < 0.5: # Pile
return n
def simulation(N):
total = 0
for _ in range(N):
total = total + un_jeu()
return total / N
print(simulation(10000)) # ~2.0 (espérance = 2)Exercice 3 – Aiguillage conditionnel avec elif
Écrire une fonction temperature(degres) qui retourne "Glace" si la température est $\le 0$, "Eau liquide" si $0 < T < 100$, et "Vapeur" si $T \ge 100$.
Solution :
def temperature(T):
if T <= 0:
return "Glace"
elif T < 100:
return "Eau liquide"
else:
return "Vapeur"Exercice 4 – Simulation d'une probabilité conditionnelle
On lance deux dés. On s'intéresse à la probabilité que la somme soit $\ge 8$ sachant que le premier dé donne 6. Écrire une simulation pour estimer cette probabilité conditionnelle.
Solution :
def simulation_cond(N):
total_cond = 0 # cas où premier dé = 6
succes = 0 # cas où premier dé = 6 ET somme >= 8
for _ in range(N):
d1 = random.randint(1, 6)
d2 = random.randint(1, 6)
if d1 == 6:
total_cond += 1
if d1 + d2 >= 8:
succes += 1
return succes / total_cond
print(simulation_cond(100000)) # ~0.666... (exact = 4/6)