En Seconde, un programme Python s'écrit avec quatre outils. Les variables (entier, flottant, booléen, chaîne de caractères) reçoivent une valeur par affectation avec =. Viennent ensuite l'instruction conditionnelle if / else et les boucles for (nombre de tours connu) et while (arrêt sur une condition). Enfin, les fonctions définies par def renvoient un résultat avec return. Le module random ajoute le hasard pour simuler des expériences.
Exemple : avec def f(x): return x**2 - 4*x + 1, l'appel f(3) renvoie , et la boucle for x in range(-1, 6): print(x, f(x)) affiche le tableau de valeurs de pour les entiers de à 5. Attention : en Python, la puissance s'écrit **, jamais ^.
Objectifs : lire, compléter, corriger et écrire de courts programmes au service des maths (calculs, seuils, tableaux de valeurs, simulations, statistiques), en prédisant leur affichage. Prérequis : les variables, boucles et tests vus au collège en algorithmique avec Scratch.
Sommaire9 parties
Variables et types en Python
Variable et type
Une variable est un nom qui désigne une valeur stockée en mémoire. Chaque valeur a un type, que la fonction type permet de connaître :
int(entier) :7,-12;float(flottant, nombre à virgule) :3.5,2.0; le séparateur décimal est un point ;bool(booléen) :TrueouFalse, résultat d'une comparaison ;str(chaîne de caractères) :"seconde", écrite entre guillemets.
| Opération | Python | Exemple | Résultat |
| somme, différence, produit | + - * | 4 * 3 | 12 |
| quotient décimal | / | 7 / 2 | 3.5 |
| quotient entier | // | 7 // 2 | 3 |
| reste de la division | % | 7 % 2 | 1 |
| puissance | ** | 2**10 | 1024 |
Exemple 1 : prévoir le type d’un résultat
a = 7
b = 7 / 2
c = a > 5
d = "seconde"
print(type(a), type(b), type(c), type(d))
print(7 // 2, 7 % 2, 2**10, 7 / 7)Affichage obtenu :
<class 'int'> <class 'float'> <class 'bool'> <class 'str'>
3 1 1024 1.0La division / donne toujours un flottant, même quand elle « tombe juste » : 7 / 7 vaut 1.0. La variable c contient True, car . Le reste a % b sert à tester la divisibilité : a % b == 0 signifie que a est un multiple de b.
Les flottants sont des valeurs approchées
print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(abs((0.1 + 0.2) - 0.3) < 1e-9)Affichage obtenu :
0.30000000000000004
False
TrueL'ordinateur code les nombres en base 2, et n'y a pas d'écriture finie. Pour comparer deux flottants, on teste plutôt si leur écart est très petit, comme à la dernière ligne.
Affectation et séquence d’instructions
Affectation
L'instruction x = expression calcule d'abord l'expression de droite avec les valeurs actuelles, puis range le résultat dans x, en remplaçant l'ancienne valeur. Ce n'est pas une égalité mathématique : x = x + 1 augmente x de 1, alors que l'équation n'a pas de solution. Les instructions s'exécutent dans l'ordre où elles sont écrites.
Exemple 2 : échanger deux valeurs, avec un tableau de suivi
a = 3
b = 5
a = a + b
b = a - b
a = a - b
print(a, b)On suit les variables ligne par ligne :
| Instruction | a | b |
a = 3 | 3 | |
b = 5 | 3 | 5 |
a = a + b | 8 | 5 |
b = a - b | 8 | 3 |
a = a - b | 5 | 3 |
Affichage obtenu :
5 3Les valeurs ont été échangées. Ce tableau de suivi est la meilleure façon de prévoir l'affichage d'un programme ou de trouver une erreur.
Exemple 3 : deux évolutions successives
prix = 80
prix = prix * 1.05
prix = prix * 0.9
print(round(prix, 2))Affichage obtenu :
75.6Augmenter de 5 % revient à multiplier par , baisser de 10 % à multiplier par . Le prix final est : une hausse de 5 % suivie d'une baisse de 10 % donne une baisse de %, et non de 5 %. La fonction round(prix, 2) arrondit au centième.
Instruction conditionnelle et connecteurs logiques
Instruction conditionnelle
Une instruction conditionnelle exécute un bloc seulement si une condition est vraie :
if condition:
bloc exécuté si la condition est vraie
elif autre_condition:
bloc exécuté si la première est fausse et la seconde vraie
else:
bloc exécuté dans tous les autres casLes deux-points et le décalage (indentation de quatre espaces) délimitent chaque bloc. Les comparaisons s'écrivent == (égal), != (différent), <, <=, >, >=. Les parties elif et else sont facultatives.

Exemple 4 : position d’un point par rapport à une droite
Un point est au-dessus de la droite d'équation si son ordonnée dépasse .
def position(x, y):
if y > 2 * x - 1:
return "au-dessus"
elif y == 2 * x - 1:
return "sur la droite"
else:
return "au-dessous"
print(position(1, 3), position(2, 3), position(4, 0))Affichage obtenu :
au-dessus sur la droite au-dessousVérification à la main : pour , ; pour , ; pour , . Le test == convient ici parce que les calculs portent sur des entiers.
Connecteurs et, ou, non
Les conditions se combinent avec and (vrai si les deux sont vraies), or (vrai si au moins une est vraie) et not (négation). La négation de « et » est « ou » : le et devient ou, et chaque inégalité est niée.
Exemple 5 : appartenir ou non à un intervalle
def dans_intervalle(x):
return -1 <= x and x <= 5
def hors_intervalle(x):
return x < -1 or x > 5
print(dans_intervalle(3), dans_intervalle(-2), hors_intervalle(-2))
print(hors_intervalle(6) == (not dans_intervalle(6)))Affichage obtenu :
True False True
TrueLa fonction dans_intervalle renvoie un booléen qui traduit . La seconde fonction traduit la négation, , et la dernière ligne vérifie sur un exemple que les deux sont bien contraires.
Boucle for et fonction range
Boucle bornée
La boucle for k in range(a, b): répète son bloc pour k prenant les valeurs entières , , …, : la borne est exclue. range(n) donne 0, 1, …, , soit tours. On l'utilise quand le nombre de répétitions est connu à l'avance.
Exemple 6 : somme des carrés de 1 à 10
s = 0
for k in range(1, 11):
s = s + k**2
print(s)Affichage obtenu :
385La variable s, appelée accumulateur, part de 0 et reçoit un terme à chaque tour : après le tour , elle vaut . Début du suivi : , puis , puis , puis . Pour aller jusqu'à 10 inclus, il faut écrire range(1, 11).
Exemple 7 : tableau de valeurs d’une fonction
def f(x):
return x**2 - 4*x + 1
for x in range(-1, 6):
print(x, f(x))Affichage obtenu :
-1 6
0 1
1 -2
2 -3
3 -2
4 1
5 6Le tableau suggère que est décroissante puis croissante, avec un minimum en , et que la courbe est symétrique autour de . Ce n'est qu'une observation sur des valeurs entières : on la confirme par le calcul, ici avec .
Boucle while : chercher un seuil
Boucle non bornée
La boucle while condition: répète son bloc tant que la condition est vraie. On l'utilise quand on ne sait pas d'avance combien de tours seront nécessaires. La condition est celle qui permet de continuer, et le bloc doit modifier une variable de la condition, sinon la boucle ne s'arrête jamais.
Exemple 8 : première puissance de 1,5 qui dépasse 100
n = 0
p = 1
while p <= 100:
p = p * 1.5
n = n + 1
print(n, round(p, 2))Affichage obtenu :
12 129.75À chaque tour, p est multiplié par et n augmente de 1 : la relation p reste vraie avant et après chaque tour. La boucle s'arrête dès que . Comment vérifier : et , donc est bien le premier entier qui convient.
Exemple 9 : passer sous un seuil, avec une fonction
def seuil_bas(q, s):
n = 0
p = 1
while p >= s:
p = p * q
n = n + 1
return n
print(seuil_bas(0.8, 0.01), seuil_bas(0.5, 0.01))Affichage obtenu :
21 7Pour , la fonction renvoie le premier entier tel que . Contrôle : et ; et . Avec et , la condition resterait vraie pour toujours : il faut connaître les cas où un programme s'arrête.
| Situation | Boucle adaptée |
| Calculer une somme de 1 à 50, afficher 10 valeurs, simuler 1 000 lancers | for |
| Trouver le premier rang où une quantité dépasse un seuil | while |
| Répéter jusqu'à obtenir un 6 avec un dé | while |
Fonctions Python à un ou plusieurs arguments
Fonction Python
Une fonction se définit par def nom(arguments): suivi d'un bloc indenté. L'instruction return valeur termine la fonction et renvoie cette valeur au programme qui l'a appelée, qui peut la stocker ou la réutiliser dans un calcul. Une fonction peut avoir plusieurs arguments, séparés par des virgules.
Exemple 10 : images par une fonction du second degré
def g(x):
return 2*x**2 - 3*x - 5
print(g(0), g(-1), g(2.5))Affichage obtenu :
-5 0 0.0Calcul à la main : et . Les nombres et sont donc deux antécédents de 0. Le résultat 0.0 est un flottant parce que l'argument 2.5 en est un.
Exemple 11 : distance entre deux points, quatre arguments
from math import sqrt
def distance(xA, yA, xB, yB):
return sqrt((xB - xA)**2 + (yB - yA)**2)
print(distance(1, 2, 4, 6), distance(0, 0, 1, 1))Affichage obtenu :
5.0 1.4142135623730951La fonction applique : pour et , . Le second résultat est une valeur approchée de . La racine carrée sqrt doit être importée du module math.
Exemple 12 : renvoyer ou afficher, ce n’est pas pareil
def double_affiche(x):
print(2 * x)
def double(x):
return 2 * x
y = double(5) + 1
print(y)
z = double_affiche(5)
print(z)Affichage obtenu :
11
10
Nonedouble(5) renvoie 10, qu'on peut réutiliser : y vaut 11. double_affiche(5) affiche 10 à l'écran mais ne renvoie rien ; Python lui donne alors la valeur spéciale None, et z est inutilisable dans un calcul.
Nombres aléatoires et simulation d’une expérience
Fonctions du module random
randint(a, b)renvoie un entier au hasard entreaetb, les deux bornes incluses ;randint(1, 6)simule un dé équilibré.random()renvoie un flottant au hasard dans ; la conditionrandom() < pest vraie avec une probabilité .seed(n)fixe le point de départ du générateur : avec la même graine, on obtient les mêmes tirages, ce qui permet de reproduire une simulation.
Exemple 13 : une fonction qui renvoie le résultat d’une expérience
from random import randint, random, seed
seed(2026)
def lancer_de():
return randint(1, 6)
def pile():
if random() < 0.5:
return 1
else:
return 0
print(lancer_de(), lancer_de(), lancer_de(), pile(), pile())Affichage obtenu (avec la graine 2026) :
1 3 5 0 0Chaque appel produit un nouveau tirage. La fonction pile code le résultat par 1 (pile) ou 0 (face) : additionner ces valeurs revient à compter les piles.
Exemple 14 : répéter une expérience et observer la fréquence
from random import randint, seed
def frequence_six(n):
nb = 0
for i in range(n):
if randint(1, 6) == 6:
nb = nb + 1
return nb / n
seed(1)
for n in [10, 100, 1000, 100000]:
print(n, frequence_six(n))Affichage obtenu (avec la graine 1) :
10 0.1
100 0.21
1000 0.161
100000 0.1654La fonction répète lancers indépendants et renvoie la fréquence des 6. Sur 10 ou 100 lancers, la fréquence varie beaucoup ; sur 100 000 lancers, elle est proche de . C'est la loi des grands nombres. Avec une autre graine, les nombres changent, mais la tendance reste la même.
Lire une fonction qui calcule une moyenne ou un écart type
On doit savoir lire une fonction qui renvoie une moyenne ou un écart type, sans connaissance particulière sur les listes. Il suffit de savoir que for x in serie: donne à x, tour à tour, chaque valeur de la série, et que len(serie) est le nombre de valeurs.
Exemple 15 : moyenne et écart type d’une série de notes
from math import sqrt
def moyenne(serie):
s = 0
for x in serie:
s = s + x
return s / len(serie)
def ecart_type(serie):
m = moyenne(serie)
s = 0
for x in serie:
s = s + (x - m)**2
return sqrt(s / len(serie))
notes = [8, 11, 12, 13, 16]
print(moyenne(notes), round(ecart_type(notes), 2))Affichage obtenu :
12.0 2.61Lecture de ecart_type : elle calcule d'abord la moyenne , puis accumule les carrés des écarts , en fait la moyenne et prend la racine carrée. C'est exactement la définition de l'écart type, . Contrôle à la main : , écarts au carré , , , , , de somme 34 ; .
Exemple 16 : moyenne d’une série obtenue par simulation
from random import randint, seed
def moyenne_des(n):
s = 0
for i in range(n):
s = s + randint(1, 6)
return s / n
seed(5)
print(moyenne_des(10), moyenne_des(1000), moyenne_des(100000))Affichage obtenu (avec la graine 5) :
4.5 3.423 3.50023Ici, la série n'est jamais stockée : chaque résultat est ajouté à s dès qu'il est tiré. La moyenne des résultats se rapproche de quand augmente.
Erreurs fréquentes en Python
Écrire la puissance avec un accent circonflexe
Ligne fausse : y = 4*x^2 + x - 3. En Python, ^ n'est pas la puissance mais un « ou exclusif » sur les bits : 2^3 vaut 1, pas 8. Pour , cette ligne donne 9 au lieu de , sans message d'erreur. Correction : 4*x**2 + x - 3. Détection : calculer une image à la main et la comparer.
Confondre affectation et test d’égalité
Ligne fausse : if a % 2 = 0:. Le signe = range une valeur, le test d'égalité s'écrit ==. Python refuse cette ligne avec une erreur de syntaxe, qui indique la ligne fautive.
Se tromper de borne dans range
Ligne fausse, pour additionner les entiers de 1 à 100 : for k in range(1, 100):. La borne 100 est exclue, donc la somme s'arrête à 99 et vaut 4 950 au lieu de 5 050. Correction : range(1, 101). Détection : tester avec une petite valeur, par exemple jusqu'à 4, où l'on connaît la réponse .
Oublier de modifier la variable d’une boucle while
Programme faux, pour trouver le premier entier tel que atteigne 50 : s = 0, k = 0, puis while s < 50: suivi seulement de k = k + 1. Comme s n'est jamais modifié, la condition reste vraie et le programme tourne sans fin. Correction : ajouter s = s + k dans le bloc ; on obtient alors , car et . Détection : vérifier que chaque variable de la condition est modifiée dans le bloc, et dans le bon sens.
Afficher au lieu de renvoyer
Fonction fausse : def aire(r): print(3.14 * r**2), puis total = aire(2) + aire(3). La fonction affiche les aires mais renvoie None, et l'addition provoque une erreur TypeError. Correction : remplacer print par return dans la fonction.
Mal placer le return dans une boucle
Fonction fausse : dans for x in serie:, écrire return s / len(serie) avec la même indentation que s = s + x. Le return est alors exécuté dès le premier tour, et la fonction renvoie la première valeur divisée par l'effectif. Correction : désindenter le return pour qu'il soit après la boucle. Détection : tester la fonction sur une série dont on connaît la moyenne.
Pour s'entraîner : exercices corrigés d'algorithmique et Python en Seconde, avec les affichages exacts de chaque programme.