Algorithmes Python et simulations

Python et simulations

Environ 45 minutes

  • Tracer un algorithme.
  • Construire une fonction sur des listes.
  • Simuler une loi et discuter une fréquence.
Sommaire
  1. 1. Décrire une tâche avant de programmer
  2. 2. Utiliser des listes et des fonctions simples
  3. 3. Simuler des essais aléatoires sans les confondre avec une preuve
  4. 4. Vérifier le programme et sa portée
  5. S’entraîner

Une simulation peut-elle être convaincante tout en étant fausse ?

Python permet de calculer des sommes, de sélectionner des mesures et de répéter des expériences aléatoires. Ces outils gagnent en intérêt quand on sait expliquer ce que chaque variable représente. Cet atelier reprend les variables, les fonctions, les listes et les boucles au fil de tâches mathématiques, puis apprend à vérifier les résultats et les limites d’une simulation.

1. Décrire une tâche avant de programmer

Cet atelier se réinvestit dans les suites, les probabilités et l’étude de données. Un algorithme est une suite d’instructions qui transforme des données d’entrée en un résultat. Avant d’écrire du Python, précise la question, les entrées et la sortie attendue. Une fonction qui reçoit un nombre d’essais et renvoie un nombre de succès n’a pas le même rôle qu’une fonction qui répète des séries et renvoie une fréquence.

Une variable conserve une valeur qui peut être modifiée. L’affectation Python s = s + 1 remplace la valeur de s par son ancienne valeur augmentée de 1 ; ce n’est pas une égalité mathématique à résoudre. Le symbole = sert à affecter, tandis que == sert à comparer. Les noms doivent exprimer le rôle de la variable : n pour la taille d’une série, N pour le nombre de séries, p pour une probabilité.

Un compteur dénombre des occurrences, souvent en ajoutant 1. Un accumulateur additionne des contributions, par exemple des carrés ou des coûts. Pour une somme, on l’initialise à 0 ; pour un produit, à 1. Initialiser un produit à 0 le laisserait nul à chaque multiplication. Le choix de la valeur de départ fait donc partie du raisonnement, pas seulement de la syntaxe.

Exemple résolu

On veut calculer la somme des carrés des entiers de 1 à n. Décris un algorithme et vérifie le résultat pour n = 4.

  1. Étape 1 : Entrée : un entier n positif ou nul. Sortie : la somme 1² + 2² + … + n². On initialise l’accumulateur s à 0.
  2. Étape 2 : Pour chaque entier k de 1 à n inclus, on remplace s par s + k*k. En Python, range(1, n+1) parcourt exactement ces entiers, car la borne de droite est exclue.
  3. Étape 3 : Pour n = 4, les valeurs successives de s sont 1, 5, 14 et 30.
  4. Étape 4 : Une version compacte utilisant une liste est : def somme_carres(n): return sum([k*k for k in range(1, n+1)])

Résultat : L’appel somme_carres(4) renvoie 30. Pour n = 0, la liste est vide et sum renvoie 0, ce qui correspond à une somme sans terme.

Piège à éviter : Utiliser range(1, n) omet le dernier terme n² ; le programme peut s’exécuter sans erreur tout en répondant faux.

Le cumul augmente à chaque rang du carré du nouvel entier ; au rang 4, la somme vaut 30.

À toi d'essayer

Pour calculer la somme des carrés de 1 à 6 inclus, un programme parcourt range(1, 6). Corrige cette borne et détermine le résultat attendu. Explique l’erreur sans exécuter le programme.

Voir la réponse

La borne supérieure est exclue : range(1, 6) s’arrête à 5 et omet 6². Il faut écrire range(1, 7). Le résultat correct est 1 + 4 + 9 + 16 + 25 + 36 = 91. Le programme initial additionne seulement cinq termes alors que la question en demande six.

2. Utiliser des listes et des fonctions simples

Une liste rassemble plusieurs valeurs dans un ordre donné. Pour L = [2, 5, 8], les indices commencent à zéro : L[0] vaut 2 et L[2] vaut 8. L’indice 3 n’existe pas. L.append(11) ajoute une valeur en fin de liste ; del L[1] retire l’élément d’indice 1. Les indices suivants se décalent après une suppression : on évite de modifier une liste pendant qu’on la parcourt sans avoir prévu cet effet.

Une liste peut être écrite directement, construite par ajouts successifs ou définie en compréhension. L’expression [k*k for k in range(1, 5)] produit [1, 4, 9, 16]. L’expression [x for x in L if x > 4] sélectionne les éléments de L strictement supérieurs à 4. Les crochets font partie de la syntaxe. Dans une condition, and signifie que les deux critères sont vrais, or qu’au moins un l’est, et not inverse une condition.

