Chapitre 9 — Algorithmique et programmation Python

Q: Quand utiliser `for` plutôt que `while` ?

`for` quand le **nombre d'itérations est connu à l'avance** (calculer $u_{10}$, somme de 1 à n). `while` quand on cherche à atteindre une **condition** (premier $n$ tel que $u_n \geq S$, convergence à $\varepsilon$ près).

Q: Comment lire un script Python sans l'exécuter ?

Faire un **tableau d'évolution** des variables. À chaque itération, noter les valeurs avant et après. Indispensable pour les questions du type "quelle est la valeur de `u` à la sortie ?".

Q: Comment écrire une fonction qui retourne le n-ième terme d'une suite récurrente ?

Initialiser la variable avec $u_0$, faire une boucle `for k in range(n):` qui applique la relation de récurrence, retourner la variable finale. Voir Pattern 1.

Q: Que faire si le script doit gérer des erreurs (par exemple, $n < 0$) ?

Au bac, on n'attend pas de gestion d'exceptions. Si la question le précise, ajouter en début de fonction : `if n < 0: return None` ou un message. Sinon, supposer que l'entrée est valide.

Key takeaway

Programme officiel — BO du 25 juillet 2019.

Probabilité 2026 (analyse Innovaweb) : ⭐⭐⭐⭐ — Transversal. Apparaît dans 5 sessions sur 8 Métropole 2022-2025, généralement en sous-question d'un exercice de suite, de probas ou de fonction.

Cadrage du chapitre

Python est utilisé comme outil algorithmique : lire un script, suivre son exécution, le compléter, parfois écrire une fonction simple. Pas besoin de maîtriser l'orienté objet, les listes en compréhension complexes, les modules externes. Le minimum suffit.

Structures de base à connaître

Variables et opérations

x = 5

# affectation
y = 2.5

# variable réelle
n = n + 1

# incrémentation (équivalent : n += 1)
prod = a * b

# produit
quotient = a / b

# division réelle (résultat flottant)
div_ent = a // b

# division entière
reste = a % b

# modulo
puissance = a ** n

# a puissance n

Conditions

if x > 0:
    print("positif")
elif x == 0:
    print("nul")
else:
    print("négatif")

Opérateurs : == (égal), != (différent), <, >, <=, >=, and, or, not.

