Fiche – Algorithmique et programmation

Chapitre 12 | Première générale (spécialité) | Mathématiques

Dernière mise à jour : 21 octobre 2026

L'essentiel :

Une liste est une collection ordonnée : L = [4, 9, 16]. Les indices commencent à \(0\).
Le dernier élément est L[-1] ; le nombre d'éléments est len(L).
Trois façons de générer : extension, ajouts successifs (append), compréhension.
Parcourir : for i in range(len(L)) (indices) ou for x in L (éléments).
Programmation modulaire : découper une tâche en fonctions simples et réutilisables.

Définitions clés

Définition

Liste : collection ordonnée d'éléments repérés par leur indice (position), à partir de \(0\). L[0] est le premier, L[-1] le dernier.

Définition

Affectation : \(x \leftarrow 3\) en langage naturel, x = 3 en Python. Ne pas confondre = (affecte) et == (teste l'égalité).

Définition

Programmation modulaire : découper un problème complexe en fonctions simples, chacune réalisant une sous-tâche, que l'on combine ensuite.

À connaître par cœur

Générer une liste (trois façons)

carres = [1, 4, 9, 16, 25]                # extension

carres = []                               # ajouts successifs
for k in range(1, 6):
    carres.append(k * k)

carres = [k*k for k in range(1, 6)]       # compréhension

Manipuler une liste

L.append(x)   # ajoute x en fin
del L[i]      # supprime l'élément d'indice i
L[i] = x      # modifie l'élément d'indice i
len(L)        # nombre d'éléments
x in L        # True ou False

Parcourir une liste

for i in range(len(L)):   # par indices
    print(i, L[i])

for x in L:               # par éléments
    ...

Structures de contrôle

Conditionnelle : if condition: ... else: ...
Boucle bornée : for i in range(n): ... (\(n\) tours, \(i\) de \(0\) à \(n-1\)).
Boucle non bornée : while condition: ... (tant que la condition est vraie).

Algorithmes classiques du programme

Seuil : boucle while jusqu'à dépasser une valeur.
Factorielle : \(n! = 1\times 2\times\dots\times n\) par une boucle for.
Newton, Euler : répéter \(n\) fois une mise à jour de \(x\) (ou de \(y\)).
Monte-Carlo : estimer \(\pi\) par tirages aléatoires.
Syracuse, Fibonacci : construire une liste terme après terme.

Méthode — Écrire un script

Méthode — Premiers termes d'une suite

Initialiser la liste avec le premier terme : L = [u0].
Répéter \(n-1\) fois : calculer le terme suivant à partir de L[-1].
Ajouter avec L.append(...), puis renvoyer L.

Méthode — Recherche d'un seuil

Initialiser la valeur et un compteur : u, n = u0, 0.
Boucle while u < S : mettre à jour u puis n += 1.
Renvoyer n. Vérifier que u évolue pour éviter une boucle infinie.

Erreurs fréquentes

Attention

❌ Croire que L[len(L)] est le dernier élément.

✅ Les indices vont de \(0\) à len(L) - 1 ; le dernier est L[-1].

❌ Écrire L = L.append(x).

✅ append modifie la liste en place et ne renvoie rien : L.append(x).

❌ Confondre = et ==.

✅ = affecte une valeur ; == teste l'égalité.

❌ Boucle while sans progression.

✅ La variable testée doit évoluer, sinon la boucle est infinie.

Exemple rapide

Exemple — moyenne d'une liste (module réutilisable)

def moyenne(L):
    return sum(L) / len(L)

print(moyenne([12, 8, 15, 6, 18, 10]))   # 11.5

La fonction moyenne peut ensuite être combinée avec d'autres modules (par exemple liste_carres).