Cours

Comprendre, pas à pas

Un algorithme, c'est une suite d'instructions précises qui résout un problème. Dans ce cours, vous apprenez à les lire, à les compléter, à les écrire, puis à les faire tourner en Python.

Chapitre 1 — Écrire un algorithme

Inès travaille au service informatique d'un lycée. Chaque matin, elle compte les postes en panne et calcule le pourcentage de postes qui marchent. Elle le fait à la main, sur une feuille.

Elle se trompe parfois. Son responsable lui demande d'écrire un petit programme qui fait le calcul à sa place.

À la fin de ce chapitre, vous saurez écrire ce programme en pseudo-code et en Python, et vérifier qu'il est juste.

1.1 Du problème au programme

Une recette marche parce que chaque étape est claire et vient au bon moment. Comment écrire des étapes aussi claires pour un ordinateur ?

Un ALGORITHME est une suite d'instructions qui résout un problème, en un nombre fini d'étapes. L'ordinateur les exécute dans l'ordre, de haut en bas : c'est l'EXÉCUTION SÉQUENTIELLE.

Un ordinateur ne devine rien. Il fait exactement ce qu'on écrit, ni plus, ni moins. Si une étape manque, il ne la rajoute pas.

On écrit un algorithme dans deux langages :

1. Le PSEUDO-CODE : des mots français, simples et précis. C'est la forme des sujets du BTS. Il ne tourne sur aucune machine.
2. Le Python : un vrai langage de programmation. Il tourne sur l'ordinateur : on peut tester.

Voici le calcul d'Inès. Le lycée a 120 postes, 9 sont en panne.

total ← 120
pannes ← 9
marche ← total - pannes
pourcentage ← marche / total * 100
Écrire "Postes qui marchent :", pourcentage, "%"

total = 120
pannes = 9
marche = total - pannes
pourcentage = marche / total * 100
print("Postes qui marchent :", pourcentage, "%")

Postes qui marchent : 92.5 %

Les deux colonnes disent la même chose, ligne pour ligne. Dans la version écran de ce cours, le bouton « Exécuter » lance le Python.

Un algorithme complet commence par un en-tête : son nom, son rôle, ce qu'il reçoit, ce qu'il produit. On l'écrit en commentaire, après // en pseudo-code et après # en Python.

// Nom : taux_de_marche
// Rôle : calculer le pourcentage de postes qui marchent
// Entrées : total et pannes, deux entiers
// Sortie : le pourcentage affiché à l'écran

1.2 Les variables et l'affectation

Inès a rangé des nombres dans total, pannes, marche. Mais que sont ces noms, et que fait exactement la flèche ← ?

Une VARIABLE est une case de la mémoire, avec un nom, qui contient une valeur. L'AFFECTATION range une valeur dans une variable.

En pseudo-code, on l'écrit avec la flèche ←. En Python, avec le signe =.

Pensez à une boîte avec une étiquette. L'étiquette, c'est le nom.

Le contenu, c'est la valeur. On peut vider la boîte et mettre autre chose dedans : l'ancienne valeur disparaît.

Comment ça marche :

1. L'ordinateur calcule d'abord tout ce qui est à droite de la flèche.
2. Il range le résultat dans la variable de gauche.
3. L'ancienne valeur de la variable est perdue.

Parfois, la nouvelle valeur dépend de l'ancienne : compteur ← compteur + 1. On prend la valeur actuelle, on ajoute 1, on range le résultat au même endroit.

C'est une MISE À JOUR. Le programme officiel du BTS l'appelle « affectation récursive » : retenez simplement « mise à jour ».

compteur ← 0
compteur ← compteur + 1
compteur ← compteur + 1
Écrire compteur

compteur = 0
compteur = compteur + 1
compteur = compteur + 1
print(compteur)

2

En maths, x = x + 1 est impossible. En informatique, c'est une instruction : « prends x, ajoute 1, range dans x ». En Python, on peut aussi écrire compteur += 1, et compteur -= 1 pour enlever 1.

1.3 Lire et écrire

Le programme d'Inès marche, mais les nombres 120 et 9 sont écrits dans le code. Demain, il y aura peut-être 12 pannes. Comment laisser Inès taper le nombre elle-même ?

LIRE, c'est demander une valeur à l'utilisateur, au clavier, et la ranger dans une variable. ÉCRIRE, c'est afficher un message ou une valeur à l'écran.

Un programme qui ne lit rien fait toujours le même calcul. Un programme qui lit devient un outil : on le lance, on tape les valeurs du jour, il répond.

Écrire "Nombre de pannes ?"
Lire pannes
marche ← 120 - pannes
Écrire "Postes qui marchent :", marche

pannes = int(input("Nombre de pannes ? "))
marche = 120 - pannes
print("Postes qui marchent :", marche)

Nombre de pannes ? 12
Postes qui marchent : 108

Dans print, la virgule sépare les morceaux et ajoute un espace entre eux. Pour aller à la ligne, on fait un autre print. Le programme officiel du BTS limite la mise en forme à ça : des séparateurs et des retours à la ligne.

1.4 La trace d'un algorithme

Inès veut vérifier un algorithme écrit par un collègue, sans ordinateur. Comment savoir ce qu'il fait, ligne par ligne ?

La TRACE est un tableau qui montre la valeur de chaque variable après chaque instruction. On le remplit à la main, ligne par ligne, comme si on était l'ordinateur.

C'est la question la plus fréquente à l'examen : « Que renvoie l'algorithme pour… ? Justifier. »

La trace est la justification. Elle prouve que vous avez suivi le chemin, pas deviné le résultat.

