Un prof de maths qui te répond·30 €/mois

Découvrir
MathLvlMon espace
Première spé maths

Algorithmique et Python en Première spé maths

Algorithmes de calcul de termes de suites et simulations Python en Première.

Mis à jour le

En Première spé, Python devient un outil au service de tout le programme : calculer des termes et des sommes de suites, chercher un seuil, approcher une solution d'équation par la méthode de Newton, construire l'exponentielle par la méthode d'Euler, estimer une aire ou le nombre π par la méthode de Monte-Carlo, simuler des variables aléatoires et des échantillons.

Au programme (2026) : la notion de liste (création en extension, par ajouts successifs avec append, en compréhension ; itération sur les éléments ; accès à un élément par son indice) ; termes et sommes de suites, seuil, factorielle, suites de Syracuse et de Fibonacci ; coefficients directeurs des sécantes ; méthode de Newton ; méthode d'Euler ; Monte-Carlo ; espérance, variance et écart type d'une variable aléatoire ; moyenne d'un échantillon et écart à l'espérance ; fréquence des lettres d'un texte.

Pièges classiques : confondre un élément et son indice (range(n) parcourt 0 à n-1) ; oublier l'indentation ; mal initialiser un accumulateur. Conseil : exécuter mentalement le programme sur un petit cas (n=3) avant de le lancer, et afficher les variables clés avec print.

Cours et fiche

📘

Leçon

Le cours complet du chapitre

📝

Fiche de révision

Synthèse + formules essentielles

Exercices corrigés

5 exercices
1

Plaquette 1 – Suites, seuils, sommes et simulations

2

Plaquette 2 – Variables, boucles bornées et fonctions

3

Plaquette 3 – Boucles non bornées, seuils et terminaison

4

Plaquette 4 – Listes, simulations et statistiques

5

Plaquette 5 – Problèmes de synthèse : algorithmes du programme et débogage

Quiz interactif

Auto-évaluation

Teste tes connaissances et vérifie que tu maîtrises le chapitre.

QCM — Algorithmique et Python (51 questions)

Leçon complète

Algorithmique et Python en Première spé maths : cours complet

Rappels et fonctions

Méthode — Programmation modulaire. On découpe un problème en fonctions courtes : chacune a des entrées (paramètres) et une sortie (return). L'affectation s'écrit x = 3 en Python et x ← 3 en langage naturel.

def f(x):
    return x**2 - 2

def signe(y):
    if y > 0:
        return "positif"
    elif y < 0:
        return "négatif"
    return "nul"

print(signe(f(1.5)))    # positif

Les listes

Méthode — Générer une liste.

L = [2, 3, 5, 7]                         # en extension
C = []
for k in range(1, 6):
    C.append(k**2)                       # ajouts successifs : [1, 4, 9, 16, 25]
P = [k for k in range(20) if k % 3 == 0] # en compréhension : [0, 3, 6, ..., 18]

La liste en compréhension traduit l'ensemble {k ∈ {0, 1, …, 19} | k multiple de 3} : la condition est un filtre logique.

Méthode — Manipuler et parcourir. L[0] est le premier élément, L[-1] le dernier, len(L) la longueur ; L.append(x) ajoute, L.remove(x) supprime la première occurrence de x, del L[i] supprime l'élément d'indice i.

def moyenne(L):
    s = 0
    for x in L:              # itérer sur les éléments
        s = s + x
    return s / len(L)

def indice_max(L):
    i_max = 0
    for i in range(len(L)):  # parcourir les indices
        if L[i] > L[i_max]:
            i_max = i
    return i_max

Suites

Exemple — Terme, somme, seuil. Pour u₀ = 100 et uₙ₊₁ = 0,9uₙ + 20 :

def terme(n):
    u = 100
    for k in range(n):
        u = 0.9 * u + 20
    return u

def seuil(s):            # premier n tel que u_n > s
    n, u = 0, 100
    while u <= s:
        u = 0.9 * u + 20
        n = n + 1
    return n

Exemple — Factorielle, Syracuse, Fibonacci.

def factorielle(n):
    p = 1
    for k in range(1, n + 1):
        p = p * k
    return p                 # factorielle(10) = 3628800

def syracuse(n):
    L = [n]
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3 * n + 1
        L.append(n)
    return L                 # syracuse(6) = [6, 3, 10, 5, 16, 8, 4, 2, 1]

def fibonacci(n):
    F = [1, 1]
    while len(F) < n:
        F.append(F[-1] + F[-2])
    return F                 # fibonacci(10) = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Dérivation et exponentielle

Exemple — Coefficients directeurs des sécantes.

def secantes(f, a, pas):
    return [(f(a + h) - f(a)) / h for h in pas]

def carre(x):
    return x**2

print(secantes(carre, 1, [1, 0.1, 0.01]))   # [3.0, 2.1, 2.01]

Les coefficients se rapprochent de 2, le nombre dérivé de x ↦ x² en 1.

