Partie 4 · Algorithmique et programmation · Chapitre 21

Écrire des programmes simples

Variables, boucles, fonctions.

Le chapitre précédent a donné le vocabulaire. Celui-ci apprend à s’en servir pour construire les trois programmes qui reviennent dans tous les sujets : accumuler une somme, chercher un seuil, et fabriquer une fonction que l’on pourra appeler avec n’importe quelle valeur.

La boucle bornée

Définition : Boucle for

La boucle $\texttt{for}$ répète un bloc d’instructions un nombre de fois connu à l’avance. À chaque tour, la variable de boucle prend la valeur suivante de la séquence parcourue.

1for i in range(4):2    print(i)

Ce que le programme affiche

Déroulement de for i in range(4) : le corps est exécuté quatre fois, avec i valant successivement 0, 1, 2 puis 3.

Remarque : la variable de boucle existe après la boucle

À la sortie de la boucle, $\texttt{i}$ conserve sa dernière valeur, ici $3$ . On évite toutefois de s’en servir : un programme lisible ne réutilise pas une variable de boucle en dehors de sa boucle.

$\texttt{range}$ en détail

C’est la source d’erreur numéro un des sujets de baccalauréat. La règle tient en une phrase : la borne de gauche est incluse, celle de droite est exclue.

Écriture	Valeurs parcourues	Nombre de tours
$\texttt{range(5)}$	$0,\ 1,\ 2,\ 3,\ 4$	$5$
$\texttt{range(2, 7)}$	$2,\ 3,\ 4,\ 5,\ 6$	$5$
$\texttt{range(1, n + 1)}$	$1,\ 2,\ \dots,\ n$	$n$
$\texttt{range(0, 10, 3)}$	$0,\ 3,\ 6,\ 9$	$4$
$\texttt{range(5, 0, -1)}$	$5,\ 4,\ 3,\ 2,\ 1$	$5$

Méthode : traduire un intervalle d’entiers

« pour $k$ allant de $1$ à $n$ » s’écrit $\texttt{range(1, n + 1)}$ : sans le $+1$ , on s’arrête à $n - 1$ .
« $n$ répétitions » s’écrit $\texttt{range(n)}$ , sans se préoccuper des valeurs prises.
Pour descendre, le troisième argument est le pas, ici négatif.

Exemple

1for i in range(5, 0, -1):2    print(i)

Ce que le programme affiche

Accumuler dans une variable

Le même schéma sert à calculer une somme, un produit ou un effectif : on prépare une variable avant la boucle, puis on la met à jour à chaque tour.

Méthode : le schéma d’accumulation

Initialiser avant la boucle : $\texttt{s = 0}$ pour une somme, $\texttt{p = 1}$ pour un produit, $\texttt{c = 0}$ pour un compteur.
Mettre à jour dans la boucle, par une affectation du type $\texttt{s = s + ...}$ .
Utiliser le résultat après la boucle, une fois tous les tours faits.

L’initialisation doit se trouver avant la boucle. Placée dedans, elle remettrait le total à zéro à chaque tour.

Exemple : une somme

Calcul de $1 + 2 + \dots + 10$ :

1s = 02for k in range(1, 11):3    s = s + k4print(s)

Ce que le programme affiche

Exemple : un produit

Calcul de $5!$ , la factorielle rencontrée au chapitre du dénombrement :

1p = 12for k in range(1, 6):3    p = p * k4print(p)

Ce que le programme affiche

Un produit s’initialise à $1$ , jamais à $0$ : sinon tout le calcul resterait nul.

Exemple : un compteur

Combien y a-t-il de multiples de $7$ entre $1$ et $100$ ?

1compteur = 02for k in range(1, 101):3    if k % 7 == 0:4        compteur = compteur + 15print(compteur)

Ce que le programme affiche

On retrouve bien $14$ , puisque les multiples cherchés vont de $7 \times 1$ à $7 \times 14 = 98$ .

Chercher un seuil

Quand le nombre de tours dépend du résultat, la boucle bornée ne convient plus : on ne peut pas écrire dans le $\texttt{range}$ un nombre que l’on cherche justement à déterminer.