Comment ça marche :

1. On fait une colonne par variable, plus une colonne pour l'étape.
2. On lit l'algorithme ligne par ligne, dans l'ordre.
3. À chaque affectation, on écrit la nouvelle valeur dans la colonne de la variable.
4. Une variable qui n'existe pas encore vaut –.

x ← 4
y ← x + 3
x ← x * y
y ← y - x

En Python, on vérifie une trace en ajoutant des print :

x = 4
y = x + 3
x = x * y
y = y - x
print("x =", x, "y =", y)

x = 28 y = -21

Ce qu'on retient du chapitre 1

Inès a maintenant son programme. Elle tape le nombre de pannes, il affiche le résultat. Et quand un collègue lui envoie un algorithme, elle sait le vérifier sur papier, avec une trace.

Chapitre 2 — Les types de données

Yanis développe la fiche d'inscription d'une salle de sport. Il range l'âge du client, son poids, son nom, et s'il a payé ou non. Un jour, la fiche affiche un poids de 72,30000000000001 kg.

Un autre jour, l'âge « 25 » plus 1 donne « 251 ». Yanis ne comprend pas.

À la fin de ce chapitre, vous saurez choisir le bon type pour chaque donnée, et vous saurez expliquer ces deux bugs.

2.1 Les types simples

Une variable contient une valeur. Mais une valeur peut être un âge, un prix, une réponse oui ou non. L'ordinateur les range-t-il de la même façon ?

Le TYPE d'une variable dit quelle sorte de valeur elle contient, et donc ce qu'on peut faire avec. Les quatre types simples du programme sont l'entier naturel, l'entier relatif, le réel et le booléen.

Le type, c'est comme le rayon d'un magasin. On ne range pas le lait avec les tournevis. Chaque rayon a ses règles : le lait va au frais, les tournevis non.

En Python, un réel s'écrit avec un point : 12.67, jamais 12,67. La division / donne toujours un réel, même quand elle tombe juste : 8 / 2 vaut 4.0. La fonction type donne le type d'une valeur.

print(type(57), type(-7), type(73.4), type(True))
print(8 / 2, type(8 / 2))

<class 'int'> <class 'int'> <class 'float'> <class 'bool'>
4.0 <class 'float'>

Python n'a pas de type « entier naturel » à part : un entier positif est un int comme les autres. C'est à vous de vérifier qu'il reste positif.

2.2 Les limites de la machine

En maths, les nombres n'ont pas de fin. On peut toujours ajouter 1. Est-ce vrai dans un ordinateur ?

Le DOMAINE DE VALEURS d'un type est l'ensemble des valeurs qu'il peut contenir. En maths, il est infini.

Dans une machine, il est limité, parce que chaque valeur est rangée sur un nombre fixe de bits. Un BIT est un chiffre binaire : 0 ou 1.

Pensez au compteur kilométrique d'une vieille voiture, à 6 chiffres. Après 999 999 km, il repasse à 000 000. Le compteur n'a pas de place pour un 7ᵉ chiffre.

Comment ça marche :

1. Avec n bits, on peut écrire valeurs différentes. On lit « 2 puissance n ».
2. Un entier naturel sur n bits va donc de 0 à . Sur 8 bits : de 0 à 255.
3. Un entier relatif sur n bits partage ces valeurs entre négatifs et positifs : il va de à . Sur 16 bits : de -32 768 à 32 767.
4. Si un calcul sort du domaine, c'est un DÉPASSEMENT DE CAPACITÉ. Le résultat devient faux.

Les entiers sont exacts tant qu'ils restent dans leur domaine : 42 est rangé exactement. Python agrandit seul la place d'un int : il ne déborde jamais. Mais d'autres langages, comme le C, débordent.

Les réels, eux, sont presque toujours approchés. La machine les écrit en binaire. Or beaucoup de nombres simples, comme 0,1, n'ont pas d'écriture binaire finie.

C'est comme 1/3 en décimal : 0,3333… ne s'arrête jamais.

La machine coupe quelque part. Il reste une petite erreur.

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(round(0.1 + 0.2, 2))

0.30000000000000004
False
0.3

C'est le bug de Yanis : son poids de 72,3 est rangé à peu près. Pour afficher un réel, on l'arrondit. Pour comparer deux réels, on ne teste jamais l'égalité exacte.

2.3 Les chaînes de caractères

Le nom du client, son adresse mail, son mot de passe ne sont pas des nombres. Comment l'ordinateur range-t-il du texte ?

Une CHAÎNE DE CARACTÈRES est une suite de caractères : lettres, chiffres, espaces, ponctuation. On l'écrit entre guillemets : "Yanis", "192.168.1.10". En Python, son type est str, pour string en anglais.

Une chaîne est un texte, d'un seul bloc. On ne la modifie pas case par case. On lit ses caractères et on lui applique des fonctions, qui en donnent une information ou en extraient un morceau. C'est comme une phrase écrite au stylo : on peut la lire, la recopier, en citer un mot, mais pas gommer une lettre.

Comment ça marche :

1. longueur(chaine) donne le nombre de caractères. En Python : len(chaine).
2. Chaque caractère a une position, appelée INDICE. Le premier caractère a l'indice 0.
3. chaine[i] extrait le caractère d'indice i : c'est un petit morceau de la chaîne, de longueur 1. Les sujets du BTS l'écrivent ainsi : code[i], chaine[k].
4. Le dernier caractère a donc l'indice longueur(chaine) - 1.

mot ← "BTSSIO"
Écrire longueur(mot)
Écrire mot[0]
Écrire mot[5]

