Seconde · Algorithmique et Programmation · 2S4

Cours et exercices corrigés de seconde : Algorithmique et programmation : variables, instructions conditionnelles, boucles et fonctions

Variables et types (entier, flottant, chaîne, booléen), affectation, instructions conditionnelles if/elif/else, boucles bornées for et non bornées while, fonctions Python avec paramètres et valeur renvoyée.

🎯 S'entraîner sur ce chapitre ⏱️ Rituel flash 🗂️ Flashcards

Objectifs du chapitre

Choisir ou déterminer le type d'une variable : entier (int), flottant (float), chaîne de caractères (str), booléen (bool).
Concevoir et exécuter à la main une suite d'affectations en suivant l'évolution des variables.
Écrire une instruction conditionnelle if … elif … else à l'aide de conditions et de connecteurs and, or, not.
Programmer une boucle bornée (for i in range(…)) et une boucle non bornée (while condition:), et savoir laquelle choisir.
Écrire une fonction Python avec un ou plusieurs paramètres et une valeur renvoyée (return), puis l'appeler.
Utiliser les opérateurs // (quotient entier), % (reste) et ** (puissance) dans des problèmes mathématiques.
Passer d'un algorithme écrit en langage naturel (affectation notée $\leftarrow$ ) à un programme Python, et inversement.

Le cours

1. Variables, types et affectation

Une variable est un nom associé à une valeur stockée en mémoire. L'affectation $x = 5$ range la valeur $5$ dans la variable $x$ (le signe $=$ n'est pas une égalité mathématique : il se lit « prend la valeur »).

