Quelle différence entre while et for en Python ?

La boucle for répète un bloc un nombre connu de fois (ou parcourt une liste), tandis que while répète tant qu'une condition est vraie, sans connaître à l'avance le nombre d'itérations.

Comment définit-on une fonction en Python ?

Avec le mot-clé def, suivi du nom de la fonction, des paramètres entre parenthèses et d'un bloc indenté. On utilise return pour renvoyer une valeur.

Lycée · 2ⁿᵈᵉ · Mathématiques

Algorithmique et programmation

Q: Qu'est-ce qu'un algorithme ?

Un algorithme est une suite finie et ordonnée d'instructions permettant de résoudre un problème ou d'effectuer un calcul.

Variables, instructions conditionnelles, boucles et fonctions : les bases de l'algorithmique au programme de 2nde générale

À propos de cette page

Ce cours de mathématiques en seconde sur « Algorithmique et programmation » suit le programme officiel de mathématiques de seconde. Il présente les définitions, les propriétés et les méthodes essentielles, accompagnées d'exemples résolus pour bien comprendre. Au programme : Qu'est-ce qu'un algorithme ?, Variables et affectation, Instructions d'entrée / sortie, Instructions conditionnelles. Chaque notion est expliquée pas à pas, puis mise en pratique grâce à des exercices interactifs, un QCM et une évaluation corrigée. Idéal pour réviser à son rythme, combler ses lacunes et progresser, en autonomie ou avec un professeur. Cours rédigé par un professeur particulier à Marseille pour aider les élèves de seconde à réussir en mathématiques.

Qu'est-ce qu'un algorithme ?

Un algorithme est une suite finie et ordonnée d'instructions permettant de résoudre un problème ou d'effectuer un calcul. Les algorithmes existent bien avant l'informatique (recettes, modes d'emploi…).

Définition. Un algorithme est une procédure systématique composée d'un nombre fini d'étapes clairement définies, garantissant d'aboutir à un résultat en un temps fini.

Un algorithme possède :