mot = "BTSSIO"
print(len(mot))
print(mot[0])
print(mot[5])

6
B
O

On lit un caractère, mais on ne le modifie pas. Écrire mot[0] ← "X" est impossible : Python s'arrête sur une erreur TypeError.

Pour changer un texte, on range une nouvelle chaîne dans la variable. Une chaîne n'est pas un tableau.

mot = "BTSSIO"
mot[0] = "X"

TypeError: 'str' object does not support item assignment

Attention : "123" et 123 ne sont pas la même chose. Le premier est une chaîne de trois caractères.

Le second est un nombre. On ne calcule pas sur une chaîne.

Dans la machine, chaque caractère est rangé sous forme d'un nombre. Le code ASCII, pour American Standard Code for Information Interchange, donne par exemple 65 pour A et 97 pour a. Vous n'avez pas à connaître ces codes : retenez seulement qu'une chaîne est rangée caractère par caractère.

2.4 Changer de type : le transtypage

Revenons au second bug de Yanis : « 25 » plus 1 donne « 251 ». D'où vient ce résultat ?

Le TRANSTYPAGE consiste à changer le type d'une valeur : d'un texte vers un nombre, d'un nombre vers un texte. On l'appelle aussi conversion.

C'est indispensable, car les données arrivent souvent en texte : ce qu'on tape au clavier, une ligne d'un fichier, un formulaire web. Pour calculer, il faut d'abord les changer en nombres.

Voici le bug de Yanis, puis sa correction :

age = "25"
print(age + "1")
print(int(age) + 1)
print("Âge : " + str(int(age) + 1))

251
26
Âge : 26

Avec deux chaînes, le + les colle : c'est la concaténation, au chapitre 3. Avec deux nombres, il les additionne. Le même signe fait deux choses selon le type.

Ce qu'on retient du chapitre 2

Yanis a corrigé sa fiche. Il convertit l'âge en entier avant d'ajouter 1.

Il arrondit le poids à une décimale avant de l'afficher. Et le numéro de téléphone reste une chaîne.

Chapitre 3 — Les opérateurs

Léa est stagiaire chez un hébergeur de sites web. On lui confie trois petits outils à écrire. Le premier convertit une durée en secondes en heures, minutes et secondes.

Le deuxième dit si un mot de passe est accepté. Le troisième lit les droits d'accès d'un fichier, codés sur quelques bits.

À la fin de ce chapitre, vous saurez écrire les calculs, les conditions et les manipulations de texte dont Léa a besoin.

3.1 Les opérateurs numériques

Pour calculer, un algorithme utilise des opérateurs : des signes qui combinent des valeurs. Lesquels a-t-on, et comment les écrit-on ?

Un OPÉRATEUR NUMÉRIQUE prend des nombres et donne un nombre. En plus des quatre opérations, l'informatique utilise beaucoup deux opérateurs : le quotient entier et le reste de la division euclidienne.

La division euclidienne, c'est le partage avec un reste. On partage 17 bonbons entre 5 enfants : chacun en a 3, et il en reste 2. Le quotient est 3, le reste est 2.

Le reste sert partout. Un nombre n est pair si n mod 2 = 0. Il est divisible par 7 si n mod 7 = 0.

Voici l'outil de Léa, qui convertit une durée :

duree ← 7384
heures ← duree div 3600
reste ← duree mod 3600
minutes ← reste div 60
secondes ← reste mod 60
Écrire heures, "h", minutes, "min", secondes, "s"

duree = 7384
heures = duree // 3600
reste = duree % 3600
minutes = reste // 60
secondes = reste % 60
print(heures, "h", minutes, "min", secondes, "s")

2 h 3 min 4 s

Écrire une formule en ligne. Une formule de maths s'écrit sur une ligne dans un programme. Les fractions et les puissances deviennent des opérateurs, et les parenthèses gardent l'ordre des calculs.

Comme en maths, * et / passent avant + et -. La puissance passe avant tout.

3.2 Les fonctions mathématiques usuelles

Certains calculs reviennent tout le temps : arrondir un prix, prendre une racine, tirer un nombre au hasard. Faut-il les écrire à chaque fois ?

Une FONCTION USUELLE est un calcul tout prêt, fourni par le langage. On l'appelle par son nom, avec la valeur entre parenthèses : abs(-7) donne 7.

C'est comme la touche « racine » de la calculatrice. Vous ne refaites pas le calcul à la main : vous appuyez sur la touche.

En Python, floor, ceil et sqrt sont dans le module math, et randint et uniform dans le module random. On écrit import math ou import random en haut du programme.

import math
print(round(3.678, 2), math.floor(3.7), math.ceil(3.2), math.sqrt(49))
print(math.ceil(130 / 50))

3.68 3 4 7.0
3

La dernière ligne répond à une vraie question : il faut 3 cartons de 50 pour ranger 130 câbles. On arrondit par excès, sinon des câbles restent dehors.

Le hasard d'un ordinateur est pseudo-aléatoire : il vient d'un calcul. Les nombres semblent tirés au hasard, mais une formule les produit. Pour un jeu ou une simulation, ça suffit.

Ce tirage est uniforme : chaque valeur de l'intervalle a la même chance de sortir. Avec randint(1, 6), le 6 sort aussi souvent que le 1, comme avec un vrai dé.

3.3 Comparer et combiner des conditions

Pour savoir si un mot de passe est accepté, l'outil de Léa doit tester plusieurs règles à la fois. Comment écrit-on une condition, puis plusieurs ?

Un OPÉRATEUR DE COMPARAISON compare deux valeurs et donne un booléen : Vrai ou Faux. Un OPÉRATEUR BOOLÉEN combine des booléens : NON, ET, OU, OUX.