$int$ : nombre entier ( $7$ , $-3$ ) ;
$float$ : nombre à virgule flottante, écrit avec un point ( $2.5$ , $0.1$ ) ;
$str$ : chaîne de caractères entre guillemets ( $"Bonjour"$ ) ;
$bool$ : booléen, $True$ ou $False$ (résultat d'une comparaison comme $3 < 5$ ).

Opérations utiles : $+$ , $-$ , $*$ , $/$ (division décimale, résultat flottant : $7 / 2$ vaut $3{,}5$ ), $//$ (quotient entier : $7 // 2$ vaut $3$ ), $%$ (reste : $7 % 2$ vaut $1$ ), $**$ (puissance : $2 ** 5$ vaut $32$ ).

a = 7
b = 2
q = a // b    # 3
r = a % b     # 1
print(q, r)   # affiche 3 1

2. Exécuter un programme à la main

Les instructions s'exécutent dans l'ordre, de haut en bas. Chaque affectation utilise les valeurs actuelles des variables : l'ancienne valeur est écrasée.
Pour suivre un programme, on dresse un tableau d'état des variables, ligne après ligne.

a = 3
b = 5
a = a + b     # a vaut 8
b = a - b     # b vaut 3
a = a - b     # a vaut 5

Ce programme échange les valeurs de $a$ et $b$ . On peut aussi écrire $a, b = b, a$ (affectation simultanée) ou utiliser une variable auxiliaire $c$ .

3. Instructions conditionnelles

Une instruction conditionnelle exécute un bloc seulement si une condition est vraie. Les blocs sont délimités par l'indentation (4 espaces) et la ligne de test se termine par $:$ .

if delta > 0:
    nb = 2
elif delta == 0:
    nb = 1
else:
    nb = 0

Comparaisons : $==$ (égal), $!=$ (différent), $<$ , $<=$ , $>$ , $>=$ .
Connecteurs logiques : $and$ (les deux conditions), $or$ (au moins l'une), $not$ (négation).
Tester la parité : $n % 2 == 0$ est vrai si et seulement si $n$ est pair.

4. Boucle bornée `for`

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

$range(n)$ parcourt $0, 1, \dots, n - 1$ ( $n$ valeurs) ;
$range(a, b)$ parcourt $a, a + 1, \dots, b - 1$ (la borne $b$ est exclue) ;
$range(a, b, p)$ avance avec un pas $p$ .

Exemple : calcul de $1 + 2 + \dots + 100$ avec un accumulateur $s$ .

s = 0
for i in range(1, 101):
    s = s + i
print(s)      # affiche 5050

5. Boucle non bornée `while`

On utilise une boucle non bornée quand on répète une action tant qu'une condition est vraie, sans connaître à l'avance le nombre de tours (recherche d'un seuil).

capital = 1000
annees = 0
while capital < 2000:
    capital = capital * 1.05
    annees = annees + 1
print(annees)   # affiche 15

La condition est testée avant chaque tour. Il faut s'assurer que la condition finit par devenir fausse, sinon le programme ne s'arrête jamais (boucle infinie).

6. Fonctions

Une fonction regroupe des instructions réutilisables. Elle reçoit des paramètres et renvoie un résultat avec $return$ (l'exécution de la fonction s'arrête alors).

def image(x):
    return 3 * x ** 2 - 5

def est_multiple(n, d):
    return n % d == 0

print(image(2))            # affiche 7
print(est_multiple(21, 7)) # affiche True

Ne pas confondre $return$ (la fonction renvoie une valeur utilisable dans un calcul) et $print$ (qui affiche seulement une valeur à l'écran).

7. Du langage naturel à Python

En langage naturel, l'affectation se note avec une flèche : $a \leftarrow 3$ se lit « $a$ prend la valeur $3$ ».

Langage naturel	Python
$s \leftarrow 0$	$s = 0$
Pour $i$ allant de $1$ à $10$	$for i in range(1, 11):$
$s \leftarrow s + i^2$	$s = s + i ** 2$
Tant que $s < 100$	$while s < 100:$
Si $n$ est pair, alors… sinon…	$if n % 2 == 0:$ … $else:$ …
Afficher $s$	$print(s)$

Exemple : l'algorithme «

s \leftarrow 0

; pour

i

allant de

1

10

s \leftarrow s + i^2

; afficher

s

» calcule

1^2 + 2^2 + \dots + 10^2 = 385

Une fonction peut avoir plusieurs arguments : $def aire_rectangle(L, l): return L * l$ ; l'appel $aire_rectangle(5, 3)$ renvoie $15$ .

Méthodes et exemples rédigés

Méthode : Faire tourner un programme à la main

Exemple

Qu'affiche le programme suivant ?

x = 4
y = 1
for k in range(3):
    y = y * x
    x = x - 1
print(y)

Étape 1 (État initial) : $x = 4$ , $y = 1$ . La boucle s'exécute 3 fois ( $k$ vaut 0, 1, 2).
Étape 2 (Tour 1) : $y = 1 \times 4 = 4$ , puis $x = 3$ .
Étape 3 (Tours 2 et 3) : $y = 4 \times 3 = 12$ , $x = 2$ ; puis $y = 12 \times 2 = 24$ , $x = 1$ .
Conclusion : le programme affiche $24$ , c'est-à-dire $4 \times 3 \times 2$ .

Méthode : Choisir entre boucle for et boucle while

Exemple

Une population de bactéries double toutes les heures, à partir de 500 bactéries. Écrire un programme donnant le nombre d'heures nécessaires pour dépasser 100 000 bactéries.

Étape 1 (Analyse) : on ne connaît pas à l'avance le nombre d'heures : on choisit une boucle non bornée $while$ .
Étape 2 (Condition) : on continue tant que la population est inférieure ou égale à 100 000 : $while p <= 100000:$ .

Étape 3 (Programme) :

p = 500
h = 0
while p <= 100000:
    p = 2 * p
    h = h + 1
print(h)

Conclusion : $500 \times 2^7 = 64\,000$ et $500 \times 2^8 = 128\,000$ , donc le programme affiche $8$ heures.

Méthode : Écrire une fonction avec une instruction conditionnelle

Exemple

Écrire une fonction $tarif(age)$ qui renvoie le prix d'une entrée de cinéma : 5 euros avant 12 ans, 7 euros de 12 à 25 ans inclus, 10 euros ensuite. Que renvoie $tarif(25)$ ?

Étape 1 (Cas) : trois cas qui s'excluent, testés dans l'ordre : $if \dots elif \dots else$ .

Étape 2 (Programme) :

def tarif(age):
    if age < 12:
        return 5
    elif age <= 25:
        return 7
    else:
        return 10

Étape 3 (Appel) : pour $age = 25$ , le test $age < 12$ est faux, $age <= 25$ est vrai : la fonction renvoie $7$ .
Conclusion : $tarif(25)$ vaut $7$ ; attention à bien choisir $<$ ou $<=$ selon que la borne est incluse ou non.

Méthode : Utiliser le quotient et le reste

Exemple

Écrire un programme qui convertit une durée de 7 384 secondes en heures, minutes et secondes.

Étape 1 (Heures) : une heure vaut 3 600 s : $h = 7384 // 3600$ donne $2$ et il reste $7384 % 3600$ , soit $184$ s.
Étape 2 (Minutes et secondes) : $m = 184 // 60$ donne $3$ et $s = 184 % 60$ donne $4$ .

Étape 3 (Programme) :

t = 7384
h = t // 3600
reste = t % 3600
m = reste // 60
s = reste % 60
print(h, m, s)   # affiche 2 3 4

Conclusion : $7\,384$ s $= 2$ h $3$ min $4$ s, car $2 \times 3600 + 3 \times 60 + 4 = 7\,384$ .

Pièges fréquents

range(1, 10) s'arrête à $9$ : la borne de droite est exclue. Pour aller jusqu'à $n$ inclus, on écrit range(1, n + 1).
Ne pas confondre = (affectation) et == (test d'égalité) : if x = 3: provoque une erreur.
En Python, / donne toujours un flottant (6 / 2 vaut 3.0), alors que // donne le quotient entier. Les nombres décimaux s'écrivent avec un point : 2.5 et non 2,5.
Dans une boucle while, la condition est celle pour continuer, pas pour s'arrêter : pour s'arrêter dès que u dépasse 100, on écrit while u <= 100:.
L'indentation fait partie du langage : une instruction mal indentée change de bloc (et donc le résultat), ou provoque une erreur.

Questions de révision

Essaie de répondre de tête avant d'afficher la réponse.

Quelles valeurs prend i dans for i in range(2, 6): ?

$2$ , $3$ , $4$ et $5$ (la borne $6$ est exclue).

Que valent 17 // 5 et 17 % 5 ?

$3$ et $2$ , car $17 = 5 \times 3 + 2$ .

Quand utilise-t-on une boucle while plutôt qu'une boucle for ?

Quand on ne connaît pas à l'avance le nombre de répétitions : on répète tant qu'une condition est vraie (recherche de seuil).

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

$return$ renvoie une valeur réutilisable (et termine la fonction) ; $print$ se contente de l'afficher à l'écran.

Quel est le type de la valeur de 3 < 5 ?

Un booléen ( $bool$ ) : ici $True$ .

Comment tester en Python qu'un entier n est pair ?

Avec la condition $n % 2 == 0$ (le reste de la division par 2 est nul).

Traduire en Python « Pour

i

allant de

1

n

».

$for i in range(1, n + 1):$ (la borne de droite de $range$ est exclue).

Exercices corrigés

Exercice 1 Suivre des affectations

Palier 1 · découverte

Qu'affiche le programme Python suivant ?

a = 5
b = 2
a = a * b
b = a - b
print(a, b)

« 10 8 »
« 10 3 »
« 5 2 »
« 10 2 »

Un indice

Chaque affectation utilise les valeurs actuelles des variables.

Voir la correction

Bonne réponse : A. « 10 8 »

$a = 5 \times 2 = 10$ , puis $b = a - b = 10 - 2 = 8$ (on utilise la nouvelle valeur de $a$ ). Le programme affiche « 10 8 ».

Exercice 2 Boucle bornée et accumulateur

Palier 2 · application

Qu'affiche le programme Python suivant ?

s = 0
for i in range(1, 6):
    s = s + 2 * i
print(s)

$30$
$42$
$20$
$15$

Un indice

$range(1, 6)$ parcourt les entiers de $1$ à $5$ .

Voir la correction

Bonne réponse : A. $30$

$i$ prend les valeurs $1, 2, 3, 4, 5$ (la borne $6$ est exclue). Donc $s = 2 + 4 + 6 + 8 + 10 = 30$ .

Exercice 3 Boucle while et seuil

Palier 3 · approfondissement

Un capital de $500$ euros augmente de $10$ euros par mois. Le programme ci-dessous détermine au bout de combien de mois il dépasse strictement $600$ euros. Qu'affiche-t-il ?

c = 500
m = 0
while c <= 600:
    c = c + 10
    m = m + 1
print(m)

$11$
$10$
$12$
$610$

Un indice

La boucle continue tant que $c <= 600$ .

Voir la correction

Bonne réponse : A. $11$

Après $m$ tours, $c$ vaut $500 + 10m$ . Pour $m = 10$ , $c = 600$ et $c <= 600$ est encore vrai : on fait un tour de plus. Pour $m = 11$ , $c = 610$ : la boucle s'arrête. Le programme affiche $11$ .

Exercice 4 Fonction booléenne

Palier 4 · défi

On considère la fonction Python suivante.

def mystere(n):
    for d in range(2, n):
        if n % d == 0:
            return False
    return True

Pour un entier $n \ge 2$ , que teste cette fonction ?

Si $n$ est un nombre premier
Si $n$ est un nombre pair
Si $n$ est un carré parfait
Si $n$ est divisible par tous les entiers de $2$ à $n - 1$

Un indice

$n % d == 0$ signifie que $d$ divise $n$ .

Voir la correction

Bonne réponse : A. Si $n$ est un nombre premier

La fonction cherche un diviseur de $n$ parmi $2, 3, \dots, n - 1$ . Si elle en trouve un, elle renvoie $False$ ; sinon elle renvoie $True$ . Elle renvoie donc $True$ exactement lorsque $n$ n'a pas d'autre diviseur que $1$ et lui-même : elle teste si $n$ est premier.

Objectifs du chapitre

Le cours

1. Variables, types et affectation

2. Exécuter un programme à la main

3. Instructions conditionnelles

4. Boucle bornée for

5. Boucle non bornée while

6. Fonctions

7. Du langage naturel à Python

Méthodes et exemples rédigés

Méthode : Faire tourner un programme à la main

Méthode : Choisir entre boucle for et boucle while

Méthode : Écrire une fonction avec une instruction conditionnelle

Méthode : Utiliser le quotient et le reste

Pièges fréquents

Questions de révision

Exercices corrigés

Exercice 1 Suivre des affectations

Exercice 2 Boucle bornée et accumulateur

Exercice 3 Boucle while et seuil

Exercice 4 Fonction booléenne

4. Boucle bornée `for`

5. Boucle non bornée `while`