Chapitre 32 — les briques dont tout le reste dépend : variables, types, opérations, booléens, l'instruction if et les deux boucles while et for.
Naviguez avec les flèches ← → du clavier, ou via le Sommaire.
// et %, flottantsprint, saisir avec inputif, boucles while et for, accumulateursL'idée forte : un programme est une suite d'instructions exécutées dans l'ordre ; les conditions et les boucles décident lesquelles, et combien de fois.
>>>) exécute une ligne et affiche sa valeur : l'outil de l'essai rapide.print.2 + 3 print(7 * 8) x = 2 ** 10 print(x) 56 1024
Dans ce script, la ligne 1 calcule $5$ mais ne l'affiche pas : une valeur ni affichée ni rangée dans une variable est perdue.
nom = expression évalue d'abord l'expression de droite, puis range sa valeur sous le nom de gauche ; l'ancienne valeur est oubliée.
>>> a = 5 >>> a = a + 1 >>> a 6 >>> a, b = 1, 2 >>> a, b = b, a # échange simultané >>> a 2 >>> b 1
a = a + 1 n'est pas une équation : « calculer $a+1$ avec la valeur actuelle, puis ranger le résultat dans $a$ ». Les noms distinguent majuscules et minuscules, sans espace ni accent.
int : entiers relatifs, sans limite de taille ; float : flottants, écrits avec un point (0.5, 1e-9).bool : True, False (majuscule) ; str : chaînes entre guillemets.>>> type(7.0) <class 'float'> >>> type(7 > 3) <class 'bool'> >>> int(7.9) 7 >>> str(7) + "1" '71'
int(7.9) tronque, il n'arrondit pas. Entre deux chaînes, + les met bout à bout : "7" + "1" vaut "71", pas $8$.
/ division, résultat toujours flottant : 7 / 2 vaut 3.5.// quotient et % reste euclidiens : 17 // 5 vaut 3, 17 % 5 vaut 2.** puissance : 2 ** 10 vaut 1024.>>> 2 + 3 * 4 14 >>> -2 ** 2 -4 >>> (-2) ** 2 4 >>> 2 ** 3 ** 2 512
Celles des mathématiques : **, puis * / // %, puis + -. La puissance passe avant le signe, $-2^2=-4$, et se calcule de droite à gauche, $2^{(3^2)}=512$. Dans le doute, des parenthèses.
// et %Pour $b\geqslant 1$, q = a // b et r = a % b donnent l'unique couple du cours :
a = 47 b = 6 q = a // b r = a % b print(f"{a} = {b} x {q} + {r}") print(0 <= r < b) 47 = 6 x 7 + 5 True
Le reste reste positif pour un dividende négatif : -17 // 5 vaut -4 et -17 % 5 vaut 3, car $-17=5\times(-4)+3$. Et $b$ divise $a$ si, et seulement si, a % b == 0.
Un flottant s'écrit en base $2$ avec un nombre fini de chiffres : $0{,}1$ et $0{,}2$ y sont arrondis, et l'addition propage l'arrondi.
>>> 0.1 + 0.2 0.30000000000000004 >>> 0.1 + 0.2 == 0.3 False >>> abs((0.1 + 0.2) - 0.3) < 1e-9 True
== entre flottants : on teste un écart inférieur à une tolérance.// et % : 6 / 2 vaut 3.0.print affiche ses arguments séparés par un espace. Dans une f-string, toute expression entre accolades est remplacée par sa valeur ; {x:.4f} donne quatre décimales.
>>> n = 12 >>> print("n =", n) n = 12 >>> print(f"n = {n} et n**2 = {n**2}") n = 12 et n**2 = 144 >>> print(f"{2/3:.4f}") 0.6667
Pour un nombre, on convertit : age = int(input("Votre age ? ")). Sans int, age + 10 provoque une erreur de type. Dans le livre, on fixe plutôt les données en tête du script (n = 2025).
= et ==Une comparaison vaut True ou False : ==, !=, <, <=, >, >=. Moins prioritaires que l'arithmétique : n % 2 == 0 se lit (n % 2) == 0.
>>> x = 4 >>> x == 4 True >>> 3 != 5 True >>> 0 < x < 10 # comparaisons enchaînées True
= est l'affectation, une instruction qui modifie une variable ; == est le test d'égalité, une expression qui ne modifie rien.
and, or, not et De Morganand, or (inclusif), not traduisent et, ou, non. Priorité : not, puis and, puis or, tous après les comparaisons. On vérifie $\overline{P\wedge Q}=\overline{P}\vee\overline{Q}$ et $\overline{P\vee Q}=\overline{P}\wedge\overline{Q}$ sur les quatre cas :
for P in (True, False) : for Q in (True, False) : print(P, Q, (not (P and Q)) == ((not P) or (not Q)), (not (P or Q)) == ((not P) and (not Q))) True True True True True False True True False True True True False False True True
Une table de vérité est exhaustive : ces quatre lignes démontrent les deux lois. Pas d'opérateur pour $P\Rightarrow Q$ : on écrit (not P) or Q. Et True + True vaut 2.
if, elif, elseLes conditions sont testées dans l'ordre ; seul le bloc de la première vraie s'exécute, et le else recueille le reste. Un bloc est décalé de quatre espaces : l'indentation fait partie de la syntaxe.
x = -3 if x > 0 : print("strictement positif") elif x == 0 : print("nul") else : print("strictement négatif") strictement négatif
Deux if successifs sont indépendants : les deux blocs peuvent s'exécuter. Un if suivi d'un elif ou d'un else forme une alternative : c'est la disjonction des cas.
whilewhile condition : exécute le bloc tant que la condition est vraie, en la réévaluant avant chaque tour : un nombre de tours inconnu à l'avance. Exemple : le plus petit diviseur $d\geqslant 2$ de $91$.
n = 91 d = 2 while n % d != 0 : d = d + 1 print("plus petit diviseur de", n, ":", d) plus petit diviseur de 91 : 7
Cette boucle s'arrête toujours : $n$ est divisible par lui-même, donc au pire $d$ atteint $n$ (et $n$ est alors premier).
$u_0=1$, $u_{n+1}=2u_n$ : à partir de quel rang a-t-on $u_n\geqslant 1000$ ? Les deux variables avancent ensemble.
u = 1 n = 0 while u < 1000 : u = 2 * u n = n + 1 print(n, u) 10 1024
Si la condition ne devient jamais fausse, le navigateur se fige (bouton Stop). Le bloc doit modifier une variable de la condition ; en mise au point, on ajoute un garde-fou : while u != 0 and n < 100 :.
for et rangerange(b) : $0,1,\dots,b-1$ ; range(a, b) : $a,\dots,b-1$, soit $b-a$ tours.range(a, b, p) : $a, a+p, a+2p,\dots$ strictement avant $b$.range(1, n + 1). On n'incrémente jamais k soi-même.>>> list(range(5)) [0, 1, 2, 3, 4] >>> list(range(2, 7)) [2, 3, 4, 5, 6] >>> list(range(0, 20, 5)) [0, 5, 10, 15] >>> list(range(10, 0, -3)) [10, 7, 4, 1]
Variable initialisée avant la boucle, mise à jour à chaque tour, qui contient le résultat à la sortie. On l'initialise à l'élément neutre : somme = 0, produit = 1.
n = 100 somme = 0 for k in range(1, n + 1) : somme = somme + k print(somme, n * (n + 1) // 2) 5050 5050
L'ordinateur vérifie $\displaystyle\sum_{k=1}^{n}k=\frac{n(n+1)}{2}$ pour une valeur de $n$, il ne la démontre pas : la preuve est une récurrence. Raccourci : somme += k.
compteur = 0 for k in range(1, 101) : if k % 3 == 0 : compteur = compteur + 1 print(compteur) 33
maximum = 0 for k in range(1, 21) : r = (k * k) % 23 if r > maximum : maximum = r print(maximum) 18
Le compteur ne progresse que si la condition est vraie ; le maximum s'initialise en général avec le premier terme ($0$ convient ici, les restes étant positifs). Nombre de tours connu : for ; inconnu (seuil, premier diviseur) : while.
On lit la dernière ligne d'abord : le type de l'erreur, puis la ligne indiquée. La cause est parfois à la ligne précédente (parenthèse non fermée).
somme = 0 for k in range(1, 4) : somme = somme + k print(sommme) File "script.py", line 4, in <module> NameError: name 'sommme' is not defined. Did you mean: 'somme'?
SyntaxError : parenthèse non fermée, deux-points oublié, = au lieu de == ; IndentationError : bloc non décalé.NameError : nom jamais défini ; TypeError : "n = " + n ; ZeroDivisionError : division par $0$.n = 12 compteur = 0 for d in range(1, n + 1) : if n % d == 0 : print(d) # mise au point compteur = compteur + 1 print("nombre de diviseurs :", compteur) 1 2 3 4 6 12 nombre de diviseurs : 6
x = expr : droite d'abord, puis rangementint, float, bool, str ; type(x)a // b quotient, a % b restea % b == 0abs(x - y) < 1e-9, jamais ==print(f"n = {n}")not > and > or ; $P\Rightarrow Q$ : (not P) or Qrange(1, n + 1)for ; sinon while= affecte, == compare ; et le deux-points après if, while, for.range est exclue./ renvoie toujours un flottant ; -2 ** 2 vaut -4.input renvoie une chaîne : convertir avec int.while, oublier n = n + 1 donne une boucle infinie.IndentationError.print(7 // 2, 7 % 2, 7 / 2) ?3 1 3.5print("2" + "3", 2 + 3) ?23 5 : deux chaînes se mettent bout à bout.print(list(range(1, 10, 3))) ?[1, 4, 7] : on s'arrête strictement avant $10$.s = 0 puis for k in range(4) : s = s + k, que vaut s ?6, soit $0+1+2+3$.print(0.1 + 0.2 == 0.3) ?False : les flottants sont arrondis.x = 7, qu'affichent if x > 5 : print("A") puis if x > 3 : print("B") ?A puis B : deux if sont indépendants (avec elif, seulement A).