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 coeur de la programmation : elles permettent de répéter des instructions. La boucle for est 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) → 1, 2, 3, 4, 5
- range(a, b, pas) permet un pas différent de 1. range(0, 10, 2) → 0, 2, 4, 6, 8
- Boucle while : while condition: ... s'exécute tant que la condition est True
- Attention : une boucle while peut boucler infiniment 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. n = 0 ; while 2**n <= 1000: n = n + 1
Exemple
Calculer la somme 1 + 2 + ... + 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 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
- 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 return, 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 : [expression for i in range(n)]. Exemple : [i**2 for i in range(5)] → [0, 1, 4, 9, 16]
- Parcours : for element in L: ... ou for i in range(len(L)): ... L[i] ...
- Erreur fréquente : accéder à L[len(L)] provoque une erreur (IndexError), le dernier indice est len(L)-1
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 ! L = [10, 20, 30] : L[0] = 10, L[1] = 20, L[2] = 30. L[3] provoque une erreur IndexError. Le dernier élément est L[len(L)-1] ou plus simplement 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 → m = 7 ; 2 < 7 → rien ; 9 > 7 → m = 9 ; 4 < 9 → 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, fréquence ≈ probabilité
- Exemple : estimer P(somme de 2 dés = 7). Simuler 10000 lancers et compter le nombre de fois où la somme est 7
- Plus N est grand, plus l'estimation est précise (loi des grands nombres)
Exemple
Estimer P(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. Fréquence = compteur/10000 ≈ 0.167. Théorie : P = 6/36 = 1/6 ≈ 0.1667 ✓.
Piège à éviter
random.randint(a, b) inclut BOTH 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].