← Retour au sommaire

Chapitre 9 – Algorithmique et programmation

Chapitre 9 | Terminale technologique (enseignement commun) | Mathématiques

Dernière mise à jour : 21 octobre 2026

Objectifs du chapitre

I. Variables, compteur et accumulateur

1. Variables et affectation

Définition — Variable et affectation

Une variable est une case mémoire nommée qui contient une valeur. L'affectation (symbole \(\leftarrow\) en langage naturel, = en Python) place une valeur dans une variable.

Python — affectation 
compteur = 0                  # affectation
compteur = compteur + 1       # on modifie la variable à partir de sa valeur actuelle

Types de base : entier (int), flottant (float), booléen (bool, True/False), chaine (str).

2. Compteur et accumulateur

Deux motifs fondamentaux
Python — compteur et accumulateur ensemble 
def somme_et_compte(liste, seuil):
    """Somme des éléments et nombre d'éléments dépassant un seuil."""
    total = 0        # accumulateur (somme)
    compteur = 0     # compteur
    for x in liste:
        total = total + x            # accumulation
        if x > seuil:
            compteur = compteur + 1   # incrémentation du compteur
    return total, compteur
Lien avec le symbole \(\sum\)

Le calcul d'une somme \(\displaystyle\sum_{k=1}^{n} u_k\) correspond exactement à : initialisation (S = 0), boucle (for k in range(1, n+1)), accumulation (S = S + u(k)), puis sortie (return S).

Python — somme des \(n\) premiers carrés 
def somme_carres(n):
    S = 0
    for k in range(1, n + 1):
        S = S + k**2
    return S
Python — produit (accumulateur initialisé à 1) 
def factorielle(n):
    P = 1
    for k in range(1, n + 1):
        P = P * k
    return P
Exercice d'application 1. Écrire une fonction somme_cubes(n) renvoyant \(1^3 + 2^3 + \dots + n^3\). Que renvoie somme_cubes(3) ? 
def somme_cubes(n):
    S = 0
    for k in range(1, n + 1):
        S = S + k**3
    return S

somme_cubes(3) \(= 1 + 8 + 27 = 36\).

II. Conditions et boucles

1. Instruction conditionnelle

Python — if / elif / else 
if condition:
    # bloc exécuté si la condition est vraie
elif autre_condition:
    # sinon si...
else:
    # sinon

Les conditions se construisent avec les comparaisons (==, !=, <, <=, >, >=) et les opérateurs logiques and (ET), or (OU), not (NON) — occasion de travailler la logique.

2. Boucles

Définition — Boucle bornée et non bornée
Python — algorithme de seuil (while) 
# plus petit n tel que 1,04^n dépasse 2
n = 0
valeur = 1
while valeur < 2:
    valeur = valeur * 1.04
    n = n + 1
print(n)   # 18
Exercice d'application 2. Que renvoie mystere([3, 4, 7, 8, 10]) ? 
def mystere(liste):
    c = 0
    for x in liste:
        if x % 2 == 0:
            c = c + 1
    return c

La fonction compte les nombres pairs : \(4\), \(8\), \(10\) → elle renvoie 3.

III. Fonctions (programmation modulaire)

Définition — Fonction, entrées et sortie

Une fonction prend des entrées (paramètres) et renvoie une sortie (return). Découper un programme en fonctions (programmation modulaire) permet de décomposer une tâche complexe en tâches simples, réutilisables et testables.

Python — une fonction réutilise une autre fonction 
def moyenne(liste):
    """Entrée : une liste de nombres. Sortie : leur moyenne."""
    return sum(liste) / len(liste)

def ecart_a_la_moyenne(liste):
    """Réutilise moyenne()."""
    m = moyenne(liste)
    return [x - m for x in liste]

Entrées / sorties : l'entrée de moyenne est liste, sa sortie est un nombre. Toujours savoir identifier ce qui entre et ce qui sort.

Méthode — Décomposer en fonctions
  1. Repérer les sous-tâches indépendantes.
  2. Écrire une fonction par sous-tâche, avec entrées/sorties claires.
  3. Assembler dans une fonction principale qui appelle les autres.
Exercice d'application 3. Décomposer en fonctions un programme qui calcule l'amplitude (max − min) d'une liste, en écrivant d'abord maximum(liste) et minimum(liste). 
def maximum(liste):
    m = liste[0]
    for x in liste:
        if x > m:
            m = x
    return m

def minimum(liste):
    m = liste[0]
    for x in liste:
        if x < m:
            m = x
    return m

def amplitude(liste):
    return maximum(liste) - minimum(liste)

IV. Listes

1. Créer une liste

Python — trois façons de créer une liste 
a = [2, 3, 5, 7]                       # en extension
b = []                                 # vide, puis ajouts successifs
for k in range(5):
    b.append(k**2)                     # b devient [0, 1, 4, 9, 16]
c = [k**2 for k in range(5)]           # en compréhension (même résultat)
d = [k for k in range(20) if k % 3 == 0]   # compréhension avec condition

