Chapitre 7 | Première technologique (enseignement commun) | Mathématiques
Dernière mise à jour : 21 octobre 2026, 09:36
if/elif/else)for) et une boucle non bornée (while)=.Une variable est un nom qui désigne un emplacement mémoire dans lequel on range une valeur. Affecter une valeur à une variable, c'est y ranger cette valeur. En langage naturel on note \(x \leftarrow 5\) ; en Python on écrit x = 5.
L'affectation se lit de droite à gauche : on évalue d'abord l'expression à droite, puis on range le résultat dans la variable de gauche. Ainsi x = x + 1 signifie « la nouvelle valeur de \(x\) est l'ancienne, augmentée de 1 ».
# Affectation et types de variables
n = 12 # entier (int)
prix = 3.5 # flottant (float)
nom = "Ada" # chaîne de caractères (str)
present = True # booléen (bool)
# L'affectation se lit de droite à gauche
x = 5
x = x + 1 # on lit l'ancien x (5), on ajoute 1, on range 6 dans x
print(x) # affiche 6Le type d'une variable dépend de la valeur qu'elle contient ; on peut le vérifier avec la fonction type.
print(type(12)) # <class 'int'>
print(type(3.5)) # <class 'float'>
print(type("Ada")) # <class 'str'>x = 4
x = x * 3
x = x - 2
print(x)\(x=4\), puis \(x=4\times 3=12\), puis \(x=12-2=10\). Le programme affiche 10.
Une instruction conditionnelle exécute un bloc d'instructions selon qu'une condition est vraie ou fausse. En Python : if (si), elif (sinon si) et else (sinon). Le bloc concerné est indenté (décalé vers la droite).
# Signe d'un nombre
x = -4
if x > 0:
print("positif")
elif x == 0:
print("nul")
else:
print("négatif") # affiche négatifUne condition est une expression booléenne (elle vaut True ou False). On la construit avec les comparaisons (==, !=, <, <=, >, >=) et les opérateurs logiques and, or, not.
age = 17
if age >= 15 and age <= 18:
print("lycéen probable")= et ==
= est l'affectation (« ranger dans »), == est le test d'égalité (« est-il égal à ? »). Dans un if, on utilise toujours ==.
note = 12 ?
note = 12
if note >= 10:
print("admis")
else:
print("recalé")La condition note >= 10 est vraie (\(12 \geq 10\)), donc le programme affiche admis.
Une boucle répète un bloc d'instructions. La boucle for est bornée : on connaît d'avance le nombre de répétitions. La boucle while est non bornée : on répète tant qu'une condition reste vraie.
for avec rangerange(n) parcourt les entiers de \(0\) à \(n-1\). range(a, b) parcourt de \(a\) à \(b-1\). range(a, b, pas) avance par pas.
# Afficher les entiers de 0 à 4
for i in range(5):
print(i) # affiche 0, 1, 2, 3, 4
# Afficher les entiers de 2 à 10 de 2 en 2
for i in range(2, 11, 2):
print(i) # affiche 2, 4, 6, 8, 10whileOn l'utilise quand on ne sait pas d'avance combien d'itérations seront nécessaires : par exemple pour chercher un seuil.
# Plus petit entier n tel que 2**n dépasse 1000
n = 0
while 2 ** n <= 1000:
n = n + 1
print(n) # affiche 10 (car 2**10 = 1024)Dans une boucle while, il faut s'assurer que la condition finira par devenir fausse (on doit faire évoluer la variable de test), sinon la boucle ne s'arrête jamais.
n = 1
while n < 20:
n = n * 2
print(n)\(n : 1 \to 2 \to 4 \to 8 \to 16 \to 32\). Dès que \(n=32\), la condition \(n \lt 20\) est fausse. Le programme affiche 32.
Un compteur est une variable que l'on augmente de 1 à chaque fois qu'un événement se produit (pour dénombrer). Un accumulateur est une variable dans laquelle on accumule un résultat au fil d'une boucle (pour calculer une somme ou un produit).
Compteur. On l'initialise à \(0\), puis on fait « compteur ← compteur + 1 » à chaque événement.
# Compter les multiples de 3 entre 1 et 30
compteur = 0
for i in range(1, 31):
if i % 3 == 0: # i est-il un multiple de 3 ?
compteur = compteur + 1
print(compteur) # affiche 10Accumulateur (somme). On initialise la somme à \(0\) (élément neutre de l'addition).
# Somme des entiers de 1 à 100 : 1 + 2 + ... + 100
somme = 0
for k in range(1, 101):
somme = somme + k # accumulation : somme ← somme + k
print(somme) # affiche 5050Accumulateur (produit). On initialise le produit à \(1\) (élément neutre de la multiplication).
# Factorielle : 5! = 1 x 2 x 3 x 4 x 5
produit = 1
for k in range(1, 6):
produit = produit * k # accumulation : produit ← produit x k
print(produit) # affiche 120Une somme s'initialise à 0, un produit à 1, un compteur à 0. Un produit initialisé à 0 resterait nul !
somme = 0
for k in range(0, 11, 2):
somme = somme + k
print(somme) # affiche 30Une fonction est un bloc de code nommé qui reçoit des entrées (les paramètres, entre parenthèses) et renvoie une sortie grâce au mot-clé return. On la définit une fois avec def, puis on peut l'appeler autant de fois qu'on veut.
from math import pi
def aire_disque(r): # entrée : r (le rayon)
a = pi * r ** 2
return a # sortie : l'aire
# Appels de la fonction
print(aire_disque(1)) # affiche 3.141592653589793
print(aire_disque(2)) # affiche 12.566370614359172Pour résoudre une tâche complexe, on la découpe en tâches plus simples, chacune réalisée par une fonction. Le programme principal se contente d'assembler ces fonctions : c'est plus clair, plus facile à corriger et à réutiliser.
# Découpage d'une tâche : moyenne d'une liste de notes
def somme_notes(notes): # tâche 1 : additionner
s = 0
for note in notes:
s = s + note
return s
def moyenne(notes): # tâche 2 : réutilise la tâche 1
return somme_notes(notes) / len(notes)
mes_notes = [12, 15, 9, 18]
print(moyenne(mes_notes)) # affiche 13.5print ≠ return
print affiche à l'écran ; return renvoie une valeur réutilisable. Une fonction sans return renvoie None.
double(x) qui renvoie le double de x, puis afficher double(7).
def double(x):
return 2 * x
print(double(7)) # affiche 14Une liste est une collection ordonnée d'éléments que l'on peut modifier. Chaque élément est repéré par son indice (sa position). En Python, les indices commencent à \(0\).
En extension : on écrit tous les éléments entre crochets. On accède à un élément par L[indice] ; la longueur s'obtient avec len.
L = [10, 20, 30, 40]
print(L[0]) # affiche 10 (premier élément, indice 0)
print(L[-1]) # affiche 40 (indice -1 = dernier élément)
print(len(L)) # affiche 4 (la liste a 4 éléments)
L[1] = 99 # on modifie l'élément d'indice 1
print(L) # affiche [10, 99, 30, 40]Une liste de longueur \(n\) a ses indices de \(0\) à \(n-1\). Écrire L[n] provoque une erreur IndexError.
Itérer sur une liste : par éléments (plus lisible) ou par indices (quand on a besoin de la position).
notes = [12, 15, 9, 18]
# Parcours par éléments
for note in notes:
print(note)
# Parcours par indices
for i in range(len(notes)):
print("La note d'indice", i, "vaut", notes[i])Par ajouts successifs avec append : on part d'une liste vide [] et on ajoute un élément à la fin à chaque tour de boucle.
# Liste des carrés de 0 à 4, par ajouts successifs
carres = [] # on part d'une liste vide
for x in range(5):
carres.append(x ** 2) # on ajoute x**2 à la fin
print(carres) # affiche [0, 1, 4, 9, 16]En compréhension : écriture condensée, proche de la notation des ensembles. En mathématiques \(\{x^2 \mid x \in \{0,1,2,3,4\}\}\) ; en Python :
# Les carrés de 0 à 4, en compréhension
carres = [x ** 2 for x in range(5)]
print(carres) # affiche [0, 1, 4, 9, 16]
# Avec une condition (filtre) : les entiers pairs de 0 à 19
pairs = [x for x in range(20) if x % 2 == 0]
print(pairs) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]L = [1, 2, 3] (on écrit tout).L = [] puis L.append(...) dans une boucle.[expression for variable in ... if condition].L = [10, 20, 30]
L.append(40) # ajoute 40 à la fin -> [10, 20, 30, 40]
L.insert(1, 15) # insère 15 à l'indice 1 -> [10, 15, 20, 30, 40]
L.remove(30) # supprime la valeur 30 -> [10, 15, 20, 40]
dernier = L.pop() # retire et renvoie le dernier -> dernier = 40
del L[0] # supprime l'élément d'indice 0
print(L) # affiche [15, 20]L ?
L = [3 * n for n in range(1, 6)]
print(L)\(n\) parcourt \(1,2,3,4,5\), et on garde \(3n\). La liste vaut [3, 6, 9, 12, 15].
La fonction random() du module random renvoie un nombre flottant tiré au hasard dans l'intervalle \([0\,;1[\) (chaque tirage a la même probabilité de tomber n'importe où).
Une épreuve de Bernoulli n'a que deux issues : succès (codé \(1\)) avec probabilité \(p\), et échec (codé \(0\)) avec probabilité \(1-p\). Comme random() tombe dans \([0\,;p[\) avec probabilité \(p\), il suffit de tester random() < p.
from random import random
def bernoulli(p):
# entrée : p (probabilité de succès), sortie : 1 (succès) ou 0 (échec)
if random() < p:
return 1 # succès, de probabilité p
else:
return 0 # échec, de probabilité 1 - p
# Écriture plus courte, équivalente :
def bernoulli_court(p):
return 1 if random() < p else 0
print(bernoulli(0.3)) # affiche 0 ou 1Simuler un échantillon de taille \(n\) : on range \(n\) résultats dans une liste (ici en compréhension). Comme les succès sont des \(1\), le nombre de succès est la somme de la liste.
from random import random
def bernoulli(p):
return 1 if random() < p else 0
# Échantillon de taille 20, paramètre 0.4
echantillon = [bernoulli(0.4) for _ in range(20)]
print(echantillon) # ex. [0, 1, 0, 0, 1, 1, 0, ...]
nb_succes = sum(echantillon) # compteur / somme
print("Nombre de succès :", nb_succes)Le module random propose aussi randint(a, b) qui renvoie un entier au hasard entre a et b inclus.
from random import randint
de = randint(1, 6) # un entier au hasard entre 1 et 6
print(de)Les données réelles (relevés, enquêtes, mesures) sont souvent stockées dans un fichier texte au format CSV : une ligne par individu, les valeurs séparées par un point-virgule. Pour les traiter en Python, on lit le fichier ligne à ligne et on range chaque ligne, découpée en champs, dans une liste.
Exemple. Le fichier eleves.csv contient une ligne par élève, du type F;reussi (sexe puis résultat).
# Lecture du fichier eleves.csv, ligne à ligne
donnees = [] # liste des lignes traitées
fichier = open("eleves.csv")
for ligne in fichier: # on parcourt le fichier ligne à ligne
ligne = ligne.strip() # on retire le saut de ligne final
champs = ligne.split(";") # "F;reussi" -> ["F", "reussi"]
donnees.append(champs) # on ajoute la liste à donnees
fichier.close()
print(donnees[0]) # affiche ['F', 'reussi']
print(len(donnees)) # nombre d'élèves du fichierOn obtient une liste de listes : donnees[i] est la ligne d'indice i, donnees[i][0] son premier champ. C'est exactement le format attendu par le tableau croisé ci-dessous : on peut ainsi extraire de l'information d'un fichier de données réelles et l'analyser.
Pour un tableau croisé, on classe des données brutes selon deux critères simultanément et on compte les effectifs de chaque combinaison, à l'aide de compteurs.
Exemple. Des élèves sont décrits par leur sexe ("F"/"G") et leur réussite ("reussi"/"echoue"). Chaque élève est une liste de deux éléments (comme celles lues dans le fichier CSV ci-dessus).
donnees = [
["F", "reussi"], ["G", "echoue"], ["F", "reussi"], ["G", "reussi"],
["F", "echoue"], ["G", "reussi"], ["F", "reussi"], ["G", "echoue"],
]
F_reussi = 0; F_echoue = 0; G_reussi = 0; G_echoue = 0
for eleve in donnees:
sexe = eleve[0] # premier élément de la liste
resultat = eleve[1] # second élément
if sexe == "F" and resultat == "reussi":
F_reussi = F_reussi + 1
elif sexe == "F" and resultat == "echoue":
F_echoue = F_echoue + 1
elif sexe == "G" and resultat == "reussi":
G_reussi = G_reussi + 1
else:
G_echoue = G_echoue + 1
print("Filles :", F_reussi, "réussis,", F_echoue, "échoués")
print("Garçons:", G_reussi, "réussis,", G_echoue, "échoués")| reussi | echoue | |
|---|---|---|
| Filles | 3 | 1 |
| Garçons | 2 | 2 |
Beaucoup d'algorithmes ont un équivalent naturel dans un tableur : somme = somme + k ↔ =SOMME(...), un compteur conditionnel ↔ =NB.SI(...), random() ↔ =ALEA(), un tableau croisé ↔ un tableau croisé dynamique. Comprendre la version Python éclaire ce que fait le tableur « en coulisses ».
Suite \(u(0)=3\), \(u(n+1)=2\,u(n)-1\). On veut \(u(5)\).
u = 3
for i in range(1, 6): # i prend 1, 2, 3, 4, 5
u = 2 * u - 1 # u ← 2u - 1
print(u) # affiche 65Suite \(u(0)=100\), \(u(n+1)=0{,}9\,u(n)\). Plus petit rang \(n\) tel que \(u(n) \lt 50\).
u = 100
n = 0
while u >= 50: # tant que u n'est pas passé sous 50
u = 0.9 * u
n = n + 1
print(n) # affiche 7Solution positive de \(x^2-2=0\) (soit \(\sqrt{2}\)) par balayage au pas \(0{,}001\).
x = 0
while x ** 2 < 2:
x = x + 0.001 # x avance par pas de 0,001
print(round(x, 3)) # affiche 1.415\(n=100\) épreuves de paramètre \(p=0{,}3\), on compte les succès.
from random import random
succes = 0
for i in range(100):
if random() < 0.3: # succès de probabilité 0,3
succes = succes + 1 # compteur de succès
print(succes) # un nombre proche de 30On simule \(N=500\) échantillons de taille \(n=100\) d'une loi de Bernoulli de paramètre \(p=0{,}6\), on représente graphiquement les fréquences observées des \(1\), puis on compte celles situées dans l'intervalle \([\,p-ks\,;\,p+ks\,]\) pour \(k=1,2,3\) (où \(s\) est l'écart-type de la série des fréquences). C'est la traduction en Python de la fluctuation d'échantillonnage étudiée au chapitre 6.
from random import random
def frequence(n, p):
# fréquence observée des 1 dans un échantillon de taille n
succes = 0
for i in range(n):
if random() < p:
succes = succes + 1
return succes / n
# N = 500 échantillons de taille n = 100, paramètre p = 0.6
p = 0.6
frequences = [frequence(100, p) for _ in range(500)]
# Représentation graphique : nuage de points (rang ; fréquence)
import matplotlib.pyplot as plt
plt.plot(frequences, "o") # ou plt.hist(frequences) : histogramme
plt.show() # les fréquences fluctuent autour de p
# Moyenne et écart-type s de la série des fréquences
N = len(frequences)
moyenne = sum(frequences) / N
variance = sum([(f - moyenne) ** 2 for f in frequences]) / N
s = variance ** 0.5
# Compter les fréquences dans [p - k*s ; p + k*s] pour k = 1, 2, 3
for k in [1, 2, 3]:
compteur = 0
for f in frequences:
if p - k * s <= f and f <= p + k * s:
compteur = compteur + 1
print(k, ":", compteur, "échantillons sur", N)On constate que la très grande majorité des échantillons ont une fréquence à distance au plus \(2s\) ou \(3s\) de \(p\) : une fréquence hors de \([\,p-3s\,;\,p+3s\,]\) correspond à une situation rare.
❌ Confondre = (affectation) et == (test d'égalité).
✅ Dans un if, on écrit toujours ==.
❌ Oublier d'initialiser un accumulateur ou un compteur.
✅ Somme → 0, produit → 1, compteur → 0, liste (append) → [].
❌ Croire que range(n) atteint \(n\).
✅ range(n) s'arrête à \(n-1\) ; pour aller jusqu'à \(n\) inclus, écrire range(n + 1).
❌ Écrire L[len(L)] pour le dernier élément.
✅ Le dernier est L[len(L) - 1] ou L[-1] ; les indices vont de \(0\) à \(len(L)-1\).
❌ Boucle while infinie (variable de test non modifiée).
✅ Faire évoluer la variable pour que la condition finisse par devenir fausse.
❌ Confondre print et return.
✅ print affiche ; return renvoie une valeur réutilisable.
x = valeur (Python), se lit de droite à gauche.if / elif / else avec des conditions booléennes.for (bornée, nombre de tours connu) et while (non bornée, tant qu'une condition est vraie).return ; programmation modulaire = découper en fonctions réutilisables.append, compréhension).random() ∈ \([0\,;1[\) ; Bernoulli de paramètre \(p\) : 1 if random() < p else 0, nombre de succès = sum(echantillon).