💻Python : variables, conditions, boucles

Une variable est un nom qui désigne une valeur stockée en mémoire. On l'affecte avec le signe = :

age = 15        # un entier (int)
taille = 1.72   # un nombre à virgule (float)
nom = "Léa"     # une chaîne de caractères (str)
majeur = False  # un booléen (bool) : True ou False

En Python le point décimal s'écrit avec un point (1.72), jamais avec une virgule. La fonction type(x) donne le type de x.

Pour lire une affectation :

1. On calcule d'abord la valeur à droite du =.
2. On la range dans la variable nommée à gauche.
3. a = a + 1 n'est pas une équation : on prend l'ancienne valeur de a, on lui ajoute 1, et on remet le résultat dans a.

x = 5
x = x + 3
print(x)   # affiche 8

Après x = 5, la variable vaut $5$. La ligne x = x + 3 calcule $5+3 = 8$ et range $8$ dans x.

Ne confonds pas = (affecter) et == (tester l'égalité). x = 3 range $3$ dans x ; x == 3 répond True ou False.

Les opérateurs de calcul :

⭐ Pour les curieux — pourquoi ça marche ? Pourquoi n % 10 donne-t-il le dernier chiffre d'un entier ? Parce qu'écrire un nombre en base $10$, c'est exactement le découper en paquets de dix. Par exemple $2473 = 247 \times 10 + 3$ : on a fait $247$ paquets de dix (ce qui donne $2470$), et il reste $3$, qui est précisément le chiffre des unités. Or le reste de la division par $10$, c'est justement « ce qui dépasse après avoir formé tous les paquets de dix possibles » : voilà pourquoi $n \,\%\, 10$ isole le dernier chiffre, tandis que $n \,/\!/\, 10$ ne garde que le nombre de paquets, $247$, c'est-à-dire le nombre privé de son dernier chiffre. Même idée pour le test « pair » : un nombre pair se range parfaitement en paires (paquets de $2$) sans rien qui dépasse, donc son reste par $2$ vaut $0$.

Pour savoir si un entier n est pair, on regarde le reste de sa division par $2$ : n % 2 == 0 signifie « n est pair ». Le % est aussi utile pour récupérer le dernier chiffre d'un nombre : n % 10.

Attention : / renvoie toujours un float. 10 / 2 vaut 5.0 (et non 5). Pour un quotient entier, utilise //.

Une comparaison renvoie un booléen True ou False :

On combine plusieurs tests avec and (et), or (ou) et not (non).

Pour traduire « x est compris entre 0 et 10 » on écrit 0 <= x and x <= 10, ou plus court en Python : 0 <= x <= 10.

== compare, = affecte. Une erreur très fréquente !

Une condition permet d'exécuter un bloc seulement si un test est vrai :

note = 12
if note >= 10:
    print("Reçu")
else:
    print("Recalé")

On peut tester plusieurs cas à la suite avec elif (sinon si).

1. Le bloc d'un if est indenté (décalé de 4 espaces).
2. Python lit les tests dans l'ordre et s'arrête au premier vrai.
3. Le else (facultatif) attrape tous les cas restants.

N'oublie jamais les deux-points : en fin de ligne if, et indente le bloc en dessous, sinon Python refuse le programme.

La boucle for répète un bloc pour chaque valeur d'une séquence. Avec range, on parcourt des entiers :

for i in range(4):
    print(i)
# affiche 0, puis 1, puis 2, puis 3

range(n) va de 0 à n-1 (donc n valeurs). range(a, b) va de a à b-1.

⭐ Pour les curieux — pourquoi ça marche ? Pourquoi range(n) contient-il exactement $n$ valeurs alors qu'il s'arrête à $n-1$ ? Parce qu'on compte à partir de $0$ et non de $1$. Aligne les nombres $0, 1, 2, \dots, n-1$ : devant chaque entier $k$, il y a exactement $k$ entiers ($0, 1, \dots, k-1$). Donc le tout dernier, $n-1$, est précédé de $n-1$ camarades : cela fait bien $n-1$ valeurs avant lui, puis lui-même, soit $n$ valeurs en tout. Le piège du « $-1$ » disparaît dès qu'on retient que démarrer à $0$ décale toute la liste d'un cran vers le bas, sans en changer la longueur.

Pour répéter quelque chose n fois, on écrit for i in range(n):. La variable i prend successivement $0, 1, 2, \dots, n-1$.

range(4) ne contient pas le 4 : ce sont $0, 1, 2, 3$. La borne de droite est toujours exclue.

La boucle while répète un bloc **tant qu'**une condition reste vraie :

n = 1
while n <= 3:
    print(n)
    n = n + 1
# affiche 1, 2, 3

On l'utilise quand on ne sait pas à l'avance combien de tours il faudra (contrairement au for).

Dans un while, il faut faire évoluer la condition à l'intérieur de la boucle (ici n = n + 1), sinon elle ne s'arrête jamais : c'est une boucle infinie.

Oublier de modifier la variable testée crée une boucle infinie. Vérifie toujours que la condition finira par devenir fausse.