Mathématiques — Seconde

Algorithmique et programmation — Maths Seconde (chapitre 12)

Variables et types, affectation, instruction conditionnelle, boucles for et while, fonctions Python, simulation d'expériences aléatoires. Programme 2026 de…

Par ProfBot

Algorithmique et programmation en Python

Chapitre 12 — Partie transversale · Seconde générale et technologique

Programmer, c'est écrire une méthode si précisément qu'une machine puisse l'exécuter sans rien comprendre. Cette exigence est un excellent test mathématique : tant qu'un raisonnement reste vague, il ne se programme pas. Et une fois programmé, il se vérifie — sur cent cas, en une seconde.

Au programme officiel (programme 2026, applicable à la rentrée 2026-2027). Variables et instructions élémentaires : variables de type entier, booléen, flottant, chaîne de caractères ; affectation (notée $\leftarrow$ en langage naturel) ; séquence d'instructions ; instruction conditionnelle ; boucle bornée (for), boucle non bornée (while). Choisir ou déterminer le type d'une variable ; concevoir une affectation, une séquence, une conditionnelle ; écrire une formule combinant des variables ; programmer une boucle bornée, une boucle non bornée ; lire, comprendre, modifier ou compléter un programme plus complexe.

Notion de fonction : fonctions à un ou plusieurs arguments ; fonction renvoyant un nombre aléatoire ; série statistique obtenue par répétition de l'appel d'une telle fonction. Lire et comprendre une fonction renvoyant une moyenne, un écart type. Aucune connaissance sur les listes n'est exigée. Écrire des fonctions renvoyant le résultat numérique d'une expérience aléatoire, ou d'une répétition d'expériences aléatoires indépendantes.

1. Variables et types

Définition. Une variable est un nom associé à une valeur stockée en mémoire. L'affectation donne (ou change) cette valeur ; on la note $\leftarrow$ en langage naturel, et = en Python.

Les quatre types au programme :

TypePythonExemples
entierint7, -3, 0
flottant (décimal)float2.5, -0.75, 3.0
booléenboolTrue, False
chaîne de caractèresstr"bonjour", "12"

n = 7             # int
prix = 12.50      # float
gagne = True      # bool
nom = "Alice"     # str

12 et "12" ne sont pas la même chose. Le premier est un nombre, avec lequel on calcule ; le second est un texte, qu'on peut afficher ou concaténer. En Python, 2 3 vaut 6, mais 2 "3" vaut "33". Le type n'est pas un détail administratif : il décide de ce que font les opérations.

Le = de Python n'est PAS le = des mathématiques. L'instruction x = x + 1 n'a aucun sens comme équation — elle n'a pas de solution. Comme affectation, elle signifie « prends la valeur actuelle de $x$, ajoute $1$, range le résultat dans $x$ ». C'est une action, pas une affirmation.

La variable x contient 5, puis 6 après l'affectation x ← x + 1.

Une séquence s'exécute dans l'ordre, ligne après ligne :


a = 3
b = a + 2      # b vaut 5
a = 10         # b vaut TOUJOURS 5 : il a été calculé avant

2. Instruction conditionnelle

Trois schémas : if-else, boucle for, boucle while.


if note >= 10:
    print("admis")
elif note >= 8:
    print("rattrapage")
else:
    print("ajourné")

Les opérateurs de comparaison produisent des booléens : == (égal), != (différent), <, <=, >, >=. On les combine avec and, or, not.

= affecte, == compare. Écrire if x = 3: est une erreur de syntaxe en Python. Cette distinction n'existe pas en mathématiques, où le même symbole sert aux deux — d'où la confusion, très fréquente au début.

L'ordre des tests compte. Dans l'exemple, elif note >= 8 n'est atteint que si le premier test a échoué : il signifie donc implicitement « entre $8$ et $10$ ». Si l'on avait écrit le test >= 8 en premier, tous les admis seraient envoyés au rattrapage.

3. Les boucles

Boucle bornée for — on connaît le nombre de tours à l'avance :


somme = 0
for k in range(1, 11):     # k prend les valeurs 1, 2, …, 10
    somme = somme + k
print(somme)               # 55

range(a, b) s'arrête AVANT b. range(1, 11) donne $1, 2, \dots, 10$ — dix valeurs, pas onze. Et range(n) seul commence à zéro : range(4) donne $0, 1, 2, 3$. C'est la source d'erreur numéro un des boucles.

Boucle non bornée while — on répète tant qu'une condition est vraie :


