Algorithmique et programmation

Q: Quelle est la différence entre = et == en Python ?

Le signe = est l’affectation : x = 5 range la valeur 5 dans la variable x (en langage naturel x ← 5), et x = x + 1 augmente x de 1. Le double signe == compare deux valeurs : x == 5 vaut True ou False et sert dans les conditions d’un if ou d’un while.

Q: Pourquoi l’ordre des tests compte-t-il dans un if / elif / else ?

Python teste les conditions dans l’ordre et n’exécute que le bloc du premier test vrai. Si deux cas se recouvrent, par exemple « au moins 30 € » et « au moins 60 € », il faut tester le cas le plus restrictif en premier, sinon il n’est jamais atteint.

Q: Quand utiliser une boucle for plutôt qu’une boucle while ?

On utilise for quand le nombre de répétitions est connu avant de commencer : for k in range(1, 11) fait 10 tours. On utilise while quand ce nombre est justement ce que l’on cherche (« au bout de combien d’années… ») : la boucle tourne tant que sa condition est vraie, et un compteur donne le nombre de tours.

Q: Quelle est la différence entre print et return dans une fonction ?

print affiche une valeur à l’écran, return la renvoie au programme qui a appelé la fonction et termine la fonction. Une fonction sans return renvoie None : on ne peut pas réutiliser son résultat dans un calcul, comme f(4) + 1.

Q: Comment estimer une probabilité avec une simulation en Python ?

On écrit une fonction qui simule une expérience avec randint ou random, puis on la répète n fois dans une boucle for en comptant les succès. La fréquence (succès ÷ n) est une valeur approchée de la probabilité : elle fluctue d’une exécution à l’autre, et se rapproche de la probabilité lorsque n est grand.

Variables et types, affectation, instruction conditionnelle, boucles bornées (for) et non bornées (while), fonctions Python, fonction aléatoire et simulation.

À propos de cette page

Ce cours d’algorithmique de 2nde en Python suit six parties : variables, types (int, float, str, bool) et affectation x ← valeur ; instruction conditionnelle if / elif / else ; boucle bornée for avec range ; boucle non bornée while ; fonctions avec def et return ; fonctions aléatoires randint et random pour simuler une expérience. Chaque script du cours est suivi de son résultat ou de son explication.

Variables, types et affectation

Ce qu’il faut savoir

Variable et affectation. Une variable est un nom qui désigne une valeur rangée dans la mémoire. L’instruction x = 5 est une affectation : elle range la valeur $5$ dans la variable x. En langage naturel, on la note x ← 5. Python calcule d’abord le membre de droite, puis range le résultat dans la variable de gauche : l’ancienne valeur est perdue. Ce n’est pas une égalité mathématique : x = x + 1 signifie « x augmente de 1 ».

Séquence d’instructions. Les instructions s’exécutent une par une, de haut en bas, et chacune utilise les valeurs des variables à cet instant.

Les quatre types de variables. Chaque valeur a un type, qui décide de ce que l’on peut en faire.

Type	Nom Python	Exemples
entier	`int`	`7` · `-12` · `0`
flottant (nombre à virgule)	`float`	`2.5` · `7.0` · `0.001`
chaîne de caractères	`str`	`"bonjour"` · `"7"`
booléen	`bool`	`True` · `False`

Opérations. +, -, * (multiplication), / (division : le résultat est toujours un flottant), ** (puissance), // (quotient de la division euclidienne) et % (reste de cette division). Python écrit les nombres à virgule avec un point : 2.5 pour $2, 5$ .

Entrées et sorties. print(v) affiche la valeur de v. input("message") affiche le message et renvoie toujours une chaîne de caractères : pour obtenir un nombre, on la convertit avec int(...) ou float(...).

Exemples

Suivre deux affectations.

a = 5
a = a + 3
print(a)

La deuxième ligne calcule d’abord $5 + 3 = 8$ , puis range $8$ dans a : l’ancienne valeur $5$ est perdue. Le script affiche 8.

Types et divisions. 6 / 2 vaut 3.0 (un flottant), alors que 6 // 2 vaut 3 (un entier). 29 % 8 vaut 5, car $29 = 8 \times 3 + 5$ : le quotient est $3$ et le reste $5$ .

Écrire une formule qui combine des variables. Une élève a eu n1 au premier devoir (coefficient 2) et n2 au second (coefficient 3).

