Notions de base

15 minutes de Python

Conditions if : n’exécuter des instructions que dans certains cas

Thème : Notions de base

Niveau : ECG1–ECG2

Année : Maths appliquées, Maths approfondies

Objectif : Découvrir les tests et conditions en Python : comparaisons, booléens, et structures if / elif / else.

Comprendre les conditions en Python

Un programme a souvent besoin de prendre des décisions : faire une action si une condition est vraie, et une autre sinon. C’est exactement le rôle des structures if, elif et else.


Comparer des valeurs

Une condition est généralement une comparaison. Les opérateurs de comparaison les plus courants sont :

==   égal à
!=   différent de
<    strictement inférieur à
<=   inférieur ou égal à
>    strictement supérieur à
>=   supérieur ou égal à

Attention à ne pas confondre :

  • = qui sert à affecter une valeur à une variable,
  • == qui sert à tester si deux valeurs sont égales.

Par exemple :

a = 5      # on donne la valeur 5 à la variable a
a == 5     # on teste si a est égal à 5 (cela renvoie True ou False)

Une comparaison ne fait jamais un calcul “classique” : elle renvoie toujours une valeur booléenne, True (vrai) ou False (faux).

Par exemple, si on exécute le code :

n = 7
print(int(n/2)*2 == n)

Python calcule d’abord int(n/2), qui vaut 3 (partie entière de 7/2), puis int(n/2)*2, qui vaut 6. Il teste ensuite si 6 == 7, ce qui est faux. Le programme renvoie donc False.

Cela signifie ici que n n’est pas pair, autrement dit que n est impair.


La structure if / else

La syntaxe de base d’une condition est la suivante :

if condition:
    instructions_si_vrai
else:
    instructions_si_faux

Concrètement, Python lit la condition. Si elle est True, il exécute toutes les lignes indentées juste en dessous du if. Sinon, il exécute toutes les lignes indentées juste en dessous du else.

L’indentation (les espaces en début de ligne) est donc essentielle : elle indique à Python quelles instructions font partie du bloc. Sans indentation correcte, le programme ne fonctionne pas.

Exemple :

x = float(input("x = "))

if x >= 0:
    print("x est positif ou nul")
    print("on affiche ce message car la condition est vraie")
else:
    print("x est strictement négatif")
    print("on affiche ce message car la condition est fausse")

print("fin du programme")

Si x = 3, Python exécute les deux lignes indentées sous le if. Si x = -2, Python exécute les deux lignes indentées sous le else.

La dernière ligne print("fin du programme") n’est pas indentée : elle est donc exécutée dans tous les cas, quelle que soit la valeur de x.


Enchaîner plusieurs cas : elif

if condition1:
    ...
elif condition2:
    ...
else:
    ...

Python teste d’abord condition1, puis (si elle est fausse) condition2, etc. Le bloc else est utilisé si aucune condition n’est vraie.


Utiliser plusieurs conditions : and, or, not

Une condition peut être construite à partir de plusieurs tests. On utilise pour cela des connecteurs logiques.

  • and signifie « et » : toutes les conditions doivent être vraies,
  • or signifie « ou » : au moins une condition doit être vraie,
  • not signifie « non » : on inverse une condition.

Exemples :

x >= 0 and x <= 1      # x est entre 0 et 1
x < 0 or x > 10       # x est strictement négatif ou strictement supérieur à 10
not (x == 0)         # x est différent de 0

Ces connecteurs permettent d’écrire des conditions plus fines, par exemple :

if x >= 0 and x <= 1:
    print("x est entre 0 et 1")

Ils sont très utilisés pour tester l’appartenance à un intervalle, combiner plusieurs critères, ou exclure un cas particulier.


Zone de test libre

Modifie le code ci-dessous, puis clique sur « Exécuter ». Essaye par exemple de changer la valeur de x, ou d’ajouter un nouveau cas avec elif.

Exemple

import numpy.random as rd

lancer = rd.randint(2)

if lancer == 0:
    print("pile")
else:
    print("face")

Explication

Ce script simule un lancer de pièce : il affiche soit pile, soit face.

  1. import numpy.random as rd
    • On importe la bibliothèque numpy.random sous le nom abrégé rd.
    • On pourra ensuite écrire rd.randint(...) au lieu de numpy.random.randint(...).
  2. lancer = rd.randint(2)
    • rd.randint(2) renvoie un entier aléatoire parmi 0 et 1 (avec équiprobabilité).
    • Cette valeur est stockée dans la variable lancer.
    • Donc, après cette ligne, lancer vaut soit 0, soit 1.
  3. if lancer == 0:
    • Python teste si la valeur de lancer est égale à 0.
    • Si la condition est vraie, il exécute le bloc indenté sous le if.
    • Sinon, il exécute le bloc indenté sous le else.
  4. print("pile") / print("face")
    • Si lancer == 0, le programme affiche exactement pile.
    • Si lancer == 1, le programme affiche exactement face.
    • Un seul des deux mots est affiché, car un seul des deux blocs est exécuté.

Trois commandes utiles aujourd’hui

Clique sur une carte pour voir l’instruction utile.

Choisir un nombre au hasard
Calculer \( \quad e^x \)
Quotient et reste d’une division euclidienne

Un exercice pour vérifier ta maîtrise

Compléter le script pour qu'il choisisse un nombre réel \( x \) au hasard dans \( [0,1] \) et affiche :

  • 0 si ce nombre \( x \) est inférieur ou égal à \( \frac{1}{3} \),
  • 1 si ce nombre \( x \) est strictement supérieur à \( \frac{1}{3} \) et inférieur ou égal à \( \frac{1}{2} \),
  • 2 si ce nombre \( x \) est strictement supérieur à \( \frac{1}{2} \).

Et pour quelques minutes de plus…

Prendre en main la programmation, pas à pas.

Ces exercices sont conçus pour t’aider à maîtriser progressivement la programmation en Python, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de scripts complets.

L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque instruction, puis en apprenant à les utiliser par toi-même.

L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.

Niveau 1 Analyser un code

Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des scripts Python déjà écrits. L’objectif est de comprendre la logique du programme, le rôle des variables, des boucles et des conditions, et d’être capable de prévoir ce que le code affiche ou calcule.

Niveau 2 Compléter un code

Écrire, mais avec un cadre.
Ici, tu passes à l’écriture sans partir de zéro. Le squelette du programme est fourni : il te reste à compléter certaines instructions pour que le code fonctionne correctement. Ce format permet de se concentrer sur l’essentiel, sans se perdre dans la structure générale.

Niveau 3 Écrire un code complet

Passer à l’autonomie.
Dans cette dernière série, tu écris un programme complet à partir d’une consigne. Tu dois organiser ton code, choisir les bonnes instructions et construire la logique globale du script. C’est ici que tu mets en pratique tout ce que tu as appris dans les niveaux précédents.

error: Ce contenu est protégé !