Maths (Spé) — Algorithmique et programmation
Algorithmique et programmation Python
Boucles, fonctions, listes, algorithmes de recherche et simulation probabiliste en Python
Résumé synthétiqueFiche en 5 sectionsQuiz de 10 questionsGratuit, sans pub
Cours de spé Maths. Même notion dans une autre matière : Algorithmique et programmation Python — maths du tronc commun · Programmation Python en SI — spé Sciences de l'ingénieur
Résumé
L'algorithmique est l'art de concevoir des procédures systématiques pour résoudre des problèmes. En Première, on approfondit la programmation Python avec les boucles for (pour un nombre connu de répétitions) et while (tant qu'une condition est vérifiée), les fonctions (def nom(paramètres): … return résultat), et les listes (collections ordonnées d'éléments). Par exemple, pour calculer la somme des $n$ premiers entiers, on écrit : s = 0 puis for i in range(1, n+1): s = s + i. Les listes permettent de stocker et manipuler des données : L = [3, 1, 4, 1, 5], L[0] donne $3$, len(L) donne $5$. On utilise aussi Python pour simuler des expériences aléatoires avec le module random (random.random(), random.randint(a, b)), ce qui permet d'estimer des probabilités par la méthode fréquentiste.
Les boucles sont le cœur de la programmation : elles permettent de répéter des instructions. La boucle for sert pour un nombre connu de répétitions, la boucle while pour une condition d'arrêt.
Les deux types de boucles en Python : for (compteur) et while (condition)
- Boucle for : for i in range(n) exécute le bloc $n$ fois, $i$ allant de $0$ à $n-1$.
- range(a, b) donne les entiers de $a$ (inclus) à $b$ (exclu). range(1, 6) donne $1, 2, 3, 4, 5$.
- range(a, b, pas) permet un pas différent de $1$. range(0, 10, 2) donne $0, 2, 4, 6, 8$.
- Boucle while : while condition: … s'exécute tant que la condition est True.
- Attention : une boucle while peut boucler à l'infini si la condition ne devient jamais False.
- Quand utiliser for : nombre de répétitions connu. Quand utiliser while : condition d'arrêt.
- Exemple while : trouver le plus petit $n$ tel que $2^n > 1000$. On écrit n = 0 ; while 2**n <= 1000: n = n + 1.
Exemple
Calculer la somme $1 + 2 + \dots + 100$ avec une boucle for : s = 0 puis for i in range(1, 101): s = s + i. Résultat : $s = 5050$. Avec while : s = 0, i = 1 puis while i <= 100: s = s + i, i = i + 1. Même résultat, mais la boucle for est plus claire ici.
Piège à éviter
range(n) va de $0$ à $n-1$ ($n$ est exclu). Pour aller de $1$ à $n$ inclus, utilisez range(1, n+1). L'erreur classique est d'écrire range(1, n), qui s'arrête à $n-1$. Vérifiez toujours avec un petit exemple : range(1, 4) donne $1, 2, 3$.
Les fonctions permettent de structurer un programme en blocs réutilisables. En maths, elles sont indispensables pour coder des formules et des algorithmes.
- Syntaxe : def nom_fonction(paramètres): puis instructions indentées, terminées par return résultat.
- Exemple : def carre(x): return x**2. Appel : carre(5) renvoie $25$.
- Une fonction peut avoir plusieurs paramètres : def somme(a, b): return a + b.
- Le mot-clé return termine l'exécution de la fonction et renvoie la valeur.
- Sans return, la fonction renvoie None par défaut.
- Variables locales : les variables définies dans la fonction n'existent qu'à l'intérieur de celle-ci.
- Exemple : def factorielle(n): r = 1 ; for i in range(1, n+1): r = r * i ; return r.
Exemple
def est_premier(n): if n < 2: return False ; for i in range(2, n): if n % i == 0: return False ; return True. Appel : est_premier(7) renvoie True, est_premier(12) renvoie False (car 12 % 2 == 0).
Piège à éviter
N'oubliez pas le return ! Sans lui, la fonction renvoie None et votre résultat est perdu. Erreur classique : écrire print(resultat) au lieu de return resultat. print affiche à l'écran mais ne renvoie pas la valeur.
Les listes sont des collections ordonnées qui stockent plusieurs valeurs. Elles sont omniprésentes en Python et permettent de manipuler des données, des résultats d'expériences ou des termes de suites.
- Création : L = [3, 1, 4, 1, 5] ou L = [] (liste vide).
- Accès : L[0] est le premier élément, L[-1] est le dernier. Les indices commencent à $0$ !
- Longueur : len(L) donne le nombre d'éléments.
- Ajout : L.append(x) ajoute $x$ à la fin de la liste.
- Liste en compréhension : [i**2 for i in range(5)] donne [0, 1, 4, 9, 16].
- Parcours : for element in L: … ou for i in range(len(L)): … L[i] …
Exemple
Construire la liste des $10$ premiers termes de la suite $u_0 = 1$, $u_{n+1} = 2u_n + 1$ : L = [1] puis for i in range(9): L.append(2 * L[-1] + 1). Résultat : L = [1, 3, 7, 15, 31, 63, 127, 255, 511, 1023]. On utilise L[-1] pour accéder au dernier élément.
Piège à éviter
Les indices commencent à $0$ en Python ! Pour L = [10, 20, 30] : L[0] = 10, L[1] = 20, L[2] = 30, et L[3] provoque une erreur IndexError. Accéder à L[len(L)] provoque la même erreur : le dernier indice est len(L)-1, ou plus simplement -1 avec L[-1].
Les algorithmes classiques (somme, maximum, comptage, recherche) reviennent dans tous les exercices de programmation. Savoir les écrire de mémoire est un gain de temps considérable.
- Somme des éléments : s = 0 ; for x in L: s = s + x (ou sum(L)).
- Recherche du maximum : m = L[0] ; for x in L: if x > m: m = x.
- Comptage : c = 0 ; for x in L: if condition(x): c = c + 1.
- Recherche d'un élément : for x in L: if x == valeur: return True.
- Algorithme de seuil (avec while) : trouver le premier $n$ tel qu'une condition est vérifiée.
- Calcul des termes d'une suite : u = u0 ; for i in range(n): u = f(u) (suite récurrente).
Exemple
Recherche du maximum dans une liste : L = [3, 7, 2, 9, 4]. m = L[0] (soit $3$). On parcourt : $7 > 3 \to m = 7$ ; $2 < 7 \to$ rien ; $9 > 7 \to m = 9$ ; $4 < 9 \to$ rien. Résultat : $m = 9$. En Python : m = L[0] puis for x in L: if x > m: m = x.
Piège à éviter
Pour initialiser le maximum, utilisez m = L[0] (premier élément), pas m = 0 ! Si la liste contient des nombres négatifs (ex. [-5, -3, -1]), m = 0 donnerait $0$ comme « maximum » alors que $0$ n'est pas dans la liste.
Python permet de simuler des expériences aléatoires et d'estimer des probabilités par la méthode fréquentiste. Plus le nombre de simulations est grand, plus l'estimation est précise.
- import random en début de programme.
- random.random() renvoie un flottant aléatoire dans $[0\,;1[$.
- random.randint(a, b) renvoie un entier aléatoire entre $a$ et $b$ inclus.
- Simuler un dé : random.randint(1, 6).
- Simuler un événement de probabilité $p$ : if random.random() < p: (succès).
- Estimer une probabilité : répéter $N$ fois l'expérience, compter les succès ; la fréquence $\approx$ probabilité.
- Exemple : estimer $P(\text{somme de 2 dés} = 7)$ en simulant $10\,000$ lancers et en comptant les sommes égales à $7$.
- Plus $N$ est grand, plus l'estimation est précise (loi des grands nombres).
Exemple
Estimer $P(\text{somme de 2 dés} = 7)$ : import random ; compteur = 0 ; for i in range(10000): d1 = random.randint(1,6) ; d2 = random.randint(1,6) ; if d1 + d2 == 7: compteur += 1. La fréquence vaut $\dfrac{\text{compteur}}{10000} \approx 0{,}167$. Théorie : $P = \dfrac{6}{36} = \dfrac{1}{6} \approx 0{,}1667$.
Piège à éviter
random.randint(a, b) inclut les deux bornes $a$ et $b$. C'est une exception en Python, où d'habitude la borne supérieure est exclue (comme dans range). Pour un dé, random.randint(1, 6) est correct ; random.randint(1, 7) donnerait un « dé à $7$ faces ».
Quiz - Algorithmique et programmation Python
10 questions
S'entraîner
- Quiz : Algorithmique et programmation Python10 questions corrigées sur ce chapitre
- Épreuve anticipée de mathsFormat, barème et préparation
- AutomatismesLes questions flash de l'épreuve anticipée
- Bac Mathématiques : le guideProgramme, méthodes et calendrier
- Aide aux devoirs de MathsLes notions qui bloquent en Première
Thème complet
Voir tous les chapitres « Algorithmique et programmation » de la Seconde à la Terminale
Ce thème dans une autre classe
Notions clés — Maths (Spé)
Articles utiles
Questions fréquentes
Les points clés à retenir sur Algorithmique et programmation Python, extraits du quiz de révision.
Que renvoie range(1, 5) ?
Réponse :
$1, 2, 3, 4$
range(1, 5) produit les entiers de $1$ (inclus) à $5$ (exclu) : $1, 2, 3, 4$.
Que vaut L[0] si L = [7, 3, 9, 1] ?
Réponse :
$7$
Les indices commencent à $0$. L[0] est le premier élément : $7$.
Quelle boucle utiliser quand on ne connaît pas le nombre de répétitions ?
Réponse :
while
La boucle while s'exécute tant qu'une condition est vraie, utile quand on ne sait pas à l'avance le nombre d'itérations.
Que fait L.append(5) si L = [1, 2, 3] ?
Réponse :
L = [1, 2, 3, 5]
append ajoute l'élément à la fin de la liste. L devient [1, 2, 3, 5].