Boucles for (nombre d'itérations connu)

for k in range(10):

# k = 0, 1, 2, ..., 9
    print(k)

for k in range(1, 11):

# k = 1, 2, ..., 10
    somme = somme + k

for k in range(0, 20, 2):

# k = 0, 2, 4, ..., 18 (pas de 2)
    print(k)

Boucles while (condition à respecter)

n = 0
u = 1
while u < 100:
    u = 2 * u
    n = n + 1
print(n, u)

Différence clé :

for : on sait combien de fois on itère.
while : on itère tant qu'une condition est vraie. Attention aux boucles infinies (vérifier que la condition finit par être fausse).

Fonctions

def carre(x):
    return x * x

def somme_premiers(n):
    """Retourne 1 + 2 + ... + n."""
    s = 0
    for k in range(1, n + 1):
        s = s + k
    return s

Trois patterns Python ultra-fréquents au bac

Pattern 1 : Calcul du n-ième terme d'une suite

Pour la suite $u_{n+1} = f(u_n)$ avec $u_0$ donné :

def terme(n):
    """Retourne u_n pour la suite u_{k+1} = 0.5 * u_k + 3, u_0 = 1."""
    u = 1
    for k in range(n):
        u = 0.5 * u + 3
    return u

Variations : modifier la fonction de récurrence ou la valeur initiale. Très fréquent en exercice 4.

Pattern 2 : Seuil avec boucle while

Trouver le plus petit $n$ tel que $u_n \geq S$ (suite croissante) :

def seuil(S):
    """Retourne le plus petit n tel que u_n >= S."""
    u = 1

# u_0
    n = 0
    while u < S:
        u = 0.5 * u + 3
        n = n + 1
    return n

Variantes :

Suite décroissante : while u > S:
Seuil sur la somme des termes : utiliser une variable accumulateur.

Pattern 3 : Simulation probabiliste

Pour estimer une probabilité par fréquence statistique :

import random

# parfois mentionné, mais le `random.random()` est admis

def simulation(n):
    """Estime la probabilité par n simulations."""
    succes = 0
    for k in range(n):
        x = random.random()

# nombre dans [0, 1[
        if x < 0.3:
            succes = succes + 1
    return succes / n

Au bac, on demande surtout de compléter un tel script ou de prédire son résultat.

Exercice-type au bac : compléter un script

Énoncé (inspiré bac 2025 J1)

On considère la suite $(u_n)$ définie par $u_0 = 1000$ et $u_{n+1} = 0{,}9 \cdot u_n + 50$ pour tout $n \in \mathbb{N}$ .

On donne le script Python suivant, qui doit retourner le plus petit entier $n$ tel que $u_n \leq 600$ .

def seuil():
    u = ...
    n = 0
    while u ... :
        u = ...
        n = ...
    return n

Compléter les pointillés.

Corrigé

La suite est décroissante (vérifier que $u_{n+1} - u_n = -0{,}1 u_n + 50 < 0$ tant que $u_n > 500$ ).

def seuil():
    u = 1000

# u_0
    n = 0
    while u > 600:

# tant que pas encore atteint le seuil
        u = 0.9 * u + 50
        n = n + 1
    return n

Pièges classiques à éviter

Confondre = et ==. = = affectation. == = test d'égalité. if u = 5: est une erreur de syntaxe.
Oublier l'incrémentation dans une boucle while. Sans n = n + 1, on a une boucle infinie.
Range : la borne supérieure est exclue. range(10) produit 0, 1, ..., 9 (pas 10). Pour obtenir 1, 2, ..., n : utiliser range(1, n+1).
Indentation Python. Les blocs sont délimités par l'indentation (4 espaces standard). Une indentation incorrecte = erreur de syntaxe ou logique différente.
Initialiser les compteurs avant la boucle. n = 0 avant while, sinon n est indéfini la 1re fois qu'on l'utilise.

Annales 2022-2025 connectées

2022 J1 Ex 1 : Suite + Python (modèle médicament).
2023 J1 Ex 3 : Suite + Python (FAQ entreprise).
2023 J2 Ex 2 : Suite + Python (insectes).
2025 J1 Ex 4 : Suite + Python (algue marine).
2025 J2 Ex 4 : Python (sous-question).

Bilan : 5 apparitions sur 8 sessions. Toujours en sous-question d'un exercice de suite ou de modèle d'évolution. Maîtriser les 3 patterns ci-dessus suffit pour 90 % des cas.

Q&R pour le tuteur IA

Q : Quand utiliser for plutôt que while ? R : for quand le nombre d'itérations est connu à l'avance (calculer $u_{10}$ , somme de 1 à n). while quand on cherche à atteindre une condition (premier $n$ tel que $u_n \geq S$ , convergence à $\varepsilon$ près).

Q : Comment lire un script Python sans l'exécuter ? R : Faire un tableau d'évolution des variables. À chaque itération, noter les valeurs avant et après. Indispensable pour les questions du type "quelle est la valeur de u à la sortie ?".

Q : Comment écrire une fonction qui retourne le n-ième terme d'une suite récurrente ? R : Initialiser la variable avec $u_0$ , faire une boucle for k in range(n): qui applique la relation de récurrence, retourner la variable finale. Voir Pattern 1.

Q : Que faire si le script doit gérer des erreurs (par exemple, $n < 0$ ) ? R : Au bac, on n'attend pas de gestion d'exceptions. Si la question le précise, ajouter en début de fonction : if n < 0: return None ou un message. Sinon, supposer que l'entrée est valide.