Panique : le prochain contrôle de maths parle de Python, et toi, la dernière fois que tu as croisé un serpent, c'était au zoo. Respire. Il n'y a que trois idées à retenir, et tu t'en sers déjà sans le savoir. On y va tranquillement.
Les trois mots à retenir (et le seul prérequis)
Un programme, c'est une recette : une suite d'instructions que l'ordinateur execute une par une, de haut en bas, dans l'ordre. Rien de magique.
Savoir calculer une expression (par exemple 5 + 3 ou 5 * 2) et suivre des etapes dans l'ordre. Si tu sais faire ca, tu sais deja lire du Python.
En Seconde, tout tient en trois briques :
- Variable : une boite etiquetee qui garde une valeur. On ecrit
a = 5pour ranger 5 dans la boite nommeea. - Boucle : une instruction qui dit recommence. Elle repete un bloc plusieurs fois sans qu'on ait a le recopier.
- Fonction : un mini-programme qu'on nomme une fois et qu'on reutilise autant qu'on veut, en lui donnant des valeurs.
Les formules clés à recopier au brouillon
Voici les quatre ecritures a recopier sur ton brouillon en debut de controle. Apprends-les par coeur, elles reviennent tout le temps.
- Affectation (ranger une valeur) : $\texttt{variable = valeur}$
- Boucle for (repeter un nombre connu de fois) : $\texttt{for i in range(n) :}$
- Boucle while (repeter tant qu'une condition tient) : $\texttt{while condition :}$
- Fonction (bloc nomme) : $\texttt{def nom(param) : return ...}$
Les deux-points : sont obligatoires apres for, while, def. Et le bloc qui suit doit etre indente (decale vers la droite, 4 espaces).
Un exemple traité du début à la fin
On lit trois lignes et on suit la valeur de chaque boite, pas a pas. C'est exactement ce qu'on te demandera.
b = a + 3
a = a * 2
Ligne 1 a = 5 : la boite a recoit la valeur 5.
Ligne 2 b = a + 3 : l'ordinateur calcule d'abord la droite, $5 + 3 = 8$, puis range 8 dans b.
Ligne 3 a = a * 2 : il calcule $5 \times 2 = 10$, puis range 10 dans a. La boite a change, mais b ne bouge pas.
Bilan : a la fin, $a = 10$ et $b = 8$.
Si tu sais lire de haut en bas et calculer la droite avant de ranger a gauche, tu sais deja tracer un programme. Le reste, ce sont des variations.
Ah, le brouillard se lève : tu as déjà croisé ces bestioles en salle info. On reprend proprement, avec les vraies définitions et la méthode, pour que « ça me dit un truc » devienne « je maîtrise ».
Variables : une case mémoire qui a un nom
Definition. Une variable est une case memoire identifiee par un nom, qui stocke une valeur. Le signe = est une affectation, pas une egalite mathematique : il range la valeur de droite dans la case de gauche.
Dans x = expression, Python calcule d'abord toute l'expression de droite, puis depose le resultat dans x. On lit donc de la droite vers la gauche.
Reprenons trois affectations et suivons chaque case dans un tableau, comme un correcteur.
b = a + 3
a = a * 2
| Ligne | Instruction | Calcul | a | b |
|---|---|---|---|---|
| 1 | a = 5 | — | 5 | — |
| 2 | b = a + 3 | $5 + 3 = 8$ | 5 | 8 |
| 3 | a = a * 2 | $5 \times 2 = 10$ | 10 | 8 |
A la fin : $a = 10$ et $b = 8$. La ligne 3 ne touche pas a b : une variable ne change que si on la reaffecte.
Boucles : répéter sans tout réécrire
Definition. Une boucle repete un bloc d'instructions. On distingue deux cas selon ce que l'on sait a l'avance.
for i in range(n) : repete le bloc n fois, avec i qui prend successivement les valeurs $0, 1, \ldots, n-1$. Attention : range(n) genere $0, 1, \ldots, n-1$, la valeur $n$ est exclue. Ainsi range(1, 4) donne 1, 2, 3.
while condition : repete le bloc tant que la condition est vraie. On ne connait pas forcement d'avance le nombre de tours.
for i in range(1, 4) :
s = s + i
| Tour | i | s (avant) | s = s + i | s (après) |
|---|---|---|---|---|
| init | — | — | — | 0 |
| 1 | 1 | 0 | $0 + 1$ | 1 |
| 2 | 2 | 1 | $1 + 2$ | 3 |
| 3 | 3 | 3 | $3 + 3$ | 6 |
Resultat : $s = 6 = 1 + 2 + 3$. La boucle a additionne 1, 2 et 3.
while $n < 10$ :
n = n * 2
| n (avant) | $n < 10$ ? | action | n (après) |
|---|---|---|---|
| 1 | vrai | $n \times 2$ | 2 |
| 2 | vrai | $n \times 2$ | 4 |
| 4 | vrai | $n \times 2$ | 8 |
| 8 | vrai | $n \times 2$ | 16 |
| 16 | faux | on sort | 16 |
Iterations : $n = 1 \to 2 \to 4 \to 8 \to 16$. Pour $n = 16$, la condition $n < 10$ est fausse : la boucle s'arrete.
Fonctions : un bloc nommé et réutilisable
Definition. Une fonction est un bloc d'instructions nomme et parametrable, reutilisable a volonte. Les parametres entre parentheses sont des cases qui recoivent les valeurs donnees a l'appel ; return renvoie le resultat a celui qui a appele la fonction.
return x ** 3
cube(4) : le parametre $x$ vaut 4, la fonction renvoie $4^3 = 64$.
cube(2) : le parametre $x$ vaut 2, la fonction renvoie $2^3 = 8$.
Le parametre prend la valeur fournie a l'appel ; return communique le resultat.
- Ecrire
def, le nom, les parametres entre parentheses, puis:. - Indenter le corps de la fonction (4 espaces ou une tabulation).
- Terminer par
returnsuivi de la valeur a renvoyer. - Tester avec une valeur concrete et verifier le resultat a la main.
Assez de théorie, on met les mains dans le clavier — enfin, dans le brouillon. On refait trois exécutions ensemble, ligne par ligne, comme un correcteur qui déroule le programme à la main. Crayon en main, on trace côte à côte.
On trace une boucle for ensemble (la somme)
On deroule l'execution ensemble, ligne par ligne. Prends un crayon et remplis le tableau en meme temps que moi.
for i in range(1, 4) :
s = s + i
On commence. range(1, 4) fabrique les valeurs 1, 2, 3 (le 4 est exclu). La variable i va prendre ces trois valeurs, l'une apres l'autre. Avant le premier tour, s vaut 0.
| Tour | i | s avant | calcul s = s + i | s après |
|---|---|---|---|---|
| init | — | — | — | 0 |
| 1 | 1 | 0 | $0 + 1 = 1$ | 1 |
| 2 | 2 | 1 | $1 + 2 = 3$ | 3 |
| 3 | 3 | 3 | $3 + 3 = 6$ | 6 |
On conclut. Une fois les trois valeurs epuisees, la boucle s'arrete et $s = 6$. C'est bien $1 + 2 + 3 = 6$ : on a additionne les entiers en accumulant dans s.
On trace une boucle while ensemble (doubler)
Meme methode, mais avec un while : ici on ne compte pas les tours, on surveille une condition.
while $n < 10$ :
n = n * 2
Point cle. La condition $n < 10$ est testee avant chaque tour. Tant qu'elle est vraie, on double ; des qu'elle est fausse, on sort sans executer le bloc.
| n (avant le test) | $n < 10$ ? | n = n × 2 |
|---|---|---|
| 1 | vrai, on continue | 2 |
| 2 | vrai | 4 |
| 4 | vrai | 8 |
| 8 | vrai | 16 |
| 16 | faux, on sort | — |
On conclut. A la sortie, $n = 16$. Remarque : $n$ vaut 16 (et non un nombre plus petit que 10), car le dernier doublement a fait passer n de 8 a 16, et c'est seulement ensuite que le test echoue.
On écrit et on teste une fonction ensemble (cube)
On ecrit une fonction en suivant la methode, puis on la teste. Objectif : cube(x) doit renvoyer le cube de x.
Etape 1. def, le nom, le parametre, les deux-points :
Etape 2. on indente le corps et on renvoie le resultat :
return x ** 3
Etape 3 — on teste. cube(4) : le parametre $x$ prend la valeur 4, donc la fonction renvoie $4 \times 4 \times 4 = 4^3 = 64$.
Et cube(2) renvoie $2^3 = 8$. On verifie a la main : tout colle.
Un appel de fonction vaut la valeur qu'elle renvoie : ecrire cube(4) dans un calcul, c'est comme ecrire 64. Le parametre, lui, n'existe que le temps de l'appel.
Là on joue le contrôle pour de vrai. Pas de piège caché : juste les détails qui font gagner (ou perdre) les points, et ce que le correcteur coche vraiment. On blinde deux problèmes types du début à la fin.
Les subtilités qui font les points (et les pièges)
Au controle, les points se gagnent (ou se perdent) sur les details. Voici ceux que le correcteur regarde en premier.
- range :
range(n)donne $0, 1, \ldots, n-1$ (le $n$ est exclu) ;range(a, b)donne $a, a+1, \ldots, b-1$. Le grand classique de l'erreur : croire querange(1, 4)contient 4. - = et == :
=affecte une valeur,==teste l'egalite. Dans un test on ecritif n == 5 :, jamaisif n = 5 :. - Deux-points : obligatoires apres
for,while,def,if. - Indentation : le corps doit etre decale (4 espaces). Un bloc non indente provoque une IndentationError.
- return : une fonction sans
returnne renvoie rien d'exploitable ; pense a renvoyer le resultat.
Un code lisible et correctement indente, les : en place, une trace juste (tableau d'execution), et surtout des bornes de range justes. Une trace propre rapporte souvent plus que le seul resultat final.
Problème type 1 — une fonction qui calcule une somme
Enonce. Ecris une fonction somme(n) qui renvoie $1 + 2 + \ldots + n$, puis teste-la pour $n = 4$.
Idee. On combine deux briques : une boucle for pour additionner, et une fonction pour rendre le tout reutilisable.
s = 0
for i in range(1, n + 1) :
s = s + i
return s
Le point delicat. Pour aller jusqu'a $n$ inclus, on ecrit range(1, n + 1) : comme la borne haute est exclue, il faut ecrire $n+1$ pour que $n$ soit atteint.
Test pour $n = 4$. Alors range(1, 5) produit 1, 2, 3, 4.
| Tour | i | s avant | s après |
|---|---|---|---|
| init | — | — | 0 |
| 1 | 1 | 0 | 1 |
| 2 | 2 | 1 | 3 |
| 3 | 3 | 3 | 6 |
| 4 | 4 | 6 | 10 |
La fonction renvoie 10, et on verifie : $1 + 2 + 3 + 4 = 10$.
- Le
+ 1dansrange(1, n + 1)(sinon on s'arrete an - 1). - L'initialisation
s = 0avant la boucle. - Le
returnapres la boucle, bien desindente (sinon la fonction s'arrete des le premier tour).
Problème type 2 — compter avec une boucle while
Enonce. En partant de n = 1, combien de fois faut-il doubler pour depasser 100 ? On veut compter les doublements.
Idee. On reprend la boucle qui double, et on ajoute un compteur c qui augmente de 1 a chaque tour.
c = 0
while $n \le 100$ :
n = n * 2
c = c + 1
On repete tant que $n \le 100$ ; des que $n$ depasse 100, on sort.
| n avant | c avant | $n \le 100$ ? | n après | c après |
|---|---|---|---|---|
| 1 | 0 | vrai | 2 | 1 |
| 2 | 1 | vrai | 4 | 2 |
| 4 | 2 | vrai | 8 | 3 |
| 8 | 3 | vrai | 16 | 4 |
| 16 | 4 | vrai | 32 | 5 |
| 32 | 5 | vrai | 64 | 6 |
| 64 | 6 | vrai | 128 | 7 |
| 128 | 7 | faux, on sort | 128 | 7 |
Reponse. Il faut 7 doublements ($n$ passe alors a 128). On verifie : $2^6 = 64 \le 100$ mais $2^7 = 128 > 100$.
- Oublier d'initialiser le compteur a 0 avant la boucle.
- Inverser la condition : tester
n > 100pour continuer ferait tout rater. - Boucle infinie : si on oublie la ligne
n = n * 2, $n$ ne change jamais, la condition reste vraie et le programme tourne sans fin. Verifie toujours que la condition finit par devenir fausse.
Tu tiens les trois briques. Maintenant, le clin d'œil vers la suite : ces briques ne servent pas qu'en info, et elles cachent de jolies idées de maths. Petit tour d'horizon, sans réviser — juste pour voir plus loin.
La fonction Python EST une fonction de maths
Surprise : la fonction que tu ecris en Python est exactement une fonction de maths. cube(x) qui renvoie x ** 3, c'est la fonction $f : x \mapsto x^3$.
- Donner un parametre a la fonction $=$ choisir un antecedent $x$.
- La valeur renvoyee par
return$=$ l'image $f(x)$.
Ainsi cube(2) renvoie 8, tout comme $f(2) = 2^3 = 8$. Meme objet, deux langages. C'est le lien direct avec les fonctions de reference (carre, cube, inverse, racine) que tu etudies en analyse.
Pourquoi la somme 1+2+…+n a une formule (idée de démonstration)
La boucle somme(n) calcule $1 + 2 + \ldots + n$ pas a pas. Mais il existe un raccourci celebre :
$1 + 2 + \ldots + n = \dfrac{n(n+1)}{2}$
Idee de la justification (l'astuce de Gauss). On apparie le premier terme avec le dernier. Pour $n = 4$ : $(1 + 4) + (2 + 3) = 5 + 5 = 2 \times 5 = 10$.
Chaque paire vaut $n + 1$, et il y a $\dfrac{n}{2}$ paires, d'ou $\dfrac{n(n+1)}{2}$. Pour $n = 4$ : $\dfrac{4 \times 5}{2} = 10$ — exactement ce que renvoie somme(4).
L'ordinateur et la formule sont d'accord : la boucle fait a la main, tour apres tour, ce que la formule donne d'un coup. Verifie avec un grand nombre : somme(100) et $\dfrac{100 \times 101}{2} = 5050$ donnent le meme resultat.
Ce qui t'attend ensuite
Variable, boucle, fonction : ce sont les trois lettres de l'alphabet. L'an prochain, tu ecriras des phrases. Au programme de la suite :
- les conditions
if / elsepour choisir selon les cas (tu as deja croise le:duif) ; - les boucles imbriquees (une boucle a l'interieur d'une autre) ;
- les listes (ou tableaux) pour ranger plusieurs valeurs sous un seul nom ;
- et enfin les algorithmes de recherche et de tri, qui assemblent tout ca pour resoudre de vrais problemes.
Chaque programme complique n'est qu'un empilement de ces trois briques. Tu tiens deja l'essentiel : range, indentation, return et une trace propre. Le reste, c'est de la combinaison.