Cours
1. Information chiffrée : appliquer une évolution
Pour augmenter une valeur de t %, on la multiplie par
1 + t / 100. La fonction suivante peut traiter une hausse ou une baisse.
def valeur_finale(valeur, taux):
return valeur * (1 + taux / 100)
print(valeur_finale(80, 15))
print(valeur_finale(80, -15))
Le premier appel renvoie 92. Le second modélise une baisse de 15 %.
2. Fonctions : calculer des images
Une fonction Python peut traduire une fonction mathématique. On peut ensuite produire un tableau de valeurs.
def f(x):
return x ** 2 - 3 * x + 2
for x in range(-2, 5):
print(x, f(x))
Le programme affiche les images des entiers de −2 à 4. Ces valeurs peuvent aider à conjecturer des variations ou des extremums, qui doivent ensuite être justifiés.
3. Algèbre : chercher une valeur approchée
Une boucle while permet d’obtenir un encadrement de √2 par balayage.
x = 1.0
pas = 0.01
while (x + pas) ** 2 <= 2:
x = x + pas
print(x, x + pas)
Le programme donne deux centièmes consécutifs qui encadrent √2. Diminuer le pas améliore la précision, mais augmente le nombre d’itérations.
4. Géométrie repérée : tester un alignement
Les points A, B et C sont alignés si les vecteurs AB et AC sont colinéaires, c’est-à-dire si leur déterminant est nul.
def sont_alignes(xA, yA, xB, yB, xC, yC):
determinant = (xB - xA) * (yC - yA) \
- (yB - yA) * (xC - xA)
return determinant == 0
print(sont_alignes(0, 1, 2, 5, 3, 7))
La fonction renvoie un booléen : True si les trois points sont
alignés et False sinon.
5. Statistiques : calculer une moyenne
Le programme suivant calcule une moyenne à partir d’une série de valeurs. Les listes sont utilisées ici comme support ; leur connaissance détaillée n’est pas exigible en seconde.
def moyenne(valeurs):
total = 0
for valeur in valeurs:
total = total + valeur
return total / len(valeurs)
donnees = [8, 10, 12, 14, 16]
print(moyenne(donnees))
Lire un programme calculant une moyenne ou un écart type fait partie des capacités attendues, même si l’écriture complète avec des listes n’est pas exigée.
6. Probabilités : simuler une expérience aléatoire
Une fonction peut renvoyer le résultat numérique d’une expérience aléatoire. La répétition permet d’observer la fluctuation d’une fréquence.
from random import randint
def lancer_de():
return randint(1, 6)
def frequence_six(n):
succes = 0
for i in range(n):
if lancer_de() == 6:
succes = succes + 1
return succes / n
print(frequence_six(1000))
Le résultat varie d’une exécution à l’autre et tend à se rapprocher de 1/6 lorsque le nombre de lancers augmente.
Méthode : passer des mathématiques au programme
1. Identifier les données et le résultat attendu. 2. Décrire l’algorithme en langage naturel. 3. Choisir les variables, conditions, boucles et fonctions. 4. Traduire en Python. 5. Tester sur des cas simples. 6. Interpréter le résultat dans le contexte du problème.
Exercices d’entraînement
Exercice 1 — Pourcentages
Utiliser puis modifier valeur_finale pour calculer le prix d’un
article de 120 € après une remise de 25 %. Vérifier le résultat par un calcul.
Afficher la correction
Une remise de 25 % est une évolution de taux −25. On peut utiliser directement la fonction du cours, puis créer une fonction qui reçoit une remise positive et change son signe.
def valeur_finale(valeur, taux):
return valeur * (1 + taux / 100)
print(valeur_finale(120, -25))
def prix_solde(prix, remise):
return valeur_finale(prix, -remise)
print(prix_solde(120, 25))Les deux appels affichent 90.0, soit 90 €. Vérification : 120 × (1 − 25/100) = 120 × 0,75 = 90 €. La réduction est de 30 €.
Exercice 2 — Tableau de valeurs
Écrire une fonction correspondant à g(x) = 3x − 4, puis afficher g(x) pour tous les entiers de −5 à 5.
Afficher la correction
En Python, on écrit la multiplication avec *. La borne supérieure de range est exclue : on utilise donc range(-5, 6) pour aller jusqu’à 5.
def g(x):
return 3 * x - 4
for x in range(-5, 6):
print(x, g(x))Pour les abscisses −5, −4, −3, −2, −1, 0, 1, 2, 3, 4, 5, les images sont respectivement −19, −16, −13, −10, −7, −4, −1, 2, 5, 8, 11. Par exemple, g(−5) = 3 × (−5) − 4 = −19.
Exercice 3 — Encadrement
Modifier le programme d’encadrement afin d’obtenir deux millièmes consécutifs qui encadrent √5. Expliquer les deux changements effectués.
Afficher la correction
Les deux modifications essentielles sont de remplacer la cible 2 par 5 et le pas 0,01 par 0,001. On peut aussi commencer à 2, car 2² < 5 < 3², pour réduire le nombre d’itérations.
x = 2.0
pas = 0.001
while (x + pas) ** 2 <= 5:
x = x + pas
print(round(x, 3), round(x + pas, 3))Le programme affiche 2.236 et 2.237. La vérification exacte donne 2,236² = 4,999696 < 5 et 2,237² = 5,004169 > 5. Donc 2,236 < √5 < 2,237. Ces deux millièmes sont consécutifs. round facilite seulement l’affichage des flottants ; la vérification des carrés justifie l’encadrement.
Exercice 4 — Géométrie
Utiliser la fonction sont_alignes avec A(1 ; 2), B(3 ; 5) et
C(7 ; 11), puis contrôler le résultat à l’aide d’un calcul de déterminant.
Afficher la correction
On remplace les paramètres par les coordonnées des trois points. Les parenthèses permettent d’écrire le déterminant sur plusieurs lignes sans antislash.
def sont_alignes(xA, yA, xB, yB, xC, yC):
determinant = (
(xB - xA) * (yC - yA)
- (yB - yA) * (xC - xA)
)
return determinant == 0
print(sont_alignes(1, 2, 3, 5, 7, 11))La fonction affiche True. En effet, le vecteur AB a pour coordonnées (3 − 1 ; 5 − 2), soit (2 ; 3), et AC a pour coordonnées (7 − 1 ; 11 − 2), soit (6 ; 9). Leur déterminant vaut 2 × 9 − 3 × 6 = 0 : A, B et C sont alignés.
Exercice 5 — Lire et modifier
Expliquer le rôle des variables total et valeur dans la
fonction moyenne. Modifier les données, puis prévoir le résultat avant
d’exécuter le programme.
Afficher la correction
La variable total accumule la somme des valeurs, en partant de 0. La variable valeur prend successivement chaque élément de la liste. La division finale par len(valeurs) donne la moyenne ; la liste doit être non vide.
def moyenne(valeurs):
total = 0
for valeur in valeurs:
total = total + valeur
return total / len(valeurs)
donnees = [6, 8, 10, 12, 14]
print(moyenne(donnees))Pour les nouvelles données proposées, la somme est 6 + 8 + 10 + 12 + 14 = 50 et l’effectif est 5. On prévoit donc 50/5 = 10 avant l’exécution, qui affiche 10.0. D’autres listes sont possibles : il faut adapter le calcul de vérification.
Exercice 6 — Simulation
Modifier frequence_six pour estimer la fréquence d’obtention d’un
nombre pair. Comparer les résultats pour 20, 200 puis 2 000 lancers.
Afficher la correction
Un entier est pair lorsque le reste de sa division par 2 est nul. On remplace donc le test de succès par randint(1, 6) % 2 == 0. Le nombre n doit être un entier strictement positif.
from random import randint
def frequence_pair(n):
succes = 0
for _ in range(n):
if randint(1, 6) % 2 == 0:
succes = succes + 1
return succes / n
for n in (20, 200, 2000):
print(n, frequence_pair(n))Les issues favorables sont 2, 4 et 6 : la probabilité théorique est 3/6 = 0,5. Les fréquences affichées varient à chaque exécution. Sur de nombreuses répétitions, elles sont généralement plus concentrées autour de 0,5 pour les grandes tailles ; une exécution particulière ne garantit pas un rapprochement régulier.
Exercice 7 — Défi de programmation
Écrire une fonction qui renvoie le nombre de lancers nécessaires pour obtenir un premier 6. Répéter plusieurs fois l’expérience et commenter les résultats.
Afficher la correction
On initialise le compteur à 0 et une valeur de face différente de 6 pour entrer dans la boucle. Chaque passage simule un lancer, puis incrémente le compteur. On s’arrête dès que le premier 6 apparaît.
from random import randint
def attente_premier_six():
nombre_lancers = 0
face = 0
while face != 6:
face = randint(1, 6)
nombre_lancers = nombre_lancers + 1
return nombre_lancers
for _ in range(10):
print(attente_premier_six())Le résultat est un entier au moins égal à 1. Le lancer donnant le premier 6 est inclus dans le compteur. Les dix expériences peuvent donner des nombres différents ; on ne doit pas attendre systématiquement six lancers. Le nombre de lancers n’a pas de maximum fixé : la boucle termine avec probabilité 1 dans le modèle du dé équilibré.
Vidéo
Vidéo explicative sur les applications de Python en mathématiques :
À retenir
Un résultat numérique n’est pas une preuve. Il peut suggérer une conjecture, fournir une approximation ou vérifier un cas, mais il faut toujours revenir au sens mathématique du problème.
Tester systématiquement les cas limites, contrôler les types des variables et vérifier la cohérence du résultat font partie du travail de programmation.