Exemple — Méthode de Newton. Pour approcher une solution de f(x) = 0, on remplace la courbe par sa tangente : xₙ₊₁ = xₙ - f(xₙ)/f'(xₙ). Avec f(x) = x² - 2 et x₀ = 1 : 1,5 ; 1,416 7 ; 1,414 216… qui converge très vite vers √2.

def newton(f, fp, x, n):
    for k in range(n):
        x = x - f(x) / fp(x)
    return x

Exemple — Exponentielle : méthode d'Euler et nombre e. exp' = exp et exp(0) = 1 : avec un pas h, yₖ₊₁ = yₖ + h yₖ = (1 + h)yₖ. Avec h = 0,1, on obtient exp(1) ≈ 1,1¹⁰ ≈ 2,594. La suite (1 + 1/n)ⁿ donne 2,594 ; 2,705 ; 2,717 pour n = 10, 100, 1 000 : elle s'approche de e ≈ 2,718.

Trigonométrie : Archimède

Exemple — Approcher π. Archimède encadre π par les demi-périmètres de polygones réguliers inscrits dans un cercle de rayon 1 : en doublant le nombre de côtés, le côté c devient √(2 - √(4 - c²)).

from math import sqrt

def archimede(etapes):
    n, c = 6, 1.0            # hexagone : côté 1
    for k in range(etapes):
        c = sqrt(2 - sqrt(4 - c**2))
        n = 2 * n
    return n * c / 2         # demi-périmètre

On obtient 3 ; 3,106 ; 3,133 ; 3,139 ; 3,141 pour 6, 12, 24, 48, 96 côtés.

Probabilités

Exemple — Monte-Carlo.

from random import random

def estime_pi(N):
    c = 0
    for k in range(N):
        if random()**2 + random()**2 <= 1:
            c = c + 1
    return 4 * c / N

Une exécution avec N = 100 000 a donné 3,138. Le même principe estime l'aire sous la parabole y = x² entre 0 et 1 (environ 1/3).

Exemple — Espérance, variance, écart type.

from math import sqrt

def esperance(X, P):
    return sum([X[i] * P[i] for i in range(len(X))])

def variance(X, P):
    E = esperance(X, P)
    return sum([P[i] * (X[i] - E)**2 for i in range(len(X))])

X, P = [0, 1, 2, 3], [0.1, 0.3, 0.4, 0.2]
print(esperance(X, P), variance(X, P), sqrt(variance(X, P)))   # 1.7  0.81  0.9

Erreurs classiques

Attention — À éviter.

  • Oublier que les indices commencent à 0 : le dernier élément est L[len(L) - 1], soit L[-1].
  • Utiliser / au lieu de // pour une division entière (Syracuse).
  • Placer return à l'intérieur de la boucle.
  • Confondre la condition d'arrêt d'une boucle while et la condition qu'on cherche : on boucle tant que le seuil n'est pas dépassé.

Fiche de synthèse

Générer [2, 3, 5] ; append dans une boucle ; [f(k) for k in … if …]
Manipuler L[i], L[-1], len, append, remove, del
Parcourir for x in L ; for i in range(len(L))
Suites boucle for (terme, somme) ; while (seuil)
Newton x ← x - f(x)/f'(x)
Euler y ← y + h y'

Exercices d'application

Exercice 1 – Liste en compréhension

Écrire la liste des carrés des entiers pairs compris entre 0 et 10.

Exercice 2 – Somme

Écrire une fonction somme(L) qui renvoie la somme des éléments d'une liste, sans utiliser sum.

Exercice 3 – Seuil

Pour la suite u₀ = 1 000, uₙ₊₁ = 1,05uₙ, écrire une fonction qui renvoie le premier n tel que uₙ > 2 000, et donner le résultat.

Corrigés des exercices

Corrigé de l'exercice 1

Corrigé. [k**2 for k in range(0, 11, 2)], soit [0, 4, 16, 36, 64, 100].

Corrigé de l'exercice 2

Corrigé.

def somme(L):
    s = 0
    for x in L:
        s = s + x
    return s

Corrigé de l'exercice 3

Corrigé.

def seuil():
    n, u = 0, 1000
    while u <= 2000:
        u = 1.05 * u
        n = n + 1
    return n

Elle renvoie 15 (1,05¹⁴ ≈ 1,98 et 1,05¹⁵ ≈ 2,08).

FAQ — Algorithmique et Python en Première spé

Pourquoi utiliser des fonctions ?

Pour réutiliser du code, organiser un programme, le rendre plus lisible et testable.

À quoi servent les simulations ?

À estimer des probabilités difficiles à calculer théoriquement, à vérifier un modèle, à explorer un phénomène.

Comment éviter les boucles infinies ?

Vérifier que la condition de sortie sera atteinte : la variable de boucle doit être modifiée à chaque tour.

Tout sur algorithmique et python au lycée

Variables, fonctions, boucles, listes, puis seuils, dichotomie et simulations : le Python du programme de la Seconde à la Terminale.

Tous les chapitres de Première spé maths

Poursuis ta révision avec les autres chapitres du programme de Première spé maths.