des données en entrée (valeurs fournies par l'utilisateur ou le contexte) ;
des instructions (calculs, tests, boucles…) ;
des données en sortie (résultats produits).

Astuce. En classe de 2nde, on utilisera principalement le langage Python pour coder les algorithmes. Un algorithme peut aussi s'écrire en pseudo-code ou sous forme d'organigramme.

Exemple. Algorithme de calcul de la somme des 100 premiers entiers : on initialise une variable somme à 0, puis on additionne successivement 1, 2, 3, …, 100, et on affiche le résultat.

Variables et affectation

Une variable est un espace mémoire repéré par un nom, contenant une valeur susceptible de changer au cours de l'exécution.

Définition. L'affectation est l'opération qui attribue une valeur à une variable. En Python, on écrit $x = 5$ (le signe $=$ est l'opérateur d'affectation, pas d'égalité mathématique).

Types de données courants en Python :

Type	Notation Python	Exemple
Entier	$int$	$n = 7$
Décimal (flottant)	$float$	$x = 3.14$
Chaîne de caractères	$str$	$s = "bonjour"$
Booléen	$bool$	$b = True$

Attention ! L'affectation $x = x + 1$ est parfaitement licite en algorithmique : on lit la valeur actuelle de x, on lui ajoute 1, et on range le résultat dans x. Ce n'est pas une équation mathématique.

Exemple. $a = 3$ puis $a = a * 2$ : après la deuxième instruction, $a$ vaut 6.

Instructions d'entrée / sortie

Pour interagir avec l'utilisateur, on utilise des instructions de lecture (entrée) et d'affichage (sortie).

Action	Python	Rôle
Entrée	$x = int(input("Entrer x : "))$	Lit une valeur saisie au clavier
Sortie	$print(x)$	Affiche une valeur à l'écran

La fonction $input()$ renvoie toujours une chaîne de caractères. Il faut donc la convertir si l'on attend un nombre : $int(…)$ pour un entier, $float(…)$ pour un décimal.

Astuce. On peut afficher plusieurs éléments avec $print("La somme est :", s)$ ou utiliser les f-strings : $print(f"La somme est {s}")$.

Exemple.
$n = int(input("Entrez un entier : "))$
$print("Son carré est", n**2)$
Si l'utilisateur saisit 5, l'affichage sera : Son carré est 25.

Instructions conditionnelles

Une instruction conditionnelle permet d'exécuter un bloc d'instructions seulement si une condition est vraie.

Syntaxe Python.
$if condition :$
$bloc si vrai$
$elif autre_condition :$
$bloc sinon-si$
$else :$
$bloc sinon$
L'indentation (4 espaces ou 1 tabulation) est obligatoire en Python.

Opérateurs de comparaison : $==$ (égal), $!=$ (différent), $\lt $, $\gt $, $\lt =$, $\gt =$.
Opérateurs logiques : $and$, $or$, $not$.

Attention ! Ne pas confondre $=$ (affectation) et $==$ (test d'égalité). Écrire $if x = 5 :$ provoque une erreur de syntaxe.

Exemple. Signe d'un nombre :
$x = float(input("Entrez x : "))$
$if x \gt 0 :$
$print("Positif")$
$elif x \lt 0 :$
$print("Négatif")$
$else :$
$print("Nul")$

Boucles bornées (for)

Une boucle bornée répète un bloc d'instructions un nombre de fois déterminé à l'avance.

Syntaxe Python.
$for i in range(n) :$
$instruction(s)$
$range(n)$ génère les entiers de 0 à n−1 (soit n valeurs). $range(a, b)$ génère les entiers de a à b−1. $range(a, b, p)$ avance par pas de p.

On peut aussi parcourir une liste : $for x in [1, 4, 9, 16] :$

Astuce. Si la variable de boucle est inutilisée dans le corps, on peut écrire $for _ in range(n) :$.

Exemple 1. Afficher les entiers de 1 à 10 :
$for i in range(1, 11) :$
$print(i)$

Exemple 2. Calculer la somme 1 + 2 + … + n :
$n = int(input())$
$s = 0$
$for i in range(1, n+1) :$
$s = s + i$
$print(s)$
Pour n = 5, on obtient s = 15.

Boucles non bornées (while)

Une boucle non bornée répète un bloc d'instructions tant qu'une condition reste vraie, sans connaître à l'avance le nombre d'itérations.

Syntaxe Python.
$while condition :$
$instruction(s)$
La condition est testée avant chaque itération. Si elle est fausse dès le départ, le bloc n'est jamais exécuté.

Attention ! Si la condition ne devient jamais fausse, la boucle tourne indéfiniment (boucle infinie). Il faut toujours s'assurer que la condition finit par devenir fausse (en modifiant une variable dans le corps de la boucle).

Exemple. Premier entier n tel que 2ⁿ > 1000 :
$n = 0$
$while 2**n \lt = 1000 :$
$n = n + 1$
$print(n)$
On obtient n = 10 car 2¹⁰ = 1024 > 1000.

Astuce. On utilise $for$ quand le nombre d'itérations est connu, et $while$ quand on répète jusqu'à ce qu'une condition soit satisfaite.

Fonctions en Python

Une fonction est un bloc d'instructions réutilisable, identifié par un nom, qui peut recevoir des paramètres et renvoyer un résultat.

Syntaxe de définition.
$def nom_fonction(param1, param2, ...) :$
$instructions$
$return valeur$
L'instruction $return$ met fin à la fonction et renvoie la valeur indiquée. Si elle est absente, la fonction renvoie $None$.

On appelle la fonction en écrivant $nom_fonction(argument1, argument2)$.

Exemple. Fonction renvoyant le maximum de deux nombres :
$def maximum(a, b) :$
$if a \gt = b :$
$return a$
$else :$
$return b$

$print(maximum(3, 7))$ → affiche 7

Astuce. Décomposer un programme en fonctions le rend plus lisible, plus facile à tester et réutilisable. C'est la base de la modularité.

Mise en œuvre : exemples résolus

Voici deux algorithmes complets illustrant les notions vues.

Exemple 1 — Test de parité.
Écrire une fonction qui indique si un entier est pair ou impair.
$def parite(n) :$
$if n % 2 == 0 :$
$return "pair"$
$else :$
$return "impair"$

$print(parite(14))$ → pair
$print(parite(9))$ → impair

L'opérateur $%$ (modulo) renvoie le reste de la division euclidienne.

Exemple 2 — Suite de Collatz.
Partant d'un entier n > 0 : si n est pair, diviser par 2 ; sinon, remplacer par 3n + 1. Répéter jusqu'à obtenir 1.
$def collatz(n) :$
$nb_etapes = 0$
$while n != 1 :$
$if n % 2 == 0 :$
$n = n // 2$
$else :$
$n = 3*n + 1$
$nb_etapes += 1$
$return nb_etapes$

$print(collatz(6))$ → 8 étapes (6→3→10→5→16→8→4→2→1)

Méthode. Face à un algorithme inconnu, on peut en simuler l'exécution sur un exemple simple en complétant un tableau de valeurs des variables à chaque étape (trace d'exécution).

En bref

Un algorithme est une suite finie d'instructions pour résoudre un problème.
Une variable stocke une valeur ; l'affectation ($=$) lui attribue une valeur.
$if / elif / else$ : exécution conditionnelle selon un test.
$for i in range(n)$ : boucle répétée n fois (bornée).
$while condition$ : boucle répétée tant que la condition est vraie (non bornée).
$def f(x) : … return …$ : définit une fonction réutilisable.
Ne pas confondre $=$ (affectation) et $==$ (test d'égalité).

Bloqué sur ce chapitre ?

Cours particuliers de mathématiques à Marseille, en présentiel ou à distance — un prof qui s'adapte à ton rythme et reprend ce qui coince.

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

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