n1 = 12
n2 = 17
m = (2 * n1 + 3 * n2) / 5
print(m)

Le script calcule $(2 \times 12 + 3 \times 17) \div 5 = 75 \div 5 = 15$ et affiche 15.0 : la division / donne un flottant. Les parenthèses sont indispensables : sans elles, seul 3 * n2 serait divisé par $5$ .

Lire un nombre au clavier.

n = int(input("Un entier : "))
print(n * n)

Si l’on tape 9, int transforme la chaîne "9" en l’entier $9$ , et le script affiche 81.

Réflexe — Pour savoir ce que contient une variable, je dresse un tableau : une colonne par variable, une ligne par instruction. Je calcule toujours le membre de droite avec les valeurs de la ligne précédente, puis je range le résultat.

Attention — = range une valeur, == compare deux valeurs et vaut True ou False. La puissance s’écrit ** : en Python, ^ n’est pas la puissance. Et input renvoie une chaîne : comparer "17" < 18 provoque une erreur.

1 / 6

Instruction conditionnelle

Ce qu’il faut savoir

Si … alors … sinon. Le bloc placé sous if n’est exécuté que si la condition est vraie ; sinon, c’est le bloc placé sous else (qui est facultatif). Avec elif (« sinon si »), on ajoute des cas intermédiaires.

if condition_1:
    bloc_1
elif condition_2:
    bloc_2
else:
    bloc_3

Python teste les conditions dans l’ordre et exécute seulement le bloc du premier test vrai ; les tests suivants ne sont pas examinés.

Syntaxe. La ligne du test se termine par deux-points :, et le bloc est décalé de quatre espaces : cette indentation fait partie du langage, c’est elle qui délimite le bloc.

Conditions. Une condition est une expression booléenne : elle vaut True ou False. Comparateurs : == (égal), != (différent), <, <=, >, >=. On combine des conditions avec and (les deux sont vraies), or (au moins une est vraie) et not (le contraire). Python accepte aussi l’écriture enchaînée 10 <= n <= 50, qui signifie 10 <= n and n <= 50.

Exemples

Pair ou impair.

n = 23
if n % 2 == 0:
    print("n est pair")
else:
    print("n est impair")

$23 = 2 \times 11 + 1$ , donc n % 2 vaut $1$ : le test n % 2 == 0 est faux et le script exécute le bloc du else. Il affiche n est impair.

Trois cas avec elif.

def categorie(t):
    if t < 0:
        return "gel"
    elif t < 15:
        return "frais"
    else:
        return "doux"

print(categorie(11))

Pour $t = 11$ : le premier test, $11 < 0$ , est faux ; le second, $11 < 15$ , est vrai : la fonction renvoie frais et s’arrête. Le else n’est pas atteint. Inutile d’écrire t >= 0 and t < 15 : si l’on arrive au elif, c’est que le premier test était faux.

Combiner deux conditions. Pour x = 7 : x > 2 and x < 5 vaut False (la seconde condition est fausse), alors que x < 0 or x > 5 vaut True (la seconde suffit).

Réflexe — Quand les cas se recouvrent, je place le test le plus restrictif en premier. Puis je teste le programme sur une valeur de chaque cas et sur les valeurs frontières, pour choisir entre < et <=.

Attention — L’ordre des tests compte. Si l’on testait t < 15 avant t < 0, une température de $- 4$ °C serait classée « frais » : le premier test vrai est le seul exécuté. Et if x = 3: est une erreur de syntaxe : le test d’égalité s’écrit x == 3.

2 / 6

Boucle bornée : for

Ce qu’il faut savoir

On utilise une boucle bornée quand le nombre de répétitions est connu avant de commencer. for k in range(a, b): exécute le bloc indenté pour k $= a$ , $a + 1$ , …, $b - 1$ : la borne de droite est exclue, et la boucle fait $b - a$ tours.

Écriture	Valeurs de k	Tours
`range(4)`	0 · 1 · 2 · 3	4
`range(2, 7)`	2 · 3 · 4 · 5 · 6	5
`range(1, 10, 3)`	1 · 4 · 7	3
`range(9, 4, -1)`	9 · 8 · 7 · 6 · 5	5

range(n) commence à $0$ ; le troisième nombre, s’il est écrit, est le pas.

