Partie 4 · Algorithmique et programmation · Chapitre 20

Du langage naturel à Python

Traduire un algorithme dans les deux sens.

Les trois derniers chapitres du programme ne demandent pas de nouvelles mathématiques : ils demandent de savoir écrire et lire un programme. Au baccalauréat, l’algorithmique n’est jamais un exercice isolé, elle s’invite dans les autres questions : chercher le rang à partir duquel une suite dépasse un seuil, simuler un échantillon, calculer une intégrale par des rectangles. Ce chapitre pose le vocabulaire, les deux suivants l’exploitent.

Qu’est-ce qu’un algorithme ?

Définition : Algorithme

Un algorithme est une suite finie d’instructions non ambiguës qui, à partir de données, produit un résultat en un nombre fini d’étapes.

Un programme est la traduction d’un algorithme dans un langage compris par la machine. Ici, ce sera Python.

Remarque : trois exigences

Non ambigu : « prendre un nombre à peu près grand » n’est pas une instruction.
Fini : l’algorithme doit s’arrêter. Une boucle qui tourne sans fin n’est pas un algorithme.
Ordonné : les instructions s’exécutent l’une après l’autre, de haut en bas.

Exemple

« Multiplier un nombre par lui-même, puis afficher le résultat » est un algorithme. En Python :

1n = 62carre = n * n3print(carre)

Ce que le programme affiche

Les variables et l’affectation

Définition : Variable et affectation

Une variable est un nom qui désigne un emplacement de la mémoire, dans lequel on range une valeur. L’instruction $\texttt{n = 7}$ est une affectation : elle range la valeur $7$ dans la variable $\texttt{n}$ .

Une affectation remplace l’ancienne valeur : celle-ci est définitivement perdue.

Effet de l’instruction n = n + 3 : la machine calcule d’abord n + 3, puis range le résultat dans n, ce qui écrase la valeur précédente.

Méthode : lire une affectation de droite à gauche

La machine calcule d’abord le membre de droite, avec les valeurs actuelles des variables.
Puis elle range ce résultat dans la variable du membre de gauche.
Le signe $\texttt{=}$ ne signifie donc pas « est égal à ». L’instruction $\texttt{n = n + 3}$ n’est pas une équation, c’est un ordre.

Exemple

Suivons ces trois lignes :

1n = 72n = n + 33print(n)

Ce que le programme affiche

À la ligne 2, le membre de droite $\texttt{n + 3}$ vaut $7 + 3 = 10$ ; c’est cette valeur qui est rangée dans $\texttt{n}$ . Le $7$ n’existe plus.

Remarque : nommer ses variables

Un nom de variable commence par une lettre, ne contient ni espace ni accent, et distingue les majuscules des minuscules : $\texttt{n}$ et $\texttt{N}$ sont deux variables différentes. Un nom parlant, comme $\texttt{somme}$ ou $\texttt{compteur}$ , rend le programme lisible.

Calculer : les opérateurs

Python connaît les opérations usuelles, plus deux opérateurs très utiles en arithmétique.