u = 3
n = 0
while u <= 100:
    u = 3 * u
    n = n + 1
print(n, u)                # 4 243

Une trace d'exécution ligne par ligne de la boucle while.

La trace d'exécution — écrire les valeurs de chaque variable tour après tour — est la seule méthode fiable pour comprendre une boucle. On la fait à la main, sur un brouillon.

Une boucle while peut tourner indéfiniment. Si le corps de la boucle ne rapproche jamais de la condition d'arrêt, le programme ne s'arrête pas. Avant d'exécuter, il faut se demander : qu'est-ce qui, à chaque tour, fait avancer vers la sortie ? Ici, $u$ est multiplié par $3$ : il finira forcément par dépasser $100$.

La condition est testée AVANT chaque tour. Si elle est fausse dès le départ, le corps n'est jamais exécuté. Avec u = 500 au lieu de 3, le programme afficherait 0 500 sans rien faire.

4. Les fonctions

Définition. Une fonction informatique regroupe une suite d'instructions sous un nom. Elle prend des arguments (les données d'entrée) et renvoie un résultat avec return.


def aire_rectangle(longueur, largeur):
    """Renvoie l'aire d'un rectangle."""
    return longueur * largeur

aire_rectangle(5, 3)      # 15

print affiche, return renvoie. Une fonction qui print mais ne return rien ne peut pas être réutilisée dans un calcul : 2 * aire_rectangle(5, 3) échouerait. Pour un usage mathématique, c'est toujours return.

Fonction et fonction mathématique. La correspondance est directe : def f(x): return x2 - 3 est la traduction de $f : x \mapsto x^2 - 3$. Mais une fonction informatique peut avoir plusieurs** arguments, ou n'être pas déterministe — comme celles du paragraphe suivant.

5. Simuler le hasard


from random import randint, random

randint(1, 6)      # un entier au hasard entre 1 et 6 INCLUS
random()           # un décimal au hasard dans [0 ; 1[

randint(a, b) inclut les DEUX bornes, contrairement à range(a, b). Pour un dé, c'est bien randint(1, 6).

Simuler une expérience :


def lancer_de():
    """Simule un lancer de dé équilibré."""
    return randint(1, 6)

def somme_deux_des():
    """Simule la somme de deux dés."""
    return randint(1, 6) + randint(1, 6)

Répéter et compter — c'est ainsi qu'on observe la loi des grands nombres du [chapitre 11] :


def frequence_de_six(n):
    """Fréquence de « 6 » sur n lancers."""
    compteur = 0
    for _ in range(n):
        if lancer_de() == 6:
            compteur = compteur + 1
    return compteur / n

frequence_de_six(100000)     # ≈ 0.1667

Deux exécutions donnent des résultats DIFFÉRENTS. C'est normal, et c'est même tout l'intérêt : une simulation illustre une tendance, elle ne démontre rien. Sur $100$ lancers on peut trouver $0{,}11$ ou $0{,}22$ ; sur $100\,000$, on tourne autour de $\frac16 \approx 0{,}1667$.

Moyenne d'une simulation, sans utiliser de liste (le programme ne les exige pas en seconde) : on accumule dans une variable.


def moyenne_des_sommes(n):
    """Moyenne des sommes de deux dés sur n répétitions."""
    total = 0
    for _ in range(n):
        total = total + somme_deux_des()
    return total / n

moyenne_des_sommes(100000)   # ≈ 7.0

6. Exercices corrigés

Exercice 1 — Types et affectations

Quel est le type de chacune des variables, et que vaut d à la fin ?


a = 5
b = 2.0
c = (a > 3)
d = a + b

Correction. a est un int, b un float, c un bool (il vaut True car $5 > 3$), et d vaut 7.0 — un flottant, car l'addition d'un entier et d'un flottant donne un flottant.

Exercice 2 — Trace d'exécution

Donner la valeur finale de x et de y :


x = 4
y = 10
x = x + y
y = x - y
x = x - y

Correction. Ligne à ligne :

aprèsxy
départ$4$$10$
x = x + y$14$$10$
y = x - y$14$$4$
x = x - y$10$$4$

Les deux valeurs ont été échangées, sans variable intermédiaire.

Exercice 3 — Conditionnelle

Écrire une fonction qui renvoie la mention obtenue pour une moyenne : « TB » à partir de $16$, « B » à partir de $14$, « AB » à partir de $12$, « admis » à partir de $10$, « refusé » en dessous.

Correction.