Méthode : le schéma de recherche de seuil

Initialiser le terme au premier de la suite, et le compteur de rang à $0$ .
Écrire la condition de poursuite, c’est-à-dire la négation de ce que l’on cherche.
Dans le corps, calculer le terme suivant puis incrémenter le rang.
Après la boucle, le compteur contient le premier rang qui vérifie la condition cherchée.

Organigramme d’une boucle non bornée : après le corps, la flèche rouge revient AVANT le test, qui est donc réévalué à chaque tour.

Exemple

Cherchons le plus petit entier $n$ tel que $3^{\,n} > 1000$ . On part de $3^0 = 1$ et on multiplie par $3$ à chaque tour :

1u = 12n = 03while u <= 1000:4    u = 3 * u5    n = n + 16print(n, u)

Ce que le programme affiche

7 2187

Le programme affiche $7$ et $2187$ : en effet $3^6 = 729 \leqslant 1000$ alors que $3^7 = 2187 > 1000$ .

Termes de la suite définie par u(n) = 10 × 0,7ⁿ et seuil s = 3 : le premier terme sous le seuil, en rouge, est celui de rang 4.

Exemple

Pour la suite $u_n = 10 \times 0{,}7^{\,n}$ représentée ci-dessus, on cherche le premier rang où elle passe sous $3$ :

1u = 102n = 03while u >= 3:4    u = 0.7 * u5    n = n + 16print(n)

Ce que le programme affiche

Remarque : poursuite ou arrêt

La condition écrite après $\texttt{while}$ est celle qui fait continuer, pas celle que l’on cherche. Pour trouver le premier terme strictement inférieur à $3$ , on écrit donc $\texttt{while u >= 3:}$ , c’est-à-dire la négation de $\texttt{u < 3}$ . Se tromper de sens est l’erreur la plus fréquente de ce type d’exercice.

Écrire une fonction

Définition : Fonction

Une fonction est un bloc d’instructions nommé, que l’on peut exécuter autant de fois qu’on veut avec des valeurs différentes. On la définit par $\texttt{def}$ , on lui donne des paramètres, et elle renvoie un résultat par $\texttt{return}$ .

1def carre(x):2    return x * x34print(carre(3))5print(carre(-5))

Ce que le programme affiche

9
25

Une fonction se comporte comme une boîte : l’argument entre par le paramètre, le résultat sort par return.

Méthode : anatomie d’une fonction

$\texttt{def}$ suivi du nom, des paramètres entre parenthèses, et d’un deux-points.
Le corps est indenté, comme tout bloc.
$\texttt{return}$ renvoie le résultat et termine immédiatement la fonction : les lignes suivantes ne sont pas exécutées.
L’appel s’écrit $\texttt{carre(3)}$ : la valeur $3$ , appelée argument, est rangée dans le paramètre $\texttt{x}$ .

Exemple

Une fonction peut contenir une boucle. Celle-ci calcule $1^2 + 2^2 + \dots + n^2$ pour n’importe quel $n$ :

1def somme_carres(n):2    s = 03    for k in range(1, n + 1):4        s = s + k * k5    return s67print(somme_carres(10))

Ce que le programme affiche

Le même programme écrit sans fonction ne servirait qu’une fois, pour la seule valeur $n = 10$ .

$\texttt{return}$ n’est pas $\texttt{print}$

C’est la confusion la plus coûteuse du chapitre, car le programme semble marcher : quelque chose s’affiche bien à l’écran.

Propriété : Deux rôles à ne pas confondre

$\texttt{print}$ affiche une valeur pour l’utilisateur. Le programme, lui, n’en récupère rien.
$\texttt{return}$ renvoie une valeur au programme, qui peut la stocker, la réutiliser ou la recalculer.
Une fonction sans $\texttt{return}$ renvoie la valeur spéciale $\texttt{None}$ , qui signifie « rien ».

Exemple

1def double_affiche(x):2    print(2 * x)34def double_renvoie(x):5    return 2 * x67a = double_affiche(5)8b = double_renvoie(5)9print(a, b)

Ce que le programme affiche

10
None 10

