Algorithmique et programmation en Python
Seconde · Maths · Algorithmique et programmation
Algorithmique et programmation
Variables, types et instructions conditionnelles
Un algorithme, c'est une suite finie d'instructions non ambiguës qui, à partir de données en entrée, produit un résultat. Python n'est qu'un langage pour l'écrire proprement. En seconde, on ne te demande pas de devenir développeur : on te demande de lire un programme et de dire ce qu'il fait, et d'en écrire de courts sans te tromper sur les détails qui comptent.
| Type | Nom Python | Exemples de valeurs | Piège fréquent |
|---|---|---|---|
| Nombre entier | int | 0, 7, −25 | 7/2 ne donne PAS un int |
| Nombre décimal | float | 3.5, −0.25, 2.0 | on écrit un point, jamais une virgule |
| Chaîne de caractères | str | "bonjour", "12" | "12" + "3" donne "123", pas 15 |
| Booléen | bool | True, False | s'écrivent avec une majuscule |
La fonction type(x) renvoie le type de x, et int("12") ou float("3.5") convertissent une chaîne en nombre. C'est indispensable après un input(), qui renvoie toujours une chaîne de caractères.
Les opérateurs à connaître :
- Calcul : + (addition), − (soustraction), * (multiplication), / (division qui donne toujours un float), ** (puissance : 2**3 vaut 8).
- Division entière : // renvoie le quotient entier (7//2 vaut 3), et % renvoie le reste (7%2 vaut 1). Très utile pour tester la parité : n%2 == 0 signifie « n est pair ».
- Comparaison : == (égal à), != (différent de), <, >, <=, >=. Le résultat d'une comparaison est un booléen.
- Logique : and (et), or (ou), not (non).
L'instruction conditionnelle
Pour exécuter des instructions seulement dans certains cas, on utilise if / elif / else. Attention à la syntaxe : deux points à la fin de la ligne de test, et surtout une indentation (un décalage de 4 espaces) pour marquer le bloc qui dépend du test.
age = 12
if age < 6:
tarif = 0
elif age < 18:
tarif = 5
else:
tarif = 9
Python teste les conditions dans l'ordre et s'arrête à la première qui est vraie. Ici age vaut 12 : la première condition est fausse, la deuxième est vraie, donc tarif reçoit 5 et le else est ignoré.
Algorithmique et programmation
Boucles, fonctions et listes
Un ordinateur est surtout doué pour répéter. Deux outils pour ça : la boucle bornée (je sais combien de tours je veux faire) et la boucle non bornée (je répète tant qu'une condition reste vraie). Savoir choisir entre les deux est l'attendu principal du chapitre.
La boucle bornée : for. On l'emploie quand le nombre de répétitions est connu à l'avance.
somme = 0
for i in range(1, 5):
somme = somme + i
La variable i prend successivement les valeurs 1, 2, 3, 4 : la somme finale vaut 1 + 2 + 3 + 4 = 10. Tout tient dans le fonctionnement de range, à connaître par cœur :
| Écriture | Valeurs parcourues | Nombre de tours |
|---|---|---|
| range(5) | 0, 1, 2, 3, 4 | 5 |
| range(1, 5) | 1, 2, 3, 4 | 4 |
| range(2, 10, 3) | 2, 5, 8 | 3 |
| range(len(L)) | les indices de la liste L | len(L) |
La boucle non bornée : while. Quand on ignore à l'avance le nombre de répétitions, on utilise while (« tant que »).
capital = 1000
annees = 0
while capital < 1200:
capital = capital * 1.05
annees = annees + 1
Tant que le capital n'a pas atteint 1 200 euros, on ajoute 5 % et on compte une année de plus. À la sortie, la variable annees contient le nombre d'années nécessaires. Ce schéma « je répète et je compte » est le plus classique de tous les exercices de seconde.
Les fonctions. Une fonction regroupe des instructions sous un nom, avec des paramètres en entrée et éventuellement une valeur renvoyée par return.
def aire_disque(r):
from math import pi
return pi * r ** 2
On l'utilise ensuite comme en maths : a = aire_disque(3). Attention à la différence essentielle entre return et print : return renvoie une valeur qu'on peut réutiliser dans un calcul, print se contente d'afficher du texte à l'écran. Une fonction sans return renvoie la valeur spéciale None.
Les listes. Une liste range plusieurs valeurs dans une seule variable : L = [3, 7, 1, 9]. On accède à un élément par son indice, qui commence à 0 : L[0] vaut 3 et L[2] vaut 1. La longueur s'obtient avec len(L), ici 4. On construit une liste de trois façons :
• En extension, en écrivant tous les termes : L = [1, 4, 9, 16].
• Par ajouts successifs, avec append : L = [] puis, dans une boucle, L.append(x*x).
• En compréhension, la plus rapide à écrire : L = [x*x for x in range(1, 5)] donne [1, 4, 9, 16].
Exercices corrigés
Quelles valeurs la variable i prend-elle dans la boucle for i in range(5) ?
- A.1, 2, 3, 4, 5
- B.1, 2, 3, 4
- C.0, 1, 2, 3, 4, 5
- D.0, 1, 2, 3, 4Bonne réponse
Réponse : D — 0, 1, 2, 3, 4
range(5) part de 0 (valeur par défaut) et s'arrête AVANT 5 : i prend donc les valeurs 0, 1, 2, 3, 4. Cela fait bien 5 tours de boucle, mais la dernière valeur est 4, pas 5. Retiens la règle générale : dans range, la borne de gauche est incluse et celle de droite est exclue. Si tu veux les entiers de 1 à 5, il faut écrire range(1, 6).
À quoi sert le mot-clé def en Python ?
- A.À déclarer le type d'une variable
- B.À définir une condition
- C.À définir une fonctionBonne réponse
- D.À afficher un résultat à l'écran
Réponse : C — À définir une fonction
def (pour « define ») sert à définir une fonction : def aire(r): ouvre un bloc d'instructions regroupées sous le nom aire, avec r comme paramètre. Les conditions, elles, s'écrivent avec if / elif / else, et l'affichage se fait avec print. Quant au type des variables, Python le devine tout seul : on n'a jamais besoin de le déclarer.
On définit L = [3, 7, 1, 9]. Que vaut L[2] ?
- A.7
- B.1Bonne réponse
- C.9
- D.3
Réponse : B — 1
Les indices d'une liste commencent à 0 : L[0] vaut 3, L[1] vaut 7, L[2] vaut 1 et L[3] vaut 9. L[2] désigne donc le TROISIÈME élément, c'est-à-dire 1. Répondre 7, c'est compter à partir de 1 comme on le fait naturellement en français. Petite conséquence à retenir : dans cette liste de longueur 4, le dernier indice valide est 3, et écrire L[4] provoque une erreur.
La fonction f est définie par « def f(x) : return 2 * x + 1 ». Que vaut f(f(1)) ?
- A.3
- B.5
- C.4
- D.7Bonne réponse
Réponse : D — 7
On calcule de l'intérieur vers l'extérieur, exactement comme en mathématiques. D'abord f(1) = 2 × 1 + 1 = 3. Puis f(3) = 2 × 3 + 1 = 7. Donc f(f(1)) = 7. Répondre 3, c'est s'arrêter au premier calcul ; répondre 5, c'est calculer f(2) au lieu de f(3). Un bon réflexe : réécris l'expression en remplaçant f(1) par sa valeur avant de continuer.
Que contient la liste L après L = [x * x for x in range(1, 5)] ?
- A.[0, 1, 4, 9, 16]
- B.[1, 4, 9, 16, 25]
- C.[1, 4, 9, 16]Bonne réponse
- D.[2, 4, 6, 8]
Réponse : C — [1, 4, 9, 16]
C'est une construction en compréhension : x parcourt range(1, 5), donc les valeurs 1, 2, 3, 4 (la borne 5 est exclue), et on stocke x * x à chaque fois. On obtient [1, 4, 9, 16]. L'option avec 25 inclut à tort le carré de 5, celle qui commence par 0 inclut à tort le carré de 0. Enfin [2, 4, 6, 8] correspondrait à 2 * x, pas à x * x : ne confonds pas le double et le carré.
On exécute les deux lignes suivantes : x = 3 puis x = x + 4. Que vaut x à la fin ?
- A.3
- B.4
- C.7Bonne réponse
- D.Rien : x = x + 4 est une équation sans solution
Réponse : C — 7
En Python, une affectation se lit de droite à gauche. Python calcule d'abord x + 4 avec la valeur ACTUELLE de x, c'est-à-dire 3 + 4 = 7, puis range ce résultat dans x. La variable x vaut donc 7. C'est le point qui déroute le plus au début : en mathématiques, x = x + 4 n'a effectivement aucune solution, mais en informatique le signe = n'est pas une égalité, c'est un ordre donné à la machine.
Quel opérateur permet de TESTER si deux valeurs sont égales ?
- A.==Bonne réponse
- B.=
- C.!=
- D.<=
Réponse : A — ==
Le test d'égalité s'écrit avec un double signe égal : x == 5 renvoie True ou False sans rien modifier. Le simple signe = est réservé à l'affectation : x = 5 range 5 dans x. Écrire if x = 5: déclenche une erreur de syntaxe. Quant à != , c'est le test « est différent de », l'inverse exact de ==.
Que renvoie 7 / 2 en Python ?
- A.3
- B.3.5Bonne réponse
- C.1
- D.4
Réponse : B — 3.5
L'opérateur / est la division habituelle : elle renvoie toujours un nombre décimal (un float), ici 3.5. Attention à ne pas la confondre avec ses deux voisines : 7 // 2 vaut 3, c'est le quotient entier, et 7 % 2 vaut 1, c'est le reste. Python n'arrondit jamais tout seul à l'entier le plus proche, donc la réponse 4 est impossible.
Que vaut len([2, 5, 8, 11]) ?
- A.4Bonne réponse
- B.3
- C.11
- D.26
Réponse : A — 4
len renvoie le NOMBRE d'éléments de la liste : il y en a quatre (2, 5, 8 et 11), donc len vaut 4. Répondre 3, c'est confondre la longueur avec le plus grand indice (les indices vont ici de 0 à 3). Répondre 11, c'est donner le dernier élément, et 26 serait la somme des éléments : len ne calcule rien, elle compte.
Que valent respectivement 7 // 2 et 7 % 2 ?
- A.3.5 et 3.5
- B.3 et 1Bonne réponse
- C.1 et 3
- D.3 et 0
Réponse : B — 3 et 1
La division euclidienne de 7 par 2 s'écrit 7 = 2 × 3 + 1. L'opérateur // donne le quotient entier, soit 3, et % donne le reste, soit 1. L'ordre compte : // pour le quotient, % pour le reste. Si le reste valait 0, cela signifierait que 7 est divisible par 2, ce qui est faux puisque 7 est impair. Ce test n % 2 == 0 est justement la manière standard de vérifier la parité d'un nombre.
On exécute : total = 0, puis « for i in range(1, 5) : total = total + i ». Que vaut total à la fin ?
- A.15
- B.5
- C.4
- D.10Bonne réponse
Réponse : D — 10
range(1, 5) fait prendre à i les valeurs 1, 2, 3 et 4 (la borne 5 est exclue). On accumule : total vaut successivement 1, puis 3, puis 6, puis 10. Le résultat final est donc 1 + 2 + 3 + 4 = 10. Répondre 15, c'est avoir inclus le 5 à tort — c'est l'erreur la plus fréquente sur range. Répondre 4, c'est donner le nombre de tours et non la somme accumulée.
On exécute : x = 1, puis « while x < 20 : x = x * 3 ». Que vaut x à la sortie de la boucle ?
- A.27Bonne réponse
- B.20
- C.21
- D.9
Réponse : A — 27
Déroulons : x vaut 1, le test 1 < 20 est vrai donc x devient 3 ; 3 < 20 est vrai, x devient 9 ; 9 < 20 est vrai, x devient 27 ; enfin 27 < 20 est faux, la boucle s'arrête. La réponse est 27. Le point clé : la condition n'est vérifiée qu'AU DÉBUT de chaque tour, jamais au milieu. La boucle ne s'arrête donc pas pile à 20, elle dépasse. Répondre 9, c'est arrêter la boucle un tour trop tôt.
S'entraîner sur ce chapitre
Ce chapitre compte 35 exercices corrigés dans l'application, avec le suivi de ta progression.
Commencer les exercices