Une fonction se définit avec def, reçoit ses paramètres entre parenthèses et renvoie un résultat avec return. Dans une écriture sur plusieurs lignes, les instructions appartenant à la fonction sont indentées de quatre espaces ; une boucle ou une condition peut introduire un niveau supplémentaire. Toutes les instructions d’un même bloc doivent conserver la même indentation. print affiche une information, tandis que return transmet une valeur à la suite du programme.

Exemple résolu

Une liste de mesures est L = [18, 21, 19, 24, 20]. On cherche la moyenne des mesures supérieures ou égales à 20. Construis le calcul et précise le cas où aucune mesure ne serait retenue.

  1. Étape 1 : Le filtre [x for x in L if x >= 20] donne la liste [21, 24, 20]. Le signe >= conserve ici la mesure égale à 20.
  2. Étape 2 : La somme vaut 65 et le nombre de valeurs retenues vaut 3. Leur moyenne est 65/3, soit environ 21,67.
  3. Étape 3 : Une fonction réutilisable pour une liste non vide est : def moyenne(L): return sum(L)/len(L)
  4. Étape 4 : Avant l’appel, on vérifie que la liste filtrée contient au moins une valeur ; sinon on ne calcule pas de moyenne.

Résultat : La moyenne des mesures retenues est environ 21,67 dans l’unité des mesures. Si le filtre ne retient rien, la moyenne est indéfinie et il faut l’indiquer explicitement.

Piège à éviter : Remplacer une liste vide par une moyenne nulle invente une mesure ; diviser par la longueur zéro déclenche une erreur.

Pour analyser des données venues d’un fichier, commence par identifier les colonnes, les unités et le séparateur. Un tableur peut préparer une liste, mais il faut distinguer une valeur manquante d’un zéro mesuré et convertir les nombres décimaux correctement. Un tableau croisé à deux critères se construit en comptant les quatre combinaisons vrai-vrai, vrai-faux, faux-vrai et faux-faux. La somme des quatre effectifs doit retrouver le nombre d’observations exploitées.

À toi d'essayer

Après L = [3, 7, 9], on exécute L.append(12), puis del L[1]. Quelle liste reste-t-il ? Que vaut ensuite L[1] ?

Correction détaillée pas à pasDans ce chapitre : 2 corrections détaillées.

3. Simuler des essais aléatoires sans les confondre avec une preuve

La fonction random du module random fournit un nombre pseudo-aléatoire dans l’intervalle de 0 inclus à 1 exclu. On commence par l’instruction from random import random. Pour simuler une épreuve de Bernoulli de paramètre p, on teste random() < p. La portion de l’intervalle acceptée a une longueur p ; dans le modèle uniforme, elle représente une probabilité p. Le test est toujours faux pour p = 0 et toujours vrai pour p = 1.

Pour compter les succès d’une série de n essais, on répète ce test n fois. Python représente True par 1 et False par 0 lorsqu’on les additionne. La fonction suivante renvoie donc un nombre entier de succès : def serie(n, p): return sum([random() < p for k in range(n)]). Il faut ici n entier positif ou nul et 0 ≤ p ≤ 1. Les appels pseudo-aléatoires successifs servent à modéliser des essais indépendants.

Exemple résolu

On veut estimer la probabilité d’obtenir au moins deux succès dans une série de quatre essais indépendants de paramètre 0,3. Explique une simulation avec N séries et compare-la au calcul exact.

  1. Étape 1 : Une série est obtenue par serie(4, 0.3). En Python, les décimaux utilisent un point, contrairement à la rédaction mathématique française.
  2. Étape 2 : On construit les résultats par [serie(4, 0.3) for j in range(N)], avec N strictement positif.
  3. Étape 3 : On compte les résultats supérieurs ou égaux à 2, puis on divise ce nombre par N. Le dénominateur compte des séries, pas des essais élémentaires.
  4. Étape 4 : Le calcul exact donne 1 − 0,7⁴ − 4 × 0,3 × 0,7³ = 0,3483. La simulation fournit une fréquence qui fluctue autour de cette valeur.

Résultat : La probabilité théorique est 0,3483. Une simulation peut en donner une estimation, mais son résultat n’est pas censé reproduire exactement les quatre décimales pour toute valeur de N.

Piège à éviter : Diviser par 4N transforme la fréquence des séries répondant au critère en un autre quotient, qui ne mesure plus l’événement demandé.

Les hauteurs sont des fréquences de simulation ; elles approchent les probabilités binomiales sans leur être forcément égales.

