Écrire, lire et utiliser en Python les algorithmes du programme de Première : terme, somme et seuil d'une suite ; tableau de valeurs et balayage ; coefficients directeurs de sécantes ; méthode d'Euler et valeur approchée de
Programme de Seconde : variables, fonctions def, instructions conditionnelles if, boucles for et while. Suites numériques, second degré, dérivation, fonction exponentielle et probabilités conditionnelles de Première.
ILes outils
Les algorithmes de ce chapitre n'utilisent que des outils vus en Seconde. Ils sont rappelés ici ; le reste du chapitre les applique aux notions de Première.
def f(x):puisreturn …définit une fonction qui renvoie un résultat.if condition:…else:… exécute un bloc ou l'autre.for k in range(n):répète un bloc fois ;kprend les valeurs , , …, .range(a, b)donne les entiers de à .while condition:répète un bloc tant que la condition est vraie.- Un accumulateur s'initialise avant la boucle :
pour une somme, pour un produit, pour un compteur.
| Type d'algorithme | Boucle utilisée |
|---|---|
| terme de rang | for : nombre de tours connu |
| seuil, balayage | while : on répète tant que le but n'est pas atteint |
| simulation de | for et un compteur |
IISuites numériques
1. Calculer un terme de rang donné
Pour calculer for de k ne sert qu'à compter les tours.
def terme(n):
u = 0
for k in range(n):
u = 0.5 * u + 2
return u
for n in range(6):
print(n, terme(n))0 0
1 2.0
2 3.0
3 3.5
4 3.75
5 3.875Le tableau d'état de l'appel terme(3) donne la valeur de u à la fin de chaque tour :
| Étape | k | u |
|---|---|---|
| avant la boucle | — | |
| tour 1 | ||
| tour 2 | ||
| tour 3 |
Si return 3 * n**2 + 1.
2. Somme de termes et factorielle
On fait avancer ensemble l'accumulateur s et le terme u. De
Ici
def somme(n):
s = 0
u = 1
for k in range(n + 1):
s = s + u
u = 2 * u
return s
print(somme(10))2047On retrouve la formule de la somme des termes d'une suite géométrique :
Pour
def factorielle(n):
p = 1
for k in range(1, n + 1):
p = p * k
return p
print(factorielle(10))36288003. Algorithme de seuil
On calcule les termes un par un tant que le seuil n'est pas dépassé, en comptant les tours. La condition du while est le contraire de la condition cherchée : on veut n est le rang cherché.
def seuil(A):
n = 0
u = 2
while u <= A:
u = 1.5 * u
n = n + 1
return n
print(seuil(50))8En effet
whileÉcrire while u > A: est une erreur classique : comme
4. Une suite qui ne dépasse jamais le seuil
Un algorithme de seuil ne s'arrête que si le seuil est réellement dépassé à partir d'un certain rang. Il faut le justifier avant de lancer le programme.
def seuil(A):
n = 0
u = 0
while u <= A:
u = 0.5 * u + 2
n = n + 1
return n
print(seuil(3.9))6En revanche, l'appel seuil(5) ne se termine jamais. Posons
La suite u <= 5 reste toujours vraie et la boucle est infinie.
On peut limiter le nombre de tours en prenant pour condition u <= A and n < 1000 ; après la boucle, on teste si le seuil a bien été dépassé avant de renvoyer n.
IIIFonctions : tableau de valeurs et balayage
1. Tableau de valeurs
def f(x):
return x**2 - 4*x + 1
for x in range(-1, 6):
print(x, f(x))-1 6
0 1
1 -2
2 -3
3 -2
4 1
5 6On lit le minimum
2. Balayage
On part d'un nombre pas en pas tant que pas de la solution.
def balayage(a, pas):
x = a
while f(x + pas) > 0:
x = x + pas
x = round(x, 6)
return x, round(x + pas, 6)
print(balayage(0, 0.1))
print(balayage(0, 0.01))
print(balayage(0, 0.001))(0.2, 0.3)
(0.26, 0.27)
(0.267, 0.268)La fonction round(x, 6) arrondit à 0.30000000000000004).
Vérification : le discriminant de
IVDérivation : coefficients directeurs des sécantes
Le coefficient directeur de la sécante qui passe par les points de la courbe d'abscisses
Quand
Pour
def f(x):
return x**2
h = 0.1
for x in range(4):
t = (f(x + h) - f(x)) / h
print(x, round(t, 6))0 0.1
1 2.1
2 4.1
3 6.1En effet
Chaque valeur dépasse
VFonction exponentielle
1. La méthode d'Euler
La fonction exponentielle est l'unique fonction
On part du point
Les points
h = 0.25
x = 0
y = 1
for k in range(8):
x = x + h
y = y + h * y
print(x, round(y, 4))0.25 1.25
0.5 1.5625
0.75 1.9531
1.0 2.4414
1.25 3.0518
1.5 3.8147
1.75 4.7684
2.0 5.9605
La courbe de la fonction exponentielle est au-dessus de ses tangentes : la méthode d'Euler donne ici des valeurs par défaut (
2. Valeur approchée de
Avec
for n in [10, 100, 1000, 10**6]:
print(n, (1 + 1/n)**n)10 2.5937424601000023
100 2.7048138294215285
1000 2.7169239322355936
1000000 2.7182804690957534On admet que ces valeurs se rapprochent de
(1 + 1/n)**n calcule 1 + 1/n**n calcule
VITrigonométrie : approximation de
Archimède encadre la longueur
Soit
Soit
Dans le triangle
donc
Dans le triangle
L'hexagone régulier inscrit est formé de
from math import sqrt
n = 6
c = 1
for k in range(4):
c = sqrt(2 - sqrt(4 - c**2))
n = 2 * n
print(n, n * c / 2)12 3.1058285412302498
24 3.132628613281237
48 3.139350203046872
96 3.14103195089053Avec
VIIProbabilités : simuler une expérience aléatoire
1. Les fonctions du module random
random()renvoie un nombre réel au hasard dans : le testrandom() < pest vrai avec la probabilité .randint(a, b)renvoie un entier au hasard entre et inclus :randint(1, 6)simule un dé équilibré.
Les résultats changent à chaque exécution ; les affichages de cette partie sont ceux d'une exécution.
2. Fréquence d'un événement
On répète for, on compte avec un compteur c les fois où l'événement est réalisé, puis on renvoie
from random import randint
def frequence(N):
c = 0
for i in range(N):
d1 = randint(1, 6)
d2 = randint(1, 6)
if d1 + d2 == 7:
c = c + 1
return c / N
print(frequence(10000))0.1642Sur les
La liste eff (voir la notion « Notion de liste ») compte les lancers de chaque somme
from random import randint
N = 1000
eff = [0] * 13
for i in range(N):
d1 = randint(1, 6)
d2 = randint(1, 6)
s = d1 + d2
eff[s] = eff[s] + 1
for s in range(2, 13):
print(s, eff[s])2 32
3 52
4 86
5 120
6 139
7 173
8 121
9 113
10 81
11 59
12 24
3. Moyenne d'un échantillon
On lance un dé équilibré : on gagne
from random import randint
def gain():
d = randint(1, 6)
if d == 6:
return 4
elif d >= 4:
return 1
else:
return -1
def moyenne(n):
s = 0
for i in range(n):
s = s + gain()
return s / n
print(moyenne(10000))0.4776La moyenne d'un échantillon de grande taille est proche de l'espérance
4. Succession de deux épreuves
Une urne contient
D'après l'arbre, la probabilité que les deux boules soient de la même couleur vaut
La fonction tirage(r, v) simule un tirage dans une urne de r boules rouges et v vertes ; experience() enchaîne les deux épreuves.
from random import random
def tirage(r, v):
if random() < r / (r + v):
return "R"
return "V"
def experience():
t1 = tirage(3, 2)
if t1 == "R":
t2 = tirage(2, 2)
else:
t2 = tirage(3, 1)
return t1 + t2
N = 10000
c = 0
for i in range(N):
e = experience()
if e == "RR" or e == "VV":
c = c + 1
print(c / N)0.406La fréquence observée est proche de la probabilité
VIIIBilan
| Partie du programme | Algorithme | Structure |
|---|---|---|
| Suites | terme | for |
| Suites | seuil | while (condition contraire) |
| Second degré, fonctions | tableau de valeurs, balayage | for, while |
| Dérivation | coefficients directeurs des sécantes | for |
| Exponentielle | méthode d'Euler, valeur approchée de | for |
| Trigonométrie | approximation de | for |
| Probabilités | fréquence, moyenne, deux épreuves | for et random |
range(n)va de à : la somme demanderange(n + 1).- L'accumulateur s'initialise avant la boucle ; un produit commence à
. - Dans un algorithme de seuil, la condition du
whileest le contraire de la condition cherchée. - Avant de chercher un seuil, on vérifie qu'il sera dépassé, sinon la boucle est infinie.
- Les nombres décimaux sont arrondis en machine :
roundrend l'affichage lisible. randint(1, 6)inclut ; une simulation donne un résultat différent à chaque exécution.
- Terme de rang
: applications de la relation de récurrence (bouclefor). - Seuil : boucle
whileet compteur, à condition que le seuil soit atteint. - Balayage : on avance de
pasenpastant que garde le même signe. - Sécantes :
tend vers quand tend vers . - Euler :
; tend vers . - Simulation :
random() < préalise un événement de probabilité ; fréquence .
Fiche de synthèse dans l'onglet Fiches !
Cours lu ? Continue avec :