Calculer et simuler avec Python et le tableur

Un algorithme décrit une succession d’instructions permettant de résoudre une famille de problèmes. Avant de programmer, précise les données de départ, les opérations et le résultat recherché. Dans une entreprise fictive, calculer le prix après remise demande un prix initial et un taux. Le résultat dépend de ces deux entrées. Le programme automatise la règle choisie ; il ne décide pas si cette règle représente correctement une pratique commerciale. Il faut donc séparer le modèle, sa traduction en instructions et la vérification du résultat.

Une variable associe un nom à une valeur qui peut être remplacée. En Python, prix = 80 affecte la valeur 80 au nom prix. L’instruction prix = prix + 5 lit d’abord l’ancienne valeur, calcule 85, puis remplace la valeur associée à prix. Ce n’est pas une égalité mathématique entre un nombre et lui-même augmenté de cinq. Le signe == teste une égalité ; le signe = réalise une affectation. Dans un algorithme rédigé en français, la flèche ← évite cette confusion.

Python distingue notamment les entiers, les nombres décimaux approchés, les textes et les booléens True ou False. Le séparateur décimal du code est le point : 0.04 représente quatre centièmes. Une chaîne entre guillemets, comme "80", est un texte, pas le nombre 80. Les parenthèses organisent les calculs. Le signe * multiplie et / divise. Pour obtenir le carré de x, on peut écrire x*x. Les noms de variables doivent rester explicites et une variable doit recevoir une valeur avant son premier usage.

Une fonction définie avec def regroupe un calcul réutilisable. Ses paramètres sont les noms des entrées. return renvoie une valeur que le programme appelant peut réutiliser ; print affiche un résultat. Dans une fonction comportant plusieurs lignes, les instructions du corps sont indentées de la même manière, habituellement de quatre espaces. Le deux-points termine la ligne de définition. Une fonction peut appeler une autre fonction : cette décomposition permet de contrôler séparément les étapes d’un calcul complexe.

Une boucle répète des instructions. Quand le nombre de répétitions est connu, for convient. range(5) fournit les cinq entiers 0, 1, 2, 3 et 4 : la borne finale est exclue. Quand on cherche le premier dépassement d’un seuil, while teste une condition avant chaque répétition. La boucle peut donc ne jamais commencer si la condition est déjà fausse. Pour éviter une répétition infinie, il faut expliquer pourquoi les valeurs mises à jour feront finalement échouer le test.

Pour additionner des valeurs, initialise un accumulateur à zéro. Pour multiplier des valeurs, initialise-le à un. Un compteur commence souvent à zéro et augmente de un lorsqu’un événement se produit. L’initialisation se place avant la boucle ; la répéter à l’intérieur effacerait le travail précédent. Dans le suivi d’un montant, distingue le nombre de passages et le nombre d’états : un état initial suivi de cinq mises à jour donne six valeurs observées.

Une formule de tableur commence par =. Lorsqu’on recopie =B2+20 de B3 vers B4, la référence relative B2 devient B3. Si le supplément est placé en E1, écris =B2+$E$1 : les deux signes $ fixent la colonne et la ligne de ce paramètre. Tu peux alors modifier E1 pour comparer des scénarios. Les intitulés de colonnes et les unités permettent à une autre personne de comprendre la feuille. Afficher deux décimales ne modifie pas forcément la valeur conservée pour les calculs suivants.

Une condition permet de choisir un traitement. En Python, if montant > 150 teste un dépassement strict. L’égalité à 150 donne False. Pour accepter cette égalité, il faut >=. Le connecteur and exige que les deux conditions soient vraies ; or accepte au moins une condition vraie, y compris les deux. not inverse la valeur logique. Par exemple, 0 <= taux and taux <= 1 vérifie que le taux appartient à l’intervalle fermé de zéro à un.

Une liste regroupe plusieurs valeurs ordonnées. ventes = [12, 8, 15] crée une liste par extension, c’est-à-dire en écrivant ses éléments. Le premier indice est zéro : ventes[0] vaut 12, ventes[2] vaut 15. len(ventes) donne le nombre d’éléments, ici trois ; l’indice 3 serait donc hors de la liste. ventes.append(10) ajoute 10 à la fin. ventes.pop() retire et renvoie le dernier élément. Ces opérations changent la liste.

Une liste peut aussi être construite par ajouts successifs : initialise valeurs = [] puis utilise une boucle qui ajoute chaque résultat avec append. L’écriture carres = [n*n for n in range(6)] est une construction en compréhension. Elle produit [0, 1, 4, 9, 16, 25]. La variable n prend successivement chaque valeur proposée par range(6). On peut parcourir directement les valeurs avec for v in ventes, sans avoir besoin de connaître leur indice.

Sélectionner des données consiste à garder les éléments qui satisfont une condition. Par exemple, [v for v in ventes if v >= 10] conserve les ventes au moins égales à dix. Sur un fichier de données, commence par repérer les noms des colonnes, les unités et les éventuelles cellules vides ; ne transforme pas une absence de donnée en zéro sans justification. Un tableau croisé répartit ensuite les observations selon deux critères. Chaque observation doit être comptée une fois dans la case correspondant à ses deux catégories.

Dans un fichier fictif de quatre commandes, les lignes portent les couples de catégories suivants : retrait et payé ; livraison et payé ; livraison et impayé ; retrait et payé. Le tableau croisé contient deux commandes retrait/payé, zéro retrait/impayé, une livraison/payé et une livraison/impayé. Le total des quatre cases vaut quatre. Dans un tableur, filtre les colonnes ou utilise un tableau croisé pour retrouver ce classement ; contrôle ensuite les totaux de lignes et de colonnes avant d’interpréter les proportions.

Une simulation reproduit les règles d’un modèle, pas une certitude sur l’avenir. Pour simuler un succès de probabilité 0,3, on peut tirer un nombre avec random(), fourni par from random import random, puis tester random() < 0.3. Cette fonction fournit un nombre pseudo-aléatoire dans l’intervalle de zéro inclus à un exclu. Un compteur dénombre les succès. Sur N répétitions, la fréquence obtenue vaut compteur/N. Elle varie d’une simulation à l’autre et n’est pas nécessairement égale à 0,3.

Tester plusieurs entrées ne prouve pas qu’un programme fonctionne pour toutes les entrées possibles. Un contre-exemple suffit cependant à réfuter une affirmation universelle. Si quelqu’un affirme que x*x est toujours supérieur ou égal à x, le nombre 0,5 donne 0,25, inférieur à 0,5 : l’affirmation est fausse sur les réels. En revanche, réussir cent essais ne suffit pas à établir une propriété sur une infinité de nombres. Il faut distinguer observation, conjecture et démonstration.

Pour poursuivre, ouvre S’entraîner à l’adresse /exercices.