2. Manipuler et itérer

Python — manipuler les éléments et les indices 
a.append(11)     # ajoute 11 à la fin
a.remove(3)      # supprime la première occurrence de 3
a[0]             # premier élément (indice 0)
a[-1]            # dernier élément
len(a)           # nombre d'éléments
Python — itérer sur les éléments ou les indices 
for x in a:               # sur les éléments
    print(x)
for i in range(len(a)):   # sur les indices
    print(i, a[i])
Recommandation du programme

Se limiter aux listes, sans introduire d'autres types de collections, pour éviter les confusions.

Exercice d'application 4. Générer, en compréhension, la liste des multiples de \(5\) strictement inférieurs à \(50\).

[k for k in range(50) if k % 5 == 0] → [0, 5, 10, 15, 20, 25, 30, 35, 40, 45].

V. Nombres aléatoires et simulation

Définition — Simuler une épreuve de Bernoulli

Le module random fournit random(), qui renvoie un flottant entre \(0\) et \(1\). On simule une épreuve de Bernoulli de paramètre \(p\) : c'est un succès si le tirage est inférieur à \(p\).

Python — une épreuve de Bernoulli 
from random import random

def bernoulli(p):
    """Renvoie 1 (succès) avec probabilité p, sinon 0."""
    if random() < p:
        return 1
    else:
        return 0
Python — \(n\) répétitions et fréquence de succès 
def compte_succes(n, p):
    total = 0
    for _ in range(n):
        total = total + bernoulli(p)   # accumulateur de succès
    return total

# fréquence de succès sur un grand nombre de simulations
def frequence(n, p, N):
    return sum(compte_succes(n, p) for _ in range(N)) / (N * n)

print(round(frequence(10, 0.3, 100000), 3))   # proche de 0.3

C'est le lien direct avec la loi binomiale \(B(n,p)\) : on répète \(n\) épreuves de Bernoulli indépendantes et on compte les succès.

Exercice d'application 5. Écrire une fonction simule_dizaine(p) qui simule \(10\) épreuves de Bernoulli de paramètre p et renvoie le nombre de succès. 
from random import random

def simule_dizaine(p):
    succes = 0
    for _ in range(10):
        if random() < p:
            succes += 1
    return succes

VI. Sélection de données et tableau croisé

On sait traiter un fichier de données réelles (par exemple un fichier CSV) pour en extraire de l'information.

Python — lire un fichier CSV et calculer une moyenne 
def moyenne_colonne(nom_fichier, indice_colonne):
    total, n = 0, 0
    with open(nom_fichier, "r", encoding="utf-8") as f:
        next(f)                       # on saute la ligne d'en-têtes
        for ligne in f:
            champs = ligne.strip().split(",")
            total += float(champs[indice_colonne])
            n += 1
    return total / n
Méthode — Tableau croisé

Croiser deux critères à partir de données brutes (ex. « sexe » et « option ») : on compte les effectifs de chaque combinaison. Ce travail se fait aisément au tableur (tableau croisé dynamique) ou en Python avec un dictionnaire de comptage.

VII. Outils numériques — tableur

Tableur — équivalents

Lire, compléter ou corriger un programme

Méthode
  1. Identifier les entrées/sorties et le rôle de chaque variable.
  2. Suivre l'exécution pas à pas sur un petit exemple (« dérouler » l'algorithme).
  3. Repérer l'instruction fautive (initialisation oubliée, borne de boucle, indentation).
Exemple résolu — corriger une somme de liste 
def somme(liste):
    S = 0
    for x in liste:
        S = x            # BUG : écrase au lieu d'accumuler
    return S

Correction : S = S + x. L'erreur remplaçait S par le dernier élément au lieu d'accumuler.

Exercice d'application 6. Corriger cette fonction, censée calculer la moyenne d'une liste : 
def moyenne(liste):
    total = 0
    for x in liste:
        total = total + x
    return total / len(liste) - 1

La priorité des opérations fait calculer (total / len(liste)) - 1. Il faut supprimer le - 1 qui n'a pas lieu d'être : return total / len(liste).

Erreurs fréquentes / points de vigilance

Les pièges du chapitre

❌ Accumulateur non initialisé, ou écrasé au lieu d'être incrémenté.

✅ S = S + x, pas S = x. Initialiser S = 0 (somme) ou P = 1 (produit).

❌ Se tromper dans les bornes de range.

✅ range(1, n+1) parcourt \(1\) à \(n\) ; oublier le +1 perd le dernier terme.

❌ Se tromper d'indice de liste.

✅ Le premier indice est \(0\) ; le dernier est len(liste) - 1. liste[-1] = dernier élément.

❌ Confondre == (test d'égalité) et = (affectation), ou se tromper d'indentation.

✅ L'indentation définit le bloc d'une boucle ou d'un if : un mauvais alignement change la logique. Pour une Bernoulli, succès si random() < p (ne pas inverser).

L'essentiel à retenir

À retenir :
Exercices → Fiche de révision → QCM →