Accumulateur et compteur. Pour calculer une somme, on crée une variable égale à $0$ avant la boucle et on lui ajoute un terme à chaque tour ; pour un produit, on part de $1$ . Un compteur part de $0$ et augmente de $1$ chaque fois qu’un événement se produit.

Exemples

Une somme.

S = 0
for k in range(1, 6):
    S = S + k ** 2
print(S)

k prend les valeurs $1$ à $5$ , et S reçoit à chaque tour le carré de k : $S = 1 + 4 + 9 + 16 + 25 = 55$ .

Une trace d’exécution.

u = 20
for k in range(3):
    u = u - 4
print(u)

Tour	k	u
avant	—	20
1	0	16
2	1	12
3	2	8

La boucle fait 3 tours ( $k$ vaut 0, 1 puis 2) : le script affiche 8.

Un compteur. Combien de carrés $k^{2}$ , pour $k$ de $1$ à $30$ , se terminent par le chiffre 1 ?

c = 0
for k in range(1, 31):
    if k * k % 10 == 1:
        c = c + 1
print(c)

k * k % 10 est le reste de $k^{2}$ dans la division par 10, c’est-à-dire son chiffre des unités. Il vaut 1 lorsque $k$ se termine par 1 ou par 9 : $k$ = 1, 9, 11, 19, 21, 29. Le script affiche 6.

Réflexe — Avant d’écrire la boucle, je compte ses tours : range(a, b) en fait $b - a$ . Pour aller de 1 à $n$ inclus, j’écris range(1, n + 1).

Attention — Un print indenté sous le for s’exécute à chaque tour ; aligné sur le for, il ne s’exécute qu’une fois, après la boucle. Et une somme initialisée dans la boucle est remise à zéro à chaque tour.

3 / 6

Boucle non bornée : while

Ce qu’il faut savoir

while condition: répète le bloc indenté tant que la condition est vraie. On l’utilise quand on ne connaît pas le nombre de tours à l’avance : c’est l’outil des questions « au bout de combien… ». Un compteur indique alors le nombre de tours effectués. À la sortie de la boucle, la condition est fausse.

Écrire la condition. On écrit la condition pour continuer, c’est-à-dire le contraire de la condition d’arrêt : pour s’arrêter dès que b < 400, on écrit while b >= 400:.

Arrêt de la boucle. Le bloc doit modifier une variable de la condition et la rapprocher de la sortie. Sinon la condition reste vraie pour toujours et le programme ne s’arrête jamais : c’est une boucle infinie.

Exemples

Une population qui diminue. Une culture de 1 200 bactéries perd 15 % de son effectif chaque heure. Au bout de combien d’heures passe-t-elle sous 400 bactéries ?

b = 1200
h = 0
while b >= 400:
    b = b * 0.85
    h = h + 1
print(h)

Perdre 15 % revient à multiplier par $0, 85$ . On continue tant que $b ⩾ 400$ . Après 6 heures, $b = 1 200 \times 0, 85^{6} \approx 452, 6$ , encore au-dessus de 400 ; après 7 heures, $b \approx 384, 7$ , sous le seuil. Le script affiche 7.

Compter les chiffres d’un entier. Ici, aucun seuil : on divise par 10 tant qu’il reste des chiffres.

n = 40518
c = 0
while n > 0:
    n = n // 10
    c = c + 1
print(c)

n // 10 efface le chiffre des unités : n vaut successivement 4 051, 405, 40, 4 puis 0. La condition n > 0 devient fausse après 5 tours : le script affiche 5, le nombre de chiffres de 40 518.

Réflexe — J’écris d’abord la condition d’arrêt en français, puis je prends son contraire pour le while (< devient >=, > devient <=). Je vérifie enfin que le bloc fait évoluer la variable testée.

Attention — Un test != dans un while peut ne jamais devenir faux. Les flottants sont codés de façon approchée : 0.1 + 0.2 == 0.3 vaut False, et une variable qui part de 0 et augmente de 0.1 ne vaut jamais exactement 1. On teste donc une inégalité : while x < 1:.

4 / 6

Fonctions

Ce qu’il faut savoir

Définir une fonction. def nom(paramètres): ouvre la définition ; le bloc indenté qui suit est le corps de la fonction ; return renvoie une valeur et termine immédiatement la fonction. Tant qu’on ne l’appelle pas, une fonction ne fait rien.