Comparer, c'est poser une question fermée à l'ordinateur. « Le mot de passe fait-il au moins 8 caractères ? »

La réponse est oui ou non. Pour plusieurs questions, on les relie avec ET ou OU, comme en français.

On compare des nombres, mais aussi des chaînes : "Alice" < "Bob" est Vrai. Les chaînes se comparent caractère par caractère, comme dans un dictionnaire.

Attention : les caractères se comparent par leur code. Les chiffres viennent avant les majuscules, et les majuscules avant les minuscules : "a" < "B" est Faux.

En une phrase chacun :

• NON a inverse : Vrai devient Faux.
• a ET b est Vrai seulement si les deux sont Vrai.
• a OU b est Vrai si au moins un des deux est Vrai.
• a OUX b, le « ou exclusif », est Vrai si exactement un des deux est Vrai. En Python, on l'écrit a != b entre deux booléens.

Python lit un ET de gauche à droite et s'arrête dès qu'un test est faux : la suite n'est pas lue. Avec OU, il s'arrête dès qu'un test est vrai. On s'en sert pour protéger un test : k < len(mot) and mot[k] == "S" ne lit jamais une case qui n'existe pas.

Traduire une condition. Une règle en français devient une expression booléenne. On repère chaque petite condition, puis les mots « et », « ou », « ne… pas ».

Quand ET et OU se mélangent, ET passe avant OU, comme la multiplication avant l'addition. Pour ne pas se tromper, mettez des parenthèses autour de chaque morceau : (a ET b) OU c.

mdp ← "Sio2026!"
long_ok ← longueur(mdp) ≥ 8
interdit ← mdp = "motdepasse"
accepte ← long_ok ET NON interdit
Écrire accepte

mdp = "Sio2026!"
long_ok = len(mdp) >= 8
interdit = mdp == "motdepasse"
accepte = long_ok and not interdit
print(accepte)

True

3.4 Les opérateurs bit à bit

Les droits d'accès d'un fichier tiennent sur trois bits : lire, écrire, exécuter. Comment lire ou changer un seul de ces bits ?

Un OPÉRATEUR BIT À BIT applique ET, OU, OUX ou NON à chaque bit d'un nombre, rang par rang. On l'utilise avec un MASQUE : un nombre choisi exprès, dont les 1 désignent les bits qu'on veut toucher.

Un masque, c'est comme le pochoir d'un peintre. Les trous laissent passer la peinture sur certaines zones seulement. Le reste ne bouge pas.

Les bits se numérotent de droite à gauche, en commençant à 0. Dans 0b101, le bit 0 vaut 1, le bit 1 vaut 0, le bit 2 vaut 1. En Python, 0b signale un nombre écrit en binaire.

Les droits d'un fichier : le bit 2 pour lire, le bit 1 pour écrire, le bit 0 pour exécuter. 0b101 veut dire : lire oui, écrire non, exécuter oui.

droits = 0b101
print(bin(droits & 0b100))
print(bin(droits | 0b010))
print(bin(droits & ~0b001))
print(bin(droits ^ 0b001))

0b100
0b111
0b100
0b100

Le signe ~ inverse tous les bits : ~0b001 met des 1 partout, sauf au bit 0. La fonction bin affiche un nombre en binaire.

La 1ʳᵉ ligne donne un résultat différent de 0 : le droit de lire est présent. La 2ᵉ ajoute le droit d'écrire.

La 3ᵉ retire le droit d'exécuter. La 4ᵉ l'inverse : il était là, il disparaît.

3.5 Les opérateurs de chaînes

Un journal de serveur contient des lignes comme ERREUR 2026-10-18 disque plein. Comment en tirer la date, ou savoir si le mot « ERREUR » y est ?

Les OPÉRATEURS DE CHAÎNES permettent de coller des chaînes, d'en extraire un morceau et d'y chercher un motif. Coller deux chaînes s'appelle la CONCATÉNATION. Un MOTIF est un petit texte qu'on cherche dans un plus grand.

On manipule du texte partout en informatique : des adresses mail, des adresses de sites web, des journaux d'erreurs, les messages affichés à l'utilisateur.

Dans ce tableau, n est la longueur de la chaîne. En Python, un indice négatif compte depuis la fin : s[-1] est le dernier caractère, et s[-3:] les trois derniers. s[i:] va de l'indice i jusqu'à la fin.

En Python, certaines fonctions s'écrivent après la variable, avec un point : s.find(motif) cherche dans s. On les appelle des méthodes. C'est seulement une autre façon d'écrire position(s, motif).

Dans s[i:j], le caractère d'indice i est pris, celui d'indice j est exclu. On prend donc j - i caractères.

ligne = "ERREUR 2026-10-18 disque plein"
print(ligne[:6])
print(ligne[7:17])
print(ligne.find("disque"))
print(ligne.find("réseau"))
message = "Date : " + ligne[7:17]
print(message)

ERREUR
2026-10-18
18
-1
Date : 2026-10-18

Le programme officiel permet aussi les expressions régulières simples, sans les étudier. Ce cours n'en a pas besoin.

Ce qu'on retient du chapitre 3

Les trois outils de Léa sont prêts. Le convertisseur de durée utilise div et mod.

Le contrôle du mot de passe combine ses règles avec ET. Et les droits du fichier se lisent avec un masque.

Chapitre 4 — Les structures de contrôle

Hugo gère le parc informatique d'une médiathèque. Il veut un programme qui vérifie chaque poste : s'il est trop vieux, il faut le remplacer. Il veut aussi compter les postes à remplacer, et redemander une valeur tant qu'elle n'est pas correcte.

