Aller au contenu

Algorithmique et Python Seconde : variables, boucles et fonctions

Niveau
Seconde
Type
Cours
Lecture
13 min

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 32−4×3+1=−23^2-4\times3+1=-2, et la boucle for x in range(-1, 6): print(x, f(x)) affiche le tableau de valeurs de ff pour les entiers de −1-1 à 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) : True ou False, résultat d'une comparaison ;
  • str (chaîne de caractères) : "seconde", écrite entre guillemets.
OpérationPythonExempleRésultat
somme, différence, produit+ - *4 * 312
quotient décimal/7 / 23.5
quotient entier//7 // 23
reste de la division%7 % 21
puissance**2**101024

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.0

La division / donne toujours un flottant, même quand elle « tombe juste » : 7 / 7 vaut 1.0. La variable c contient True, car 7>57\gt5. 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
True

L'ordinateur code les nombres en base 2, et 0,10{,}1 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 x=x+1x=x+1 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 :

Instructionab
a = 33
b = 535
a = a + b85
b = a - b83
a = a - b53

Affichage obtenu :

5 3

Les 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.6

Augmenter de 5 % revient à multiplier par 1,051{,}05, baisser de 10 % à multiplier par 0,90{,}9. Le prix final est 80×1,05×0,9=80×0,945=75,680\times1{,}05\times0{,}9=80\times0{,}945=75{,}6 : une hausse de 5 % suivie d'une baisse de 10 % donne une baisse de 5,55{,}5 %, 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 cas

Les 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.

Algorithme avec une condition
Un test booléen dirige l'exécution vers une branche « vrai » ou une branche « faux », puis le programme reprend son cours.

Exemple 4 : position d’un point par rapport à une droite

Un point M(x ;y)M(x\,;y) est au-dessus de la droite d'équation y=2x−1y=2x-1 si son ordonnée dépasse 2x−12x-1.

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-dessous

Vérification à la main : pour x=1x=1, 2x−1=1<32x-1=1\lt3 ; pour x=2x=2, 2x−1=32x-1=3 ; pour x=4x=4, 2x−1=7>02x-1=7\gt0. 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 « a≤xa\le x et x≤bx\le b » est « x<ax\lt a ou x>bx\gt b » : 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
True

La fonction dans_intervalle renvoie un booléen qui traduit x∈[−1 ;5]x\in[-1\,;5]. La seconde fonction traduit la négation, x∉[−1 ;5]x\notin[-1\,;5], 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 aa, a+1a+1, …, b−1b-1 : la borne bb est exclue. range(n) donne 0, 1, …, n−1n-1, soit nn 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 :

385

La variable s, appelée accumulateur, part de 0 et reçoit un terme à chaque tour : après le tour kk, elle vaut 12+22+⋯+k21^2+2^2+\dots+k^2. Début du suivi : s=1s=1, puis 55, puis 1414, puis 3030. 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 6

Le tableau suggère que ff est décroissante puis croissante, avec un minimum −3-3 en x=2x=2, et que la courbe est symétrique autour de x=2x=2. Ce n'est qu'une observation sur des valeurs entières : on la confirme par le calcul, ici avec f(x)=(x−2)2−3f(x)=(x-2)^2-3.

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 1,51{,}5 et n augmente de 1 : la relation p =1,5n=1{,}5^n reste vraie avant et après chaque tour. La boucle s'arrête dès que 1,5n>1001{,}5^n\gt100. Comment vérifier : 1,511≈86,5≤1001{,}5^{11}\approx86{,}5\le100 et 1,512≈129,7>1001{,}5^{12}\approx129{,}7\gt100, donc n=12n=12 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 7

Pour 0<q<10\lt q\lt1, la fonction renvoie le premier entier nn tel que qn<sq^n\lt s. Contrôle : 0,820≈0,01150{,}8^{20}\approx0{,}0115 et 0,821≈0,00920{,}8^{21}\approx0{,}0092 ; 0,56=0,0156250{,}5^{6}=0{,}015625 et 0,57=0,00781250{,}5^7=0{,}0078125. Avec q≥1q\ge1 et s≤1s\le1, la condition resterait vraie pour toujours : il faut connaître les cas où un programme s'arrête.

SituationBoucle adaptée
Calculer une somme de 1 à 50, afficher 10 valeurs, simuler 1 000 lancersfor
Trouver le premier rang où une quantité dépasse un seuilwhile
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.0

Calcul à la main : g(−1)=2+3−5=0g(-1)=2+3-5=0 et g(2,5)=12,5−7,5−5=0g(2{,}5)=12{,}5-7{,}5-5=0. Les nombres −1-1 et 2,52{,}5 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.4142135623730951

La fonction applique AB=(xB−xA)2+(yB−yA)2AB=\sqrt{(x_B-x_A)^2+(y_B-y_A)^2} : pour A(1 ;2)A(1\,;2) et B(4 ;6)B(4\,;6), 9+16=5\sqrt{9+16}=5. Le second résultat est une valeur approchée de 2\sqrt2. 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
None

double(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 entre a et b, les deux bornes incluses ; randint(1, 6) simule un dé équilibré.
  • random() renvoie un flottant au hasard dans [0 ;1[[0\,;1\mathclose{[} ; la condition random() < p est vraie avec une probabilité pp.
  • 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 0

Chaque 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.1654

La fonction répète nn 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 16≈0,1667\frac16\approx0{,}1667. 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.61

Lecture de ecart_type : elle calcule d'abord la moyenne mm, puis accumule les carrés des écarts (x−m)2(x-m)^2, en fait la moyenne et prend la racine carrée. C'est exactement la définition de l'écart type, σ=1N∑(xi−m)2\sigma=\sqrt{\frac1N\sum(x_i-m)^2}. Contrôle à la main : m=605=12m=\frac{60}{5}=12, écarts au carré 1616, 11, 00, 11, 1616, de somme 34 ; σ=6,8≈2,61\sigma=\sqrt{6{,}8}\approx2{,}61.

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.50023

Ici, 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 1+2+3+4+5+66=3,5\frac{1+2+3+4+5+6}{6}=3{,}5 quand nn 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 x=2x=2, cette ligne donne 9 au lieu de 4×4+2−3=154\times4+2-3=15, 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 1+2+3+4=101+2+3+4=10.

Oublier de modifier la variable d’une boucle while

Programme faux, pour trouver le premier entier kk tel que 1+2+⋯+k1+2+\dots+k 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 k=10k=10, car 1+⋯+9=451+\dots+9=45 et 1+⋯+10=551+\dots+10=55. 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.