def mention(moyenne):
    if moyenne >= 16:
        return "TB"
    elif moyenne >= 14:
        return "B"
    elif moyenne >= 12:
        return "AB"
    elif moyenne >= 10:
        return "admis"
    else:
        return "refusé"

Les tests sont écrits du plus exigeant au moins exigeant : c'est indispensable, puisque moyenne >= 10 serait vrai aussi pour $18$.

Exercice 4 — Boucle bornée

Que vaut s à la fin ? Puis modifier le programme pour obtenir la somme des carrés.


s = 0
for k in range(1, 6):
    s = s + k

Correction. k prend les valeurs $1, 2, 3, 4, 5$, donc s vaut $1+2+3+4+5 = 15$. Pour la somme des carrés, on remplace la ligne par s = s + k**2, ce qui donne $1+4+9+16+25 = 55$.

Exercice 5 — Boucle non bornée

Un capital de $1\,000$ € augmente de $4\,\%$ par an. Écrire une fonction qui renvoie le nombre d'années nécessaires pour dépasser $1\,500$ €.

Correction.


def annees_pour_depasser(objectif):
    capital = 1000
    n = 0
    while capital <= objectif:
        capital = capital * 1.04
        n = n + 1
    return n

annees_pour_depasser(1500)     # 11

Vérification : $1000 \times 1{,}04^{10} \approx 1\,480{,}24$ (pas encore) et $1000 \times 1{,}04^{11} \approx 1\,539{,}45$ ✓.

Exercice 6 — Simulation

Écrire une fonction qui simule $n$ lancers de deux dés et renvoie la fréquence des « doubles » (deux faces identiques). Quelle valeur théorique attend-on ?

Correction.


def frequence_doubles(n):
    compteur = 0
    for _ in range(n):
        if randint(1, 6) == randint(1, 6):
            compteur = compteur + 1
    return compteur / n

Théoriquement, il y a $6$ doubles parmi $36$ couples équiprobables, soit $P(\text{double}) = \frac{6}{36} = \frac16 \approx 0{,}167.$ La fréquence simulée doit s'en approcher pour $n$ grand.

Exercice 7 — Lire un programme

Que fait cette fonction ?


def mystere(a, b):
    while b != 0:
        r = a % b
        a = b
        b = r
    return a

Correction. Testons avec mystere(48, 18) :

abr
$48$$18$$12$
$18$$12$$6$
$12$$6$$0$
$6$$0$—

La fonction renvoie $6$, qui est le PGCD de $48$ et $18$. C'est l'algorithme d'Euclide : on remplace le couple par (diviseur, reste) jusqu'à ce que le reste soit nul.

Il termine toujours, car le reste est strictement plus petit que le diviseur à chaque tour : la suite des b décroît strictement dans $\mathbb{N}$, elle atteint donc $0$.

À retenir

Affectation x = expression : on calcule à droite, on range à gauche. x = x + 1 est une action, pas une équation.

Types : int, float, bool, str. 12 $\neq$ "12".

= affecte, == compare. Dans une cascade if/elif, l'ordre des tests décide du résultat.

for : nombre de tours connu · range(a, b) s'arrête avant b · range(n) part de $0$. while : condition testée avant chaque tour ; s'assurer qu'on progresse vers la sortie.

Fonctions : return pour réutiliser le résultat (jamais print seul).

Hasard : randint(a, b) inclut les deux bornes ; deux exécutions diffèrent ; une simulation illustre, elle ne démontre pas.

La trace d'exécution — écrire à la main les valeurs tour par tour — est l'outil qui débloque toutes les boucles.

Chapitre suivant, le dernier : la logique, les ensembles et les raisonnements.

Le programme complet de seconde

Nombres et calculs, algèbre

  1. Arithmétique : multiples, diviseurs, pair et impair
  2. Les nombres réels, intervalles et valeur absolue
  3. Calcul algébrique : puissances et racines
  4. Équations, inéquations et tableaux de signes

Fonctions

  1. Fonctions : vocabulaire et lectures graphiques
  2. Variations, extrémums et fonctions affines
  3. Les fonctions de référence

Géométrie

  1. Les vecteurs du plan
  2. Les droites du plan

Statistiques et probabilités

  1. Information chiffrée et statistiques
  2. Probabilités et tableaux croisés

Parties transversales

  1. Algorithmique et programmation en Python
  2. Logique, ensembles et raisonnements

← Chapitre 11 · Probabilités et tableaux croisés &nbsp;|&nbsp; Chapitre 13 · Logique, ensembles et raisonnements →

Tous les cours · coursDeLion · La chaîne YouTube