Jusqu'ici, nos programmes lisent les lignes une fois, de haut en bas. Ça ne suffit plus.

À la fin de ce chapitre, vous saurez faire des choix et des répétitions dans un algorithme. C'est le cœur du programme, et le cœur de l'examen.

4.1 Faire un choix : Si… Alors… Sinon

Hugo veut un message différent selon l'âge du poste. Comment faire exécuter une instruction seulement dans certains cas ?

Une STRUCTURE CONDITIONNELLE exécute un bloc d'instructions seulement si une condition est vraie. On l'appelle aussi une ALTERNATIVE. Elle s'écrit Si … Alors … Sinon … Fin de Si.

C'est un carrefour. Selon le panneau, on prend à gauche ou à droite. On ne prend jamais les deux routes.

Comment ça marche :

1. L'ordinateur évalue la condition : Vrai ou Faux.
2. Si elle est Vrai, il exécute le bloc après Alors.
3. Sinon, il exécute le bloc après Sinon, s'il y en a un.
4. Puis il continue après Fin de Si.

Pour plus de deux cas, on enchaîne avec Sinon si. Les conditions sont testées dans l'ordre. Le premier cas vrai gagne, les suivants sont ignorés.

age ← 7
Si age ≥ 6 Alors
    Écrire "À remplacer"
Sinon si age ≥ 4 Alors
    Écrire "À surveiller"
Sinon
    Écrire "En bon état"
Fin de Si

age = 7
if age >= 6:
    print("À remplacer")
elif age >= 4:
    print("À surveiller")
else:
    print("En bon état")

À remplacer

En Python, le bloc est marqué par l'indentation : les lignes décalées de 4 espaces après les deux-points :. Il n'y a pas de Fin de Si. C'est le retour à gauche qui ferme le bloc.

4.2 Répéter un nombre connu de fois : la boucle Pour

Hugo a 30 postes à vérifier. Il sait combien il y en a. Comment répéter le même traitement pour chacun, sans écrire 30 fois le code ?

Une BOUCLE répète un bloc d'instructions. Chaque passage dans la boucle s'appelle une ITÉRATION, ou un tour.

La boucle POUR sert quand on connaît le nombre de tours à l'avance. Elle utilise un COMPTEUR, une variable qui prend une nouvelle valeur à chaque tour.

C'est l'entraîneur qui dit : « 10 pompes. » Vous comptez 1, 2, 3… jusqu'à 10, puis vous vous arrêtez.

Comment ça marche :

1. Le compteur prend la première valeur.
2. On exécute le bloc.
3. Le compteur passe à la valeur suivante. On recommence le bloc.
4. Après la dernière valeur, on sort de la boucle.

somme ← 0
Pour i allant de 1 à 4 Faire
    somme ← somme + i
Fin de Pour
Écrire somme

somme = 0
for i in range(1, 5):
    somme = somme + i
print(somme)

10

En Python, range(1, 5) donne 1, 2, 3, 4 : la borne de droite est exclue. Pour aller de 1 à n, on écrit range(1, n + 1). range(n) seul va de 0 à n - 1 : c'est pratique pour les indices d'une chaîne.

Si la fin est plus petite que le début, la boucle Pour fait 0 tour : Pour i allant de 5 à 3 Faire ne fait rien. En Python, range(5, 4) est vide.

4.3 Répéter tant que : les boucles Tant que et Répéter

Hugo veut que l'utilisateur tape un âge entre 0 et 15. Tant que la valeur est fausse, on redemande. Combien de fois ?

On ne sait pas à l'avance. La boucle Pour ne convient pas.

La boucle TANT QUE répète un bloc tant qu'une condition est vraie. Elle teste la condition avant chaque tour.

La boucle RÉPÉTER … JUSQU'À exécute le bloc, puis teste : elle fait donc toujours au moins un tour, et elle s'arrête quand la condition devient vraie.

C'est comme remplir un verre au robinet. Tant que le verre n'est pas plein, on continue de verser. On ne sait pas d'avance combien de secondes il faudra.

Comment ça marche, pour Tant que :

1. On teste la condition.
2. Si elle est Vrai, on exécute le bloc, puis on revient à l'étape 1.
3. Si elle est Faux, on sort de la boucle.
4. Le bloc doit changer quelque chose dans la condition. Sinon, elle reste vraie pour toujours : c'est une BOUCLE INFINIE.

Voici le calcul d'un reste par soustractions. C'est l'idée du sujet du BTS 2025 :

n ← 80
Tant que n ≥ 26 Faire
    n ← n - 26
Fin de Tant que
Écrire n

n = 80
while n >= 26:
    n = n - 26
print(n)

2

Fonction reste_division_par_26(N)
    Tant que N ≥ 26 Faire
        N ← N - 26
    Fin de Tant que
    Renvoyer N
Fin de Fonction

Python n'a pas de boucle Répéter. On l'imite avec while True, une boucle sans fin, et break, qui force la sortie :

Répéter
    Écrire "Âge du poste (0 à 15) ?"
    Lire age
Jusqu'à age ≥ 0 ET age ≤ 15
Écrire "Âge enregistré :", age

while True:
    age = int(input("Âge du poste (0 à 15) ? "))
    if age >= 0 and age <= 15:
        break
print("Âge enregistré :", age)

Âge du poste (0 à 15) ? 40
Âge du poste (0 à 15) ? 12
Âge enregistré : 12

i ← 1
Tant que i ≤ 4 Faire
    // le bloc de la boucle
    i ← i + 1
Fin de Tant que