La première fonction affiche $10$ , mais ne renvoie rien : $\texttt{a}$ vaut $\texttt{None}$ . La seconde n’affiche rien, mais $\texttt{b}$ vaut $10$ et pourra servir dans un calcul. Dès qu’un résultat doit être réutilisé, il faut un $\texttt{return}$ .

Application aux suites

Voici l’usage le plus fréquent au baccalauréat : une suite définie par récurrence, dont on veut un terme quelconque ou un rang de dépassement.

Exemple : calculer un terme

Pour la suite définie par $u_0 = 50$ et $u_{n+1} = 0{,}8\,u_n + 1$ , on part du premier terme et on applique $n$ fois la relation :

1def terme(n):2    u = 503    for i in range(n):4        u = 0.8 * u + 15    return u67print(terme(1))8print(round(terme(2), 3))

Ce que le programme affiche

41.0
33.8

La boucle tourne exactement $n$ fois, ce qui fait passer de $u_0$ à $u_n$ . Pour $n = 0$ , elle ne tourne pas et la fonction renvoie bien $u_0 = 50$ .

Exemple : trouver un rang

Avec un paramètre, la même idée donne le rang de franchissement pour n’importe quel seuil :

1def seuil(limite):2    u = 503    n = 04    while u >= limite:5        u = 0.8 * u + 16        n = n + 17    return n89print(seuil(10))10print(seuil(6))

Ce que le programme affiche

10
18

Plus le seuil est proche de la limite de la suite, ici $5$ , plus il faut de termes pour l’atteindre.

Remarque : les décimaux ne sont pas exacts

print(0.1 + 0.2)

Ce que le programme affiche

0.30000000000000004

La machine ne stocke qu’une valeur approchée des nombres décimaux. Deux conséquences : on affiche les résultats avec $\texttt{round(x, 2)}$ , et l’on ne teste jamais l’égalité de deux décimaux par $\texttt{==}$ . Pour les entiers, en revanche, Python est exact, quelle que soit leur taille.

Erreurs classiques à éviter

Écrire $\texttt{range(1, n)}$ pour aller de $1$ à $n$ .
La borne de droite est exclue : il faut $\texttt{range(1, n + 1)}$ . Sinon le dernier terme manque, et la somme est fausse d’exactement $n$ .
Initialiser l’accumulateur à l’intérieur de la boucle.
$\texttt{s = 0}$ doit être avant la boucle. Placée dedans, cette ligne remet le total à zéro à chaque tour, et le résultat final est le dernier terme seul.
Initialiser un produit à $0$ .
Un produit s’initialise à $1$ , élément neutre de la multiplication. À partir de $0$ , tout produit reste nul.
Écrire dans le $\texttt{while}$ la condition d’arrêt au lieu de celle de poursuite.
Après $\texttt{while}$ figure la condition qui fait continuer. Pour trouver le premier terme inférieur à $3$ , on écrit $\texttt{while u >= 3:}$ , la négation de ce que l’on cherche.
Confondre $\texttt{return}$ et $\texttt{print}$ .
$\texttt{print}$ affiche pour l’utilisateur, $\texttt{return}$ renvoie au programme. Une fonction sans $\texttt{return}$ renvoie $\texttt{None}$ , et son résultat est inutilisable dans un calcul.
Placer des instructions après le $\texttt{return}$ .
$\texttt{return}$ termine la fonction sur-le-champ. Toute ligne écrite après, au même niveau d’indentation, ne sera jamais exécutée.
Oublier d’appeler la fonction.
Définir une fonction n’exécute rien : $\texttt{def}$ ne fait que la mémoriser. Il faut ensuite l’appeler, par exemple $\texttt{print(carre(3))}$ .
Tester l’égalité de deux nombres décimaux.
Les décimaux sont stockés de façon approchée : $\texttt{0.1 + 0.2 == 0.3}$ est faux en Python. On compare avec $\texttt{<}$ ou $\texttt{>}$ , ou l’on arrondit avant.

Et maintenant

Le cours est lu ? Vérifie qu’il est acquis : le QCM repère les trous, les exercices confirment en conditions réelles, les flashcards ancrent les formules.

Faire le QCM Voir les exercices