← Retour au sommaire

Chapitre 13 – Algorithmique et programmation

Chapitre 13 | Seconde générale et technologique | Mathématiques

Dernière mise à jour : 21 octobre 2026

Objectifs du chapitre

Ce chapitre est transversal : ses notions se réinvestissent dans tous les autres (arithmétique, nombres réels, statistiques, probabilités, fonctions). Le langage de référence est Python. On y cultive une exigence d'exactitude, de rigueur et de vérification.

Convention du programme

En langage naturel (pseudo-code), l'affectation se note avec une flèche \(\leftarrow\). En Python, elle s'écrit avec le signe =. Nous ferons systématiquement la correspondance entre ces deux registres.

I. Variables, types et affectation

1. Variables et types

Définition — Variable

Une variable informatique est une « boîte » nommée qui associe un nom à une valeur, stockée en mémoire. Le type de la variable indique la nature de cette valeur et les opérations que l'on peut lui appliquer.

TypeNomExempleDescription
intentierage = 15nombre entier (positif, négatif ou nul)
floatflottanttaille = 1.72nombre « à virgule » (décimal approché)
boolbooléenmajeur = Falsevaleur logique : True ou False
strchaînenom = "Zoé"texte, entre guillemets
Points de syntaxe
Exemple 
n = 7            # int  : un entier
x = 2.5          # float: un flottant
est_pair = True  # bool : un booléen
prenom = "Ali"   # str  : une chaîne de caractères

print(type(n))        # <class 'int'>
print(type(x))        # <class 'float'>
print(type(prenom))   # <class 'str'>
Vigilance — entier vs flottant

10 / 2 vaut 5.0 (un flottant) en Python, car l'opérateur / renvoie toujours un flottant. Pour un quotient entier, on utilise // (division entière) : 10 // 3 vaut 3.

Exercice d'application 1. Indiquer le type le plus adapté (int, float, bool, str) : (a) le nombre d'élèves d'une classe ; (b) la taille en mètres d'une personne ; (c) la réponse à « la porte est-elle ouverte ? » ; (d) le code postal "75005".

(a) int. (b) float. (c) bool. (d) str (un code postal est du texte : pas de calcul, et le zéro initial doit être conservé).

2. L'affectation

Définition — Affectation

Affecter une valeur à une variable, c'est ranger cette valeur dans la boîte portant le nom de la variable.

Le signe = n'est PAS l'égalité mathématique

C'est une instruction : « range la valeur de droite dans la variable de gauche ». On lit de droite à gauche.

Exemple — incrémenter 
compteur = 0
compteur = compteur + 1   # on calcule (compteur + 1) = 1, puis on range dans compteur
print(compteur)           # 1