// le bloc de la boucle, une première fois
Tant que NON condition Faire
    // le bloc de la boucle
Fin de Tant que

4.4 Construire une boucle de calcul

Hugo veut la valeur totale de son parc, ou le nombre de postes à remplacer. Ce sont des calculs qui s'accumulent tour après tour. Comment construire ce genre de boucle sans se tromper ?

Une boucle de calcul se construit toujours en trois temps : la PRÉPARATION, l'ITÉRATION et la MISE EN FORME FINALE. On l'appelle un calcul itératif. Pendant l'itération, une variable accumule le résultat : c'est un ACCUMULATEUR.

C'est comme une tirelire. On la vide au départ.

À chaque pièce, on ajoute sa valeur. À la fin, on compte et on annonce le total.

Comment ça marche :

1. Préparation : on donne à l'accumulateur sa valeur de départ. Pour une somme, c'est 0. Pour un produit, c'est 1. Ce sont les nombres qui ne changent rien : 0 pour l'addition, 1 pour la multiplication. On les appelle des éléments neutres.
2. Itération : à chaque tour, on met à jour l'accumulateur avec la valeur du tour.
3. Mise en forme finale : après la boucle, on calcule et on présente le résultat : division pour une moyenne, arrondi, message.

En maths, une somme qui dépend de n s'écrit avec le symbole Σ, la lettre grecque sigma :

On lit « somme des i au carré, pour i allant de 1 à n ». Le Π, la lettre grecque pi majuscule, fait la même chose avec un produit : .

Chaque Σ devient une boucle Pour, avec un accumulateur qui part de 0. Chaque Π devient une boucle Pour, avec un accumulateur qui part de 1.

n ← 4
s ← 0
p ← 1
Pour i allant de 1 à n Faire
    s ← s + i ^ 2
    p ← p * i
Fin de Pour
Écrire "Somme :", s, "Produit :", p

n = 4
s = 0
p = 1
for i in range(1, n + 1):
    s = s + i ** 2
    p = p * i
print("Somme :", s, "Produit :", p)

Somme : 30 Produit : 24

En Python, il existe sum(...). On ne s'en sert pas ici : à l'examen, c'est la boucle qu'on vous demande d'écrire.

4.5 Les structures imbriquées

Hugo a plusieurs salles, et plusieurs postes par salle. Il veut un message seulement pour les postes trop vieux. Comment mettre une boucle dans une boucle, ou une condition dans une boucle ?

Des STRUCTURES IMBRIQUÉES sont des structures placées l'une dans l'autre : une condition dans une boucle, une boucle dans une boucle. La structure intérieure s'exécute entièrement à chaque tour de la structure extérieure.

C'est l'horloge. L'aiguille des minutes fait un tour complet pendant que celle des heures avance d'un cran.

Comment ça marche, pour deux boucles :

1. La boucle extérieure prend sa première valeur.
2. La boucle intérieure fait tous ses tours.
3. La boucle extérieure passe à la valeur suivante, et la boucle intérieure recommence depuis le début.
4. Le bloc intérieur s'exécute donc (tours extérieurs) × (tours intérieurs) fois.

Pour i allant de 1 à 3 Faire
    ligne ← ""
    Pour j allant de 1 à i Faire
        ligne ← ligne + "*"
    Fin de Pour
    Écrire ligne
Fin de Pour

for i in range(1, 4):
    ligne = ""
    for j in range(1, i + 1):
        ligne = ligne + "*"
    print(ligne)

*
**
***

Ici, la boucle intérieure dépend de la boucle extérieure : elle va jusqu'à i. Le programme officiel limite ces boucles qui dépendent l'une de l'autre à deux niveaux.

Le produit de deux matrices. C'est l'exemple type de boucles imbriquées. Une MATRICE est un tableau de nombres, en lignes et en colonnes. La formule du produit est donnée à l'examen :

On lit : pour la case en ligne i, colonne j de C, on multiplie la ligne i de A par la colonne j de B. On multiplie terme à terme, puis on additionne.

Il faut trois boucles imbriquées : i pour les lignes, j pour les colonnes, k pour la somme.

En Python, on range une matrice comme une liste de lignes. A[i][k] est le nombre de la ligne i, colonne k. On compte à partir de 0.

La capsule 5.2 détaille ces tableaux à deux dimensions.

A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]
C = [[0, 0], [0, 0]]
for i in range(2):
    for j in range(2):
        s = 0
        for k in range(2):
            s = s + A[i][k] * B[k][j]
        C[i][j] = s
print(C)

[[19, 22], [43, 50]]

i ← 2
Tant que i < n ET n mod i ≠ 0 Faire
    i ← i + 1
Fin de Tant que
premier ← (i = n)

Ce qu'on retient du chapitre 4

Le programme d'Hugo parcourt maintenant chaque salle, chaque poste. Il affiche les postes à remplacer, les compte, et redemande une valeur tant qu'elle est fausse.

Chapitre 5 — Les tableaux et les fonctions

Sarah est développeuse dans une petite entreprise. Elle doit traiter les notes de tous les stagiaires : la moyenne de chacun, la moyenne de chaque module, la meilleure note.

Elle a déjà écrit trois fois le même calcul de moyenne, à trois endroits du programme. Et ses 24 stagiaires ont chacun 4 notes : 96 variables, c'est impossible à gérer.

À la fin de ce chapitre, vous saurez ranger beaucoup de valeurs dans un tableau, et écrire un calcul une seule fois dans une fonction.

5.1 Les tableaux à une dimension

Sarah a 4 notes pour un stagiaire. Plutôt que 4 variables, peut-on les ranger ensemble, sous un seul nom ?