Appeler une fonction. On écrit nom(arguments) : chaque paramètre prend la valeur de l’argument placé au même rang. L’appel vaut la valeur renvoyée : on peut l’afficher, la ranger dans une variable ou la réutiliser dans un calcul. Une fonction peut avoir un, plusieurs ou aucun paramètre, et peut en appeler une autre.

Fonction Python, fonction mathématique. La fonction $f : x \mapsto 3 x^{2} - 1$ s’écrit

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

print(f(2))

et l’appel f(2) renvoie $11$ , comme $f (2) = 3 \times 4 - 1 = 11$ .

print ou return. print affiche, return renvoie. Une fonction sans return renvoie la valeur spéciale None, inutilisable dans un calcul.

Exemples

Un paramètre.

from math import pi

def aire_disque(r):
    return pi * r ** 2

print(aire_disque(3))

r est le paramètre : il prend la valeur 3 lors de l’appel. aire_disque(3) renvoie $π \times 3^{2} = 9 π \approx 28, 27$ .

Deux paramètres : l’ordre compte. L’indice de masse corporelle vaut la masse (en kg) divisée par le carré de la taille (en m).

def imc(m, h):
    return m / (h * h)

print(imc(68, 1.75))

imc(68, 1.75) donne m = 68 et h = 1.75 : $68 \div 1, 75^{2} = 68 \div 3, 0625 \approx 22, 2$ . L’appel imc(1.75, 68) ferait le calcul à l’envers et n’aurait aucun sens.

Une fonction qui en appelle une autre.

def carre(x):
    return x * x

def somme_carres(a, b):
    return carre(a) + carre(b)

print(somme_carres(3, 4))

somme_carres(3, 4) renvoie carre(3) + carre(4), soit $9 + 16 = 25$ .

Réflexe — Ce qui change d’un calcul à l’autre devient un paramètre. Je termine par return, puis je teste la fonction sur une valeur que je sais calculer de tête.

Attention — Une fonction qui se termine par print(x * x) au lieu de return x * x affiche le résultat mais renvoie None : l’instruction y = carre(5) + 1 provoque alors une erreur. Et les arguments se donnent dans l’ordre des paramètres.

5 / 6

Fonction aléatoire et simulation

Ce qu’il faut savoir

Le module random. On écrit from random import randint, random.