La ligne compteur = compteur + 1 serait absurde en mathématiques (\(x = x+1\) n'a pas de solution), mais en informatique elle augmente de 1 la valeur stockée.

Exemple — échanger deux variables 
a = 3
b = 8
# Pour échanger a et b, on utilise une variable temporaire :
temp = a
a = b
b = temp
print(a, b)   # 8 3
Exercice d'application 2. Que valent a et b à la fin ? 
a = 5
b = 3
a = a + b
b = a - b
a = a - b

Ligne 3 : a = 5 + 3 = 8. Ligne 4 : b = 8 - 3 = 5. Ligne 5 : a = 8 - 5 = 3. Donc a vaut 3 et b vaut 5 : c'est un échange sans variable temporaire.

II. Séquence, formules et instruction conditionnelle

1. Séquence d'instructions et formules

Définition — Séquence

Une séquence est une suite d'instructions exécutées l'une après l'autre, dans l'ordre, de haut en bas.

Écrire une formule

Une formule combine des variables et des opérateurs pour produire une nouvelle valeur. Opérateurs Python usuels :

+ addition, - soustraction, * multiplication, / division, // division entière, % reste (modulo), ** puissance.

Exemple — aire d'un disque 
rayon = 4
pi = 3.14159
aire = pi * rayon ** 2    # la puissance ** est calculée avant la multiplication
print(aire)               # 50.26544
Priorités

Comme en maths : les puissances d'abord, puis × et ÷, puis + et −. En cas de doute, utiliser des parenthèses : (a + b) / 2. L'opérateur modulo % donne le reste : 17 % 5 vaut 2 ; il sert à tester la divisibilité.

2. L'instruction conditionnelle

Définition — Instruction conditionnelle

Une instruction conditionnelle exécute un bloc d'instructions seulement si une condition (expression booléenne) est vraie.

Structure Python 
if condition:
    # bloc exécuté si la condition est vraie (INDENTÉ de 4 espaces)
elif autre_condition:
    # bloc exécuté si la 1re est fausse et celle-ci vraie
else:
    # bloc exécuté si toutes les conditions précédentes sont fausses
Vigilance — l'indentation fait le bloc

En Python, ce sont les espaces en début de ligne (l'indentation, en général 4 espaces) qui délimitent le bloc de l'if. Un : termine la ligne de condition. elif et else sont facultatifs.

OpérateurSignification
==égal à
!=différent de
< , >strictement inférieur / supérieur
<= , >=inférieur ou égal / supérieur ou égal

Opérateurs de comparaison (ils renvoient un booléen). On combine des conditions avec and, or, not.

Piège majeur — == vs =

== teste l'égalité (une question), = affecte (un ordre). Ne pas les confondre dans un if.

Exemple — valeur absolue « à la main » 
x = -6
if x >= 0:
    valeur_absolue = x
else:
    valeur_absolue = -x
print(valeur_absolue)   # 6
Exemple — mention selon une note 
note = 14
if note >= 16:
    mention = "très bien"
elif note >= 14:
    mention = "bien"
elif note >= 12:
    mention = "assez bien"
else:
    mention = "pas de mention"
print(mention)   # bien
Exercice d'application 3. Écrire une fonction signe(x) renvoyant "positif" si x > 0, "négatif" si x < 0, et "nul" si x == 0. 
def signe(x):
    if x > 0:
        return "positif"
    elif x < 0:
        return "négatif"
    else:
        return "nul"

print(signe(-4))   # négatif

III. Les boucles

1. La boucle bornée (for)

Définition — Boucle bornée

Une boucle bornée répète un bloc d'instructions un nombre de fois connu à l'avance.

La fonction range
Exemple — afficher les carrés de 1 à 5 
for i in range(1, 6):   # i prend les valeurs 1, 2, 3, 4, 5
    print(i, "au carré vaut", i ** 2)
Exemple — accumulation : somme des entiers de 1 à 100 
somme = 0
for i in range(1, 101):   # i va de 1 à 100
    somme = somme + i     # on accumule dans la variable somme
print(somme)              # 5050
Schéma fondamental de l'accumulateur : « initialiser un accumulateur (souvent à \(0\)), puis le mettre à jour à chaque tour de boucle ». On le retrouve pour les sommes, les moyennes, les comptages de probabilités, etc.

2. La boucle non bornée (while)

Définition — Boucle non bornée

Une boucle non bornée répète un bloc tant qu'une condition reste vraie. Le nombre de répétitions n'est pas connu à l'avance.

Exemple — première puissance de 2 dépassant 1000 
p = 1
while p <= 1000:      # tant que p n'a pas dépassé 1000
    p = p * 2         # on double p
print(p)              # 1024
Vigilance — la boucle infinie

Il faut garantir que la condition finira par devenir fausse, sinon le programme tourne indéfiniment. Ici, p double à chaque tour, donc il finit toujours par dépasser \(1000\). Toujours vérifier qu'une variable de la condition évolue à l'intérieur de la boucle.

for ou while ?

Si l'on connaît le nombre de tours à l'avance → for. Si l'on répète jusqu'à ce qu'une condition soit atteinte (dépasser un seuil, obtenir un certain tirage…) → while.

Exercice d'application 4. Écrire une fonction somme_carres(n) renvoyant \(1^2 + 2^2 + \dots + n^2\). Tester avec \(n = 4\) (résultat attendu : \(30\)). 
def somme_carres(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k ** 2
    return total

print(somme_carres(4))   # 30  (1 + 4 + 9 + 16)

IV. Les fonctions

1. Définir et appeler une fonction

Définition — Fonction informatique

Une fonction est un bloc de code nommé, prenant éventuellement des arguments (les données d'entrée), et renvoyant (mot-clé return) un résultat. On la réutilise en l'appelant par son nom.

Structure Python 
def nom_de_la_fonction(argument1, argument2):
    # instructions utilisant les arguments
    return resultat
Exemple — fonction à un puis à deux arguments 
def carre(x):
    return x ** 2

print(carre(7))    # 49  -> appel avec l'argument 7

def moyenne_deux(a, b):
    return (a + b) / 2

print(moyenne_deux(12, 18))   # 15.0
return vs print

return renvoie une valeur au programme (on peut la réutiliser, la stocker, la recalculer). print affiche seulement à l'écran. Une fonction de calcul doit renvoyer (return) son résultat.

2. Fonction renvoyant un nombre aléatoire (module random)

Pour modéliser le hasard (expériences aléatoires, probabilités), on utilise le module random, qu'il faut d'abord importer.

Deux fonctions clés
Exemple — simuler un dé 
import random

def lancer_de():
    """Renvoie le résultat d'un lancer de dé à 6 faces."""
    return random.randint(1, 6)

print(lancer_de())   # par exemple 4 (change à chaque exécution)

En appelant plusieurs fois une telle fonction, on obtient une série statistique de résultats, sur laquelle on calcule des fréquences, une moyenne, etc.

Exercice d'application 5. On place \(1000\) € sur un compte rapportant \(3\%\) par an (capital multiplié par \(1{,}03\) chaque année). Écrire une fonction annees_pour_doubler() renvoyant le nombre d'années pour dépasser \(2000\) €. 
def annees_pour_doubler():
    capital = 1000
    n = 0
    while capital <= 2000:
        capital = capital * 1.03
        n = n + 1
    return n

print(annees_pour_doubler())   # 24

On utilise while car on ignore d'avance le nombre d'années.

V. Méthodes-types

Méthode 1 — Traduire un algorithme (langage naturel → Python)
  1. Repérer les variables et leur type.
  2. Traduire chaque affectation \(\leftarrow\) par =.
  3. Traduire « Si … alors … sinon » par if / else, « Pour » par for, « Tant que » par while.
  4. Indenter correctement les blocs (4 espaces).
  5. Tester sur un exemple pour vérifier.

Exemple résolu. Algorithme (calcul de la factorielle \(5! = 120\)) :

# Langage naturel :
# n <- 5
# resultat <- 1
# Pour k allant de 1 à n faire
#     resultat <- resultat * k
# Afficher resultat

n = 5
resultat = 1
for k in range(1, n + 1):   # k va de 1 à n inclus
    resultat = resultat * k
print(resultat)             # 120
Méthode 2 — Choisir le bon type de boucle

Exemple résolu — approcher \(\sqrt{2}\). On cherche le plus petit \(x\) (par pas de \(0{,}001\)) tel que \(x^2 \ge 2\) : on ne sait pas d'avance combien d'étapes, d'où une boucle non bornée.

x = 1
while x ** 2 < 2:      # tant que x² n'a pas atteint 2
    x = x + 0.001
print(round(x, 3))     # 1.415  (valeur approchée de racine de 2 par excès)
Méthode 3 — Fonction d'une expérience aléatoire et sa répétition
  1. Écrire une fonction simulant une expérience et renvoyant son résultat numérique (souvent avec random).
  2. Pour répéter \(n\) fois de façon indépendante, utiliser une boucle for et accumuler.
  3. Renvoyer la statistique voulue (fréquence, moyenne…).

Exemple résolu — fréquence de « 6 » sur \(n\) lancers.

import random

def un_lancer():
    """Renvoie 1 si on obtient 6, sinon 0."""
    de = random.randint(1, 6)
    if de == 6:
        return 1
    else:
        return 0

def frequence_de_six(n):
    """Répète n fois l'expérience et renvoie la fréquence de 6."""
    total = 0
    for i in range(n):
        total = total + un_lancer()   # on cumule les succès
    return total / n

print(frequence_de_six(100000))   # proche de 1/6 ≈ 0.167

VI. Python relié aux autres chapitres

Ce chapitre étant transversal, voici quelques réinvestissements typiques.

Arithmétique — tester si un entier est multiple d'un autre 
def est_multiple(a, b):
    """Renvoie True si a est un multiple de b, False sinon."""
    return a % b == 0     # l'expression a % b == 0 est un booléen

print(est_multiple(15, 3))   # True
print(est_multiple(16, 3))   # False
Statistiques — fonctions moyenne et écart type (à savoir LIRE)

Le programme demande de lire et comprendre une fonction renvoyant une moyenne ou un écart type ; aucune connaissance sur les listes n'est exigée. On peut néanmoins parcourir une liste comme réservoir de valeurs.

def moyenne(valeurs):
    """Moyenne d'une série (valeurs parcourues une à une)."""
    somme = 0
    n = 0
    for v in valeurs:
        somme = somme + v
        n = n + 1
    return somme / n

def ecart_type(valeurs):
    """Écart type de la série (racine de la variance)."""
    m = moyenne(valeurs)
    somme_carres = 0
    n = 0
    for v in valeurs:
        somme_carres = somme_carres + (v - m) ** 2
        n = n + 1
    variance = somme_carres / n
    return variance ** 0.5     # racine carrée = puissance 0.5

serie = [8, 12, 10, 14, 6]
print(moyenne(serie))       # 10.0
print(ecart_type(serie))    # 2.8284...
Probabilités — loi des grands nombres par simulation 
import random

def frequence_pile(n):
    """Fréquence de 'pile' sur n lancers d'une pièce équilibrée."""
    nb_pile = 0
    for i in range(n):
        if random.random() < 0.5:     # 'pile' avec probabilité 1/2
            nb_pile = nb_pile + 1
    return nb_pile / n

print(frequence_pile(10))       # très variable
print(frequence_pile(100000))   # proche de 0.5 : loi des grands nombres

Erreurs fréquentes / points de vigilance

Les pièges du chapitre

❌ Confondre = (affectation) et == (test d'égalité).

✅ = range une valeur ; == pose une question dans un if.

❌ Oublier l'indentation ou le : en fin d'en-tête.

✅ Le bloc d'un if, for, while, def est défini par 4 espaces d'indentation.

❌ Se tromper sur range : range(1, 6) s'arrête à 5.

✅ Pour « de 1 à \(n\) inclus », écrire range(1, n + 1).

❌ Mélanger return et print, ou créer une boucle while infinie.

✅ Une fonction de calcul renvoie (return) son résultat ; une variable de la condition doit évoluer dans la boucle.

❌ Virgule au lieu du point pour les décimaux ; guillemets manquants ; import random oublié.

✅ 3.5 (jamais 3,5) ; nom = "Ali" ; importer le module avant tout appel.

L'essentiel à retenir

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