Un TABLEAU range plusieurs valeurs sous un seul nom. Chaque valeur est un ÉLÉMENT, repéré par son indice, à partir de 0.

Un tableau à une dimension est une simple liste de valeurs. En Python, on l'appelle une liste et on l'écrit entre crochets : [12, 15, 9, 18].

Un tableau, c'est comme une rangée de casiers numérotés à la piscine. Un seul nom pour la rangée, un numéro par casier.

Comment ça marche :

1. Construire : notes ← [12, 15, 9, 18]. On peut aussi partir d'un tableau vide, T ← [], puis le remplir avec ajouter.
2. Lire un élément : notes[2] vaut 9.
3. Écrire un élément : notes[2] ← 11 remplace 9 par 11.
4. Parcourir : une boucle sur les indices, de 0 à longueur(notes) - 1. Si l'indice ne sert pas, on parcourt directement les valeurs : Pour chaque x dans notes Faire. En Python : for x in notes:.
5. Ajouter à la fin : ajouter(notes, 14). En Python : notes.append(14).

Le plus souvent, un tableau est homogène : tous ses éléments ont le même type. La capsule 5.2 montre un cas où les colonnes ont des types différents.

notes ← [12, 15, 9, 18]
notes[2] ← 11
meilleure ← notes[0]
Pour i allant de 1 à longueur(notes) - 1 Faire
    Si notes[i] > meilleure Alors
        meilleure ← notes[i]
    Fin de Si
Fin de Pour
Écrire notes, meilleure

notes = [12, 15, 9, 18]
notes[2] = 11
meilleure = notes[0]
for i in range(1, len(notes)):
    if notes[i] > meilleure:
        meilleure = notes[i]
print(notes, meilleure)

[12, 15, 11, 18] 18

C'est la méthode du maximum : on suppose que le premier est le meilleur, puis on compare avec chacun des suivants.

Copier un tableau. C'est le piège classique de Python. b = a ne copie pas le tableau : b devient un deuxième nom pour le même tableau. Pour une vraie copie, on écrit b = a.copy().

a = [1, 2, 3]
b = a
c = a.copy()
b[0] = 99
print(a, c)

[99, 2, 3] [1, 2, 3]

Modifier b a modifié a. La copie c, elle, n'a pas bougé. C'est comme un raccourci sur le bureau : il ouvre le même fichier, pas une copie.

En pseudo-code, on copie un tableau élément par élément. On part d'un tableau vide, et on y ajoute chaque valeur :

copie ← []
Pour chaque x dans a Faire
    ajouter(copie, x)
Fin de Pour
copie[0] ← 99
Écrire a, copie

a = [1, 2, 3]
copie = []
for x in a:
    copie.append(x)
copie[0] = 99
print(a, copie)

[1, 2, 3] [99, 2, 3]

5.2 Les tableaux à deux dimensions

Sarah a 24 stagiaires et 4 modules. Un tableau par stagiaire, c'est encore 24 noms. Comment ranger toute la grille sous un seul nom ?

Un TABLEAU À DEUX DIMENSIONS range des valeurs en lignes et en colonnes, comme un tableur. On repère un élément par deux indices : la ligne, puis la colonne.

M[i][j] est l'élément de la ligne i, colonne j. En Python, c'est une liste de listes : chaque ligne est une liste.

C'est la grille d'une bataille navale. « B3 » désigne une case : une ligne, une colonne.

notes = [[12, 15, 9, 18],
         [8, 11, 14, 10],
         [16, 13, 17, 15]]
print(notes[1][2])
print(len(notes), "lignes,", len(notes[0]), "colonnes")

14
3 lignes, 4 colonnes

Comment ça marche, pour traiter une ligne ou une colonne :

1. Une ligne i : on fixe i, et on fait varier j de 0 au nombre de colonnes moins 1.
2. Une colonne j : on fixe j, et on fait varier i de 0 au nombre de lignes moins 1.
3. Tout le tableau : deux boucles imbriquées, i dehors, j dedans.

// moyenne de la colonne 2 (le module 3)
s ← 0
Pour i allant de 0 à 2 Faire
    s ← s + notes[i][2]
Fin de Pour
Écrire s / 3

notes = [[12, 15, 9, 18],
         [8, 11, 14, 10],
         [16, 13, 17, 15]]
s = 0
for i in range(3):
    s = s + notes[i][2]
print(s / 3)

13.333333333333334

Pour construire un tableau à deux dimensions, on utilise aussi deux boucles. Pour une grille de 3 lignes et 4 colonnes remplie de 0, on fabrique chaque ligne, puis on l'ajoute à la grille :

grille ← []
Pour i allant de 0 à 2 Faire
    ligne ← []
    Pour j allant de 0 à 3 Faire
        ajouter(ligne, 0)
    Fin de Pour
    ajouter(grille, ligne)
Fin de Pour
grille[1][2] ← 7
Écrire grille

grille = []
for i in range(3):
    ligne = []
    for j in range(4):
        ligne.append(0)
    grille.append(ligne)
grille[1][2] = 7
print(grille)

[[0, 0, 0, 0], [0, 0, 7, 0], [0, 0, 0, 0]]

La ligne repart vide à chaque tour de i : chaque ligne est un tableau à elle.

Dans un tableau à deux dimensions, les lignes ou les colonnes peuvent avoir des types différents. Ici, ce sont les colonnes : chaque ligne décrit un stagiaire, avec son nom, son âge, s'il est présent.

stagiaires = [["Sarah", 22, True],
              ["Tom", 19, False]]