Opérateur	Effet	Exemple	Résultat
$\texttt{+}$ $\texttt{-}$ $\texttt{*}$	somme, différence, produit	$\texttt{5 * 3}$	$15$
$\texttt{/}$	quotient décimal	$\texttt{7 / 2}$	$3{,}5$
$\texttt{//}$	quotient entier de la division euclidienne	$\texttt{7 // 2}$	$3$
$\texttt{\%}$	reste de la division euclidienne	$\texttt{7 \% 2}$	$1$
$\texttt{**}$	puissance	$\texttt{2 ** 10}$	$1024$

Méthode : l’opérateur reste, à connaître absolument

$\texttt{n \% 2}$ vaut $0$ si $n$ est pair et $1$ si $n$ est impair. Plus généralement, $\texttt{n \% k == 0}$ teste si $n$ est un multiple de $k$ . C’est le test de divisibilité de tous les exercices.

Exemple

1print(17 // 5, 17 % 5)2print(2 ** 10)3print(7 / 2)

Ce que le programme affiche

3 2
1024
3.5

On retrouve la division euclidienne : $17 = 5 \times 3 + 2$ . Noter que Python écrit les décimaux avec un point, jamais une virgule.

Communiquer : entrer et afficher

Définition : Les deux instructions d’échange

$\texttt{print(...)}$ affiche une valeur à l’écran.
$\texttt{input(...)}$ demande une valeur à l’utilisateur, et la renvoie toujours sous forme de texte.

Comme $\texttt{input}$ renvoie du texte, il faut convertir : $\texttt{int(...)}$ pour un entier, $\texttt{float(...)}$ pour un décimal.

Exemple

Un programme qui demande un entier et affiche son double :

1n = int(input("Entrez un entier : "))2print("Le double vaut", 2 * n)

Sans le $\texttt{int}$ , la variable $\texttt{n}$ contiendrait le texte $\texttt{"5"}$ , et $\texttt{2 * n}$ afficherait $\texttt{55}$ au lieu de $10$ : Python répéterait le texte deux fois au lieu de doubler un nombre.

Remarque : au bac, la valeur est le plus souvent donnée

Les sujets écrivent rarement $\texttt{input}$ : ils fixent la valeur dans le programme, ou la reçoivent en paramètre d’une fonction, ce que l’on verra au chapitre suivant. Cela rend le programme reproductible, donc corrigible.

Les instructions conditionnelles

Définition : Si… alors… sinon

Une instruction conditionnelle exécute un bloc d’instructions seulement si une condition est vraie. En Python, elle s’écrit avec $\texttt{if}$ , éventuellement $\texttt{elif}$ et $\texttt{else}$ :

1if condition:2    instructions exécutées si la condition est vraie3else:4    instructions exécutées sinon

Propriété : Deux règles de syntaxe à ne jamais oublier

La ligne du $\texttt{if}$ se termine par un deux-points.
Le bloc qui suit est indenté de quatre espaces. En Python, c’est l’indentation, et elle seule, qui délimite les blocs : une ligne non indentée n’appartient plus au $\texttt{if}$ .

Condition	Signification
$\texttt{a == b}$	$a$ est égal à $b$ (double signe égal)
$\texttt{a != b}$	$a$ est différent de $b$
$\texttt{a < b}$ et $\texttt{a <= b}$	$a < b$ et $a \leqslant b$
$\texttt{a > b}$ et $\texttt{a >= b}$	$a > b$ et $a \geqslant b$
$\texttt{and}$ , $\texttt{or}$ , $\texttt{not}$	et, ou, non

Organigramme d’une instruction conditionnelle : le losange porte le test, chaque branche exécute son bloc, puis les deux branches se rejoignent.

Exemple

1n = 72if n % 2 == 0:3    print("pair")4else:5    print("impair")

Ce que le programme affiche

impair

Exemple : trois cas avec elif

1x = 02if x > 0:3    print("positif")4elif x < 0:5    print("négatif")6else:7    print("nul")

Ce que le programme affiche

nul

Les cas sont examinés dans l’ordre et un seul bloc est exécuté : dès qu’une condition est vraie, les suivantes ne sont même pas testées.

Les deux façons de répéter

Répéter des instructions se fait de deux manières, selon que l’on connaît ou non à l’avance le nombre de tours.

Définition : Boucle bornée et boucle non bornée

La boucle bornée $\texttt{for}$ répète un nombre de fois connu à l’avance.
La boucle non bornée $\texttt{while}$ répète tant qu’une condition est vraie, sans savoir combien de tours cela prendra.

Exemple

Compter jusqu’à $3$ , une fois avec chaque boucle :

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

Ce que le programme affiche

1i = 02while i <= 3:3    print(i)4    i = i + 1

Ce que le programme affiche

Les deux affichent la même chose, mais la seconde exige d’initialiser $\texttt{i}$ avant la boucle et de l’incrémenter dedans. Oublier la ligne 4 ferait tourner le programme sans fin.

Organigramme d’une boucle « tant que » : après le corps, la flèche rouge revient AVANT le test, qui est donc évalué de nouveau à chaque tour.

Méthode : choisir sa boucle

« Calculer les $20$ premiers termes » : le nombre de tours est connu, donc $\texttt{for}$ .
« Chercher le premier rang où la suite dépasse $1000$ » : on ignore combien de tours il faudra, donc $\texttt{while}$ .

Traduire dans les deux sens

Le programme demande de savoir passer du langage naturel à Python et de Python au langage naturel. Voici le dictionnaire à connaître.

Langage naturel	Python
$n$ prend la valeur $5$	$\texttt{n = 5}$
Demander un entier $n$	$\texttt{n = int(input())}$
Afficher $n$	$\texttt{print(n)}$
$n$ prend la valeur $n + 1$	$\texttt{n = n + 1}$
Si $n$ est pair, alors… sinon…	$\texttt{if n \% 2 == 0:}$ … $\texttt{else:}$
Pour $i$ allant de $0$ à $n - 1$	$\texttt{for i in range(n):}$
Tant que $u > 10^{-3}$	$\texttt{while u > 10 ** (-3):}$

Exemple : du langage naturel à Python

« $S$ prend la valeur $0$ . Pour $k$ allant de $1$ à $10$ , ajouter $k^2$ à $S$ . Afficher $S$ . »

1S = 02for k in range(1, 11):3    S = S + k ** 24print(S)

Ce que le programme affiche

Attention au $\texttt{11}$ : $\texttt{range(1, 11)}$ parcourt $1,\, 2,\, \dots,\, 10$ , la borne de droite étant exclue. Ce point est détaillé au chapitre suivant.

Exemple : de Python au langage naturel

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

Ce que le programme affiche

En français : « $u$ vaut $1$ et $n$ vaut $0$ . Tant que $u$ reste strictement inférieur à $100$ , on triple $u$ et on compte un tour de plus. On affiche enfin le nombre de tours. » Ce programme cherche donc **le plus petit entier $n$ tel que $3^n \geqslant 100$ **, et affiche $5$ , car $3^4 = 81 < 100$ et $3^5 = 243 \geqslant 100$ .

Suivre un programme pas à pas

C’est l’exercice le plus fréquent au baccalauréat : on donne un programme, on demande ce qu’il affiche. La seule méthode fiable est le tableau d’exécution, où l’on note la valeur de chaque variable après chaque ligne.

Méthode : construire un tableau d’exécution

Une colonne par variable, une ligne par instruction exécutée.
Recopier la valeur d’une variable tant qu’elle ne change pas.
Pour une boucle, une ligne par tour : ne pas sauter de tour, c’est là que se glissent les erreurs.
Vérifier la condition d’arrêt avant chaque tour pour un $\texttt{while}$ .

Exemple

Que fait ce programme ?

1a = 32b = 53a = a + b4b = a - b5a = a - b6print(a, b)

Ce que le programme affiche

5 3

Ligne exécutée	$\texttt{a}$	$\texttt{b}$
$\texttt{a = 3}$	$3$
$\texttt{b = 5}$	$3$	$5$
$\texttt{a = a + b}$	$8$	$5$
$\texttt{b = a - b}$	$8$	$3$
$\texttt{a = a - b}$	$5$	$3$

Le tableau révèle l’intention du programme : il échange les contenus de $\texttt{a}$ et $\texttt{b}$ , sans utiliser de troisième variable.

Remarque : l’échange naïf ne marche pas

1a = 32b = 53a = b4b = a5print(a, b)

Ce que le programme affiche

5 5

À la ligne 3, la valeur $3$ est écrasée : elle n’existe plus nulle part, et la ligne 4 ne peut que recopier $5$ . Pour échanger simplement, il faut une variable temporaire : $\texttt{t = a}$ , puis $\texttt{a = b}$ , puis $\texttt{b = t}$ .

Erreurs classiques à éviter

Confondre $\texttt{=}$ et $\texttt{==}$ .
$\texttt{=}$ affecte une valeur, $\texttt{==}$ teste une égalité. Un test s’écrit toujours $\texttt{if n == 0:}$ , jamais $\texttt{if n = 0:}$ , qui est une erreur de syntaxe.
Lire $\texttt{n = n + 1}$ comme une équation.
Ce n’est pas une équation, c’est un ordre : « calculer $n + 1$ , puis ranger le résultat dans $n$ ». Comme équation, elle n’aurait aucune solution.
Oublier le deux-points en fin de ligne.
Toute ligne ouvrant un bloc ( $\texttt{if}$ , $\texttt{else}$ , $\texttt{for}$ , $\texttt{while}$ , $\texttt{def}$ ) se termine par $\texttt{:}$ . Sans lui, Python refuse d’exécuter le programme.
Négliger l’indentation.
En Python, l’indentation est la syntaxe : elle seule dit quelles lignes appartiennent au bloc. Décaler une ligne d’un cran change le sens du programme.
Oublier de convertir le résultat de $\texttt{input}$ .
$\texttt{input}$ renvoie toujours du texte. Sans $\texttt{int(...)}$ ou $\texttt{float(...)}$ , $\texttt{2 * n}$ répète le texte au lieu de doubler un nombre.
Écrire les décimaux avec une virgule.
Python écrit $\texttt{3.5}$ , avec un point. Une virgule sépare deux valeurs distinctes : $\texttt{print(3, 5)}$ affiche deux nombres.
Oublier d’incrémenter la variable dans un $\texttt{while}$ .
Si aucune instruction du corps ne rapproche de la condition d’arrêt, la boucle tourne indéfiniment. Vérifier systématiquement que quelque chose progresse à chaque tour.
Utiliser une variable avant de l’avoir créée.
Toute variable doit recevoir une valeur avant d’être lue. Un compteur ou une somme se déclarent avant la boucle, par $\texttt{S = 0}$ ou $\texttt{n = 0}$ .

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