randint(a, b) renvoie un entier au hasard entre a et b, les deux bornes comprises, chaque entier ayant la même probabilité. random() renvoie un flottant au hasard dans l’intervalle $[0; 1 [$ . Le test random() < p est vrai avec la probabilité $p$ : il simule un événement de probabilité $p$ .

Simuler. On écrit une fonction qui simule une expérience et renvoie son résultat. Une seconde fonction l’appelle $n$ fois dans une boucle for : avec un compteur, elle renvoie la fréquence (nombre de succès divisé par $n$ ) ; en additionnant les résultats, elle renvoie la moyenne de la série statistique obtenue.

Fréquence et probabilité. La fréquence observée change d’une exécution à l’autre : elle fluctue. Lorsque $n$ est grand, sauf exception, elle est proche de la probabilité.

Exemples

Fréquence du six.

from random import randint

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

def frequence_six(n):
    c = 0
    for i in range(n):
        if lancer() == 6:
            c = c + 1
    return c / n

c compte les six. frequence_six(1000) renvoie une valeur proche de $\frac{1}{6} \approx 0, 167$ , mais différente à chaque appel : par exemple $0, 171$ , puis $0, 158$ . Ces écarts sont normaux : ils n’indiquent pas un dé truqué.

Moyenne d’une série obtenue par simulation. On lance un dé : on gagne le numéro obtenu s’il est pair, rien sinon.

def gain():
    d = randint(1, 6)
    if d % 2 == 0:
        return d
    return 0

def moyenne(n):
    s = 0
    for i in range(n):
        s = s + gain()
    return s / n

s additionne les $n$ gains, et s / n est leur moyenne. Sur six lancers où chaque face sortirait une fois, on gagnerait $2 + 4 + 6 = 12$ , soit 2 par partie : pour $n$ grand, moyenne(n) renvoie une valeur proche de 2.

Réflexe — Je sépare deux fonctions : l’une simule une expérience, l’autre la répète $n$ fois dans une boucle for avec un compteur (ou un accumulateur), puis renvoie le total divisé par $n$ .

Attention — randint(1, 6) peut renvoyer 6 (borne incluse), alors que range(1, 6) s’arrête à 5 (borne exclue). Et une simulation ne donne jamais la probabilité exacte : elle en donne une valeur approchée qui fluctue.

6 / 6

Pour aller plus loin

Algorithmes vus dans les autres chapitres. Les boucles et les fonctions de ce chapitre servent partout dans l’année. L’encadrement de $\sqrt{2}$ par balayage est dans Ensembles de nombres, intervalles et valeur absolue ; tester si un entier est multiple d’un autre et trouver le plus grand multiple inférieur à un entier, dans Arithmétique ; la première puissance qui dépasse une valeur, dans Puissances et notation scientifique ; l’approximation d’un maximum par balayage ou par dichotomie, dans Variations et extrémums.

Simulation et loi des grands nombres. La stabilisation des fréquences observées sur de grandes simulations est étudiée dans Loi des grands nombres et simulation ; la moyenne et l’écart type d’une série, dans Statistiques descriptives.

Les listes (approfondissement). Aucune connaissance sur les listes n’est exigée en 2nde. On en rencontre pourtant : L = [4, 9, 2] range trois valeurs, et for x in L: les parcourt une à une. Les filtres sur des fichiers de données (ET, OU, NON) sont dans Croisement de deux variables qualitatives.

À retenir

Affectation x ← valeur (en Python x = valeur) : le membre de droite est calculé d’abord ; types int, float, str, bool ; // donne le quotient et % le reste.
if / elif / else : seul le bloc du premier test vrai est exécuté ; = affecte, == compare ; and, or, not combinent des conditions.
for k in range(a, b) : k va de a à b − 1, soit b − a tours ; somme initialisée à 0, produit à 1, avant la boucle.
while condition : on répète tant que la condition est vraie ; elle s’écrit comme le contraire de l’arrêt ; le bloc doit faire évoluer la variable testée.
def nom(paramètres) puis return valeur : return renvoie et termine la fonction ; print affiche seulement.
randint(a, b) : entier de a à b bornes comprises ; random() : flottant de [0 ; 1[ ; la fréquence simulée fluctue autour de la probabilité.

Questions fréquentes

Quelle est la différence entre = et == en Python ?

Le signe = est l’affectation : x = 5 range la valeur 5 dans la variable x (en langage naturel x ← 5), et x = x + 1 augmente x de 1. Le double signe == compare deux valeurs : x == 5 vaut True ou False et sert dans les conditions d’un if ou d’un while.

Pourquoi l’ordre des tests compte-t-il dans un if / elif / else ?

Python teste les conditions dans l’ordre et n’exécute que le bloc du premier test vrai. Si deux cas se recouvrent, par exemple « au moins 30 € » et « au moins 60 € », il faut tester le cas le plus restrictif en premier, sinon il n’est jamais atteint.

Quand utiliser une boucle for plutôt qu’une boucle while ?

On utilise for quand le nombre de répétitions est connu avant de commencer : for k in range(1, 11) fait 10 tours. On utilise while quand ce nombre est justement ce que l’on cherche (« au bout de combien d’années… ») : la boucle tourne tant que sa condition est vraie, et un compteur donne le nombre de tours.

Quelle est la différence entre print et return dans une fonction ?

print affiche une valeur à l’écran, return la renvoie au programme qui a appelé la fonction et termine la fonction. Une fonction sans return renvoie None : on ne peut pas réutiliser son résultat dans un calcul, comme f(4) + 1.

Comment estimer une probabilité avec une simulation en Python ?

On écrit une fonction qui simule une expérience avec randint ou random, puis on la répète n fois dans une boucle for en comptant les succès. La fréquence (succès ÷ n) est une valeur approchée de la probabilité : elle fluctue d’une exécution à l’autre, et se rapproche de la probabilité lorsque n est grand.

Bloqué sur ce chapitre ?

Moi c'est Ben, j'ai créé ce site pour aider le plus d'élèves possible, partout en France. Je peux aussi reprendre avec toi ce qui coince en cours particulier : en visio, ou à domicile si tu es à Marseille.

Réserver un 1^er cours → Voir les tarifs

Prof de maths à Marseille · Cours particuliers au lycée · Aide aux devoirs