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
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.
- 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
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].