for ligne in stagiaires:
    print(ligne[0], "a", ligne[1], "ans")

Sarah a 22 ans
Tom a 19 ans

for ligne in stagiaires parcourt directement les lignes, sans indice. C'est pratique quand on n'a pas besoin du numéro.

On peut aussi ranger ces données dans l'autre sens : une ligne de noms, une ligne d'âges. Ce sont alors les lignes qui ont des types différents.

5.3 Les fonctions et les procédures

Sarah a écrit trois fois le calcul de moyenne. Si elle trouve une erreur dedans, elle devra la corriger trois fois. Comment écrire un calcul une seule fois, et s'en servir partout ?

Une FONCTION est un morceau d'algorithme qui porte un nom, reçoit des valeurs et renvoie un résultat. Une PROCÉDURE est pareille, mais ne renvoie rien : elle fait une action, comme afficher. Les valeurs reçues s'appellent les PARAMÈTRES.

Une fonction, c'est une machine à café. On met une capsule, l'eau. Elle rend un café.

On n'a pas besoin de savoir ce qui se passe dedans pour s'en servir. C'est l'idée de modularité : on découpe un gros programme en petites pièces qu'on teste une par une.

Comment ça marche :

1. On définit la fonction une fois : son nom, ses paramètres, son bloc.
2. Renvoyer donne le résultat et termine la fonction.
3. On appelle la fonction par son nom, avec des valeurs : moyenne([12, 15, 9]).
4. Le résultat peut être rangé dans une variable, affiché, ou utilisé dans un calcul.

Fonction moyenne(T)
    s ← 0
    Pour i allant de 0 à longueur(T) - 1 Faire
        s ← s + T[i]
    Fin de Pour
    Renvoyer s / longueur(T)
Fin de Fonction

Procédure afficher_bilan(nom, T)
    Écrire nom, ":", moyenne(T)
Fin de Procédure

afficher_bilan("Sarah", [12, 15, 9, 18])

def moyenne(T):
    s = 0
    for i in range(len(T)):
        s = s + T[i]
    return s / len(T)

def afficher_bilan(nom, T):
    print(nom, ":", moyenne(T))

afficher_bilan("Sarah", [12, 15, 9, 18])

Sarah : 13.5

La procédure appelle la fonction : on assemble les pièces. Une fonction peut aussi renvoyer plusieurs valeurs : Renvoyer (s, p). En Python, on écrit return s, p, et on récupère les deux résultats avec deux variables, dans le même ordre :

def somme_et_produit(T):
    s = 0
    p = 1
    for x in T:
        s = s + x
        p = p * x
    return s, p

total, produit = somme_et_produit([2, 3, 4])
print(total, produit)

9 24

En pseudo-code, on écrit les deux variables entre parenthèses, à gauche de la flèche : (total, produit) ← somme_et_produit([2, 3, 4]).

Renvoyer peut aussi se trouver dans une boucle. Il arrête alors la fonction dès qu'on a trouvé ce qu'on cherche :

Fonction contient(T, v)
    Pour i allant de 0 à longueur(T) - 1 Faire
        Si T[i] = v Alors
            Renvoyer Vrai
        Fin de Si
    Fin de Pour
    Renvoyer Faux
Fin de Fonction

def contient(T, v):
    for i in range(len(T)):
        if T[i] == v:
            return True
    return False

print(contient([4, 8, 15], 8), contient([4, 8, 15], 3))

True False

Avec 8, la fonction s'arrête au 2ᵉ tour : la boucle ne va pas plus loin. Avec 3, la boucle va jusqu'au bout sans trouver, et on arrive à Renvoyer Faux.

5.4 Paramètres et variables locales

Dans la fonction moyenne, Sarah utilise une variable s. Son programme principal a aussi une variable s.

Vont-elles se mélanger ? Et une fonction peut-elle modifier le tableau qu'on lui donne ?

Une VARIABLE LOCALE est créée dans une fonction : elle n'existe que pendant l'appel, et seulement dans la fonction. Une VARIABLE GLOBALE est créée dans le programme principal : elle est visible partout. Ce qui passe entre le programme et la fonction s'appelle l'INTERFACE : les paramètres et le résultat.

Une variable locale, c'est le brouillon d'un exercice. Vous l'utilisez pour calculer, puis vous le jetez. Seul le résultat, recopié au propre, compte.

Comment passent les données :

En Python, une valeur simple, comme un nombre ou un texte, ne sort jamais par un paramètre : elle sort par return. Seul un tableau peut sortir par un paramètre.

def remplir(T, n):
    for i in range(n):
        T.append(0)

def bonus(T):
    for i in range(len(T)):
        T[i] = T[i] + 1

def total(T):
    s = 0
    for x in T:
        s = s + x
    return s

zeros = []
remplir(zeros, 3)
notes = [12, 15, 9]
s = 100
bonus(notes)
print(zeros)
print(notes, total(notes), s)

[0, 0, 0]
[13, 16, 10] 39 100

La procédure remplir n'a jamais lu zeros : elle l'a seulement rempli. C'est un transfert en sortie seule.

La procédure bonus a modifié le tableau notes : c'est un transfert en entrée et sortie. La variable s de total est locale : le s global vaut toujours 100.

compteur = 0

def ajouter_un():
    global compteur
    compteur = compteur + 1

ajouter_un()
ajouter_un()
print(compteur)

2

Ce qu'on retient du chapitre 5

Sarah a maintenant un seul tableau pour toutes les notes, et une seule fonction moyenne. Elle l'appelle pour chaque stagiaire et pour chaque module. Quand elle corrige la fonction, tout le programme est corrigé d'un coup.