La figure provient de 2 000 séries de quatre essais, avec p = 0,3. Une graine fixe du générateur permet de retrouver les mêmes tirages pour vérifier un programme. Elle ne rend pas les fréquences théoriquement exactes. Pour les cinq valeurs de 0 à 4, les probabilités binomiales sont respectivement 0,2401 ; 0,4116 ; 0,2646 ; 0,0756 et 0,0081. Le rapprochement avec les hauteurs observées aide à détecter une erreur de simulation.

À toi d'essayer

Un camarade simule N séries ainsi : il calcule une seule fois x = serie(4, 0.3), puis construit [x for j in range(N)]. Il augmente N et pense améliorer son estimation. Explique le défaut et propose la correction.

Correction détaillée pas à pasDans ce chapitre : 2 corrections détaillées.

4. Vérifier le programme et sa portée

Au bac : expliquer et contrôler un algorithme

  1. Annonce les entrées et la sortie. Précise les domaines admis, par exemple n entier positif ou nul et N strictement positif.
  2. Repère les initialisations et le rôle de chaque boucle. Fais une trace à la main sur un petit exemple dont la réponse est connue.
  3. Teste les cas limites : liste vide, aucun essai, probabilité 0 ou 1, valeur exactement égale à un seuil.
  4. Compare la sortie à un calcul indépendant. Pour une simulation, distingue l’écart normal de fluctuation d’une erreur systématique de logique.
Attention :

Erreurs fréquentes : oublier de remettre le compteur à zéro entre deux séries ; confondre n et N ; placer return à l’intérieur d’une boucle alors que l’on veut son résultat final ; utiliser une virgule décimale dans le code ; compter une seule simulation répétée comme plusieurs expériences.

Un test réussi ne suffit pas à démontrer qu’un programme est correct pour toutes ses entrées. Il faut aussi relire sa logique et justifier sa terminaison. Une boucle for sur une liste finie se termine après son parcours. Pour une boucle while, la condition doit évoluer vers une situation où elle devient fausse ; sinon le programme peut rester dans la boucle. On prévoit une borne lorsque la terminaison n’est pas mathématiquement assurée.

Enfin, un programme correct peut simuler un modèle inadapté. Il peut imposer l’indépendance alors que les essais réels partagent une panne commune, ou utiliser une probabilité qui varie avec le temps. Il faut donc contrôler séparément la traduction informatique et les hypothèses scientifiques. La simulation explore les conséquences d’un modèle ; elle ne prouve pas que ce modèle décrit tout le phénomène.

Vocabulaire

Compteur :
Variable qui dénombre les occurrences d’un événement.
Accumulateur :
Variable qui conserve une somme ou un produit construit progressivement.
Indice :
Position d’un élément dans une liste, en commençant à zéro.
Fréquence simulée :
Nombre de réalisations d’un événement divisé par le nombre d’expériences simulées.

Bilan

SituationRelation ou précaution
SommeInitialisation à 0, puis ajout des contributions.
BernoulliTest random() < p après import.
FréquenceNombre de séries favorables divisé par N.
ValidationPetits cas exacts, bornes et relecture du modèle.

S’entraîner

Poursuis sur le hub d’exercices d’AlloSTI, accessible à l’adresse https://www.allosti.fr/exercices. Choisis une activité correspondant à cette notion et explique tes réponses avant de consulter une correction.

À retenir

  • Un accumulateur de somme commence à 0 ; un accumulateur de produit commence à 1.
  • Les indices d’une liste commencent à zéro et la borne de droite de range est exclue.
  • Le test random() < p simule un succès de probabilité p dans le modèle uniforme.
  • Une fréquence de simulation fluctue ; elle n’est pas une démonstration de la probabilité exacte.

Fiche de révision

Pour écrire une fonction, commence par la phrase reçoit… et renvoie… ; elle précise le contrat de ton calcul.

Une trace sur quatre termes suffit souvent à repérer une borne oubliée ou une réinitialisation mal placée.

Dans une estimation, identifie l’expérience répétée avant de choisir le dénominateur : des essais ou des séries entières.

Teste aussi un résultat vide et les paramètres extrêmes ; une erreur de modèle peut subsister après tous les tests informatiques.

Et maintenant ?

Tu as lu le cours. L’étape suivante tient en une action.

S’entraîner sur ce chapitreUn exercice dans l’espace Exercices

Prolonge l’expérience !

Continue à explorer ce chapitre à travers de nouvelles activités, des défis et des expériences interactives. Avec Premium, l’apprentissage continue !

Ici, tu débloques aussi 2 corrections détaillées.

Parent ? Suivez les progrès de votre enfant.

S’entraîner sur cette notion

Tous les cours de Terminale STI2D — Mathématiques technologiques
Scientia