Algorithmique et programmation en Python

Ce que tu sais déjà. Tu as écrit tes premiers programmes Python (4e — Découvrir Python) et utilisé des boucles et des fonctions (3e — Boucles et fonctions en Python). En Seconde, on fait le point sur les types, et on s’entraîne à lire, écrire et faire tourner à la main des programmes utiles en mathématiques. Tu en as déjà croisé plusieurs dans l’année (balayage, seuil…).

1. Variables, types et affectation

Une variable est un nom qui désigne une valeur stockée en mémoire. L’affectation x = 5 donne la valeur $5$ à la variable x. Le signe = n’est pas une égalité mathématique : x = x + 1 signifie « la nouvelle valeur de x est l’ancienne valeur plus $1$ ».

Les quatre types à connaître.

La fonction type donne le type d’une valeur : type(7 / 2) renvoie float.

Opérations utiles. 7 / 2 vaut 3.5 (division décimale) ; 7 // 2 vaut 3 (quotient entier) ; 7 % 2 vaut 1 (reste de la division euclidienne) ; 2 ** 10 vaut 1024 (puissance).

Exemple (faire tourner à la main).

a = 5
b = a * 2
a = a + b

Après la ligne 2, a vaut $5$ et b vaut $10$. Après la ligne 3, a vaut $15$ et b vaut toujours $10$.

Attention aux flottants. Les nombres à virgule sont stockés en binaire, parfois de façon approchée : 0.1 + 0.2 s’affiche 0.30000000000000004, et 0.1 + 0.2 == 0.3 vaut False. Pour comparer deux flottants, on teste plutôt si leur écart est très petit.

→ S’entraîner : Exercice 1

2. Instructions conditionnelles

Une condition est une expression qui vaut True ou False (un booléen). On les construit avec les comparaisons == (égal), != (différent), <, <=, >, >=, et on les combine avec and, or, not.

def mention(note):
    if note >= 16:
        return "Très bien"
    elif note >= 14:
        return "Bien"
    elif note >= 12:
        return "Assez bien"
    elif note >= 10:
        return "Passable"
    else:
        return "Insuffisant"

Python teste les conditions dans l’ordre et exécute seulement le premier bloc dont la condition est vraie : mention(14) renvoie "Bien" (et pas "Assez bien", bien que $14 \geqslant 12$).

L’indentation compte. Les instructions d’un bloc sont décalées de quatre espaces : c’est ainsi que Python sait ce qui dépend du if.

Ne pas confondre = (affectation) et == (test d’égalité).

→ S’entraîner : Exercice 2 · Exercice 3

3. Boucles bornées

On utilise une boucle bornée for quand on connaît à l’avance le nombre de répétitions.

• range(n) parcourt $0, 1, \ldots, n - 1$ ($n$ valeurs) ;
• range(a, b) parcourt $a, a + 1, \ldots, b - 1$ (la borne $b$ est exclue) ;
• range(a, b, pas) avance de pas en pas.

Exemple (somme des entiers de 1 à 100).

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

À la fin, s vaut $5\,050$. La variable s est un accumulateur : on l’initialise avant la boucle, puis on lui ajoute un terme à chaque tour.

Exemple (tableau de valeurs). Pour $f(x) = x^2 - 3x$ :

def f(x):
    return x**2 - 3*x

for x in range(-2, 4):
    print(x, f(x))

On obtient les couples $(-2\,;\,10)$, $(-1\,;\,4)$, $(0\,;\,0)$, $(1\,;\,-2)$, $(2\,;\,-2)$, $(3\,;\,0)$.

→ S’entraîner : Exercice 4 · Exercice 5

4. Boucles non bornées

On utilise une boucle non bornée while (« tant que ») quand on ne sait pas à l’avance combien de tours seront nécessaires : on répète tant qu’une condition est vraie.

n = 0
p = 1
while p <= 1000:
    p = p * 2
    n = n + 1

À la sortie, n vaut $10$ et p vaut $1\,024$ : $2^{10}$ est la première puissance de $2$ qui dépasse $1\,000$. C’est un algorithme de seuil, comme dans les chapitres Puissances et Pourcentages.

Deux points de vigilance.

• Il faut que la condition finisse par devenir fausse, sinon la boucle ne s’arrête jamais (boucle infinie).
• Condition d’arrêt et condition de répétition sont contraires : pour s’arrêter quand p > 1000, on écrit while p <= 1000.

→ S’entraîner : Exercice 6 · Exercice 7

5. Fonctions

Une fonction regroupe des instructions sous un nom. Elle reçoit des arguments et renvoie un résultat avec return.

def est_bissextile(annee):
    return (annee % 4 == 0 and annee % 100 != 0) or annee % 400 == 0

est_bissextile(2024) renvoie True, est_bissextile(1900) renvoie False, est_bissextile(2000) renvoie True. Cette fonction renvoie un booléen.

Plusieurs arguments. Une fonction peut en recevoir plusieurs :

def seuil(valeur, taux, cible):
    n = 0
    while valeur < cible:
        valeur = valeur * (1 + taux)
        n = n + 1
    return n

return n’est pas print. print affiche une valeur à l’écran ; return renvoie une valeur qu’on peut réutiliser dans un calcul (2 * f(3), if est_bissextile(a):…). Dès qu’un return est exécuté, la fonction s’arrête.

→ S’entraîner : Exercice 8

6. Fonctions et hasard

Le module random fournit des nombres pseudo-aléatoires :

• randint(a, b) renvoie un entier au hasard entre $a$ et $b$ (inclus) ;
• random() renvoie un flottant au hasard dans $[0\,;\,1[$.

from random import randint

def de():
    return randint(1, 6)

def frequence_six(N):
    compteur = 0
    for i in range(N):
        if de() == 6:
            compteur = compteur + 1
    return compteur / N

frequence_six(10000) renvoie une valeur proche de $\dfrac16 \approx 0{,}167$ (par exemple $0{,}1627$), différente à chaque exécution. Plus $N$ est grand, plus la fréquence obtenue est en général proche de la probabilité (voir le chapitre Probabilités).

Exemple. Une fonction qui simule une pièce équilibrée :

from random import random

def piece():
    if random() < 0.5:
        return "pile"
    else:
        return "face"

→ S’entraîner : Exercice 9

À retenir.

• Quatre types : int, float, bool, str ; x = x + 1 est une affectation, pas une équation.
• if / elif / else : seul le premier bloc vrai est exécuté ; l’indentation délimite les blocs.
• for quand on connaît le nombre de tours (range(a, b) exclut b) ; while pour un seuil.
• Une fonction renvoie son résultat avec return.
• randint(a, b) inclut les deux bornes ; random() est dans $[0\,;\,1[$.