Sciences numériques et technologie (SNT) 2ⁿᵈᵉ

Ressources · 2ⁿᵈᵉ · Sciences numériques et technologie (SNT)

Programmation en Python

Variables et affectations, types, conditions, boucles bornées et non bornées, fonctions (SNT de 2nde)

À propos de cette page

Ces exercices corrigés sur « Programmation en Python » en seconde permettent de s'entraîner et de vérifier ses acquis en sciences numériques et technologie (SNT). Ils suivent le programme officiel de seconde et sont classés par difficulté (facile, moyen, difficile). Au programme : L'essentiel : variables, affectations, types, Opérations, conversions et saisie, Instructions conditionnelles, Boucles bornées et non bornées. Chaque exercice est suivi d'une correction rédigée, à déplier une fois la recherche faite au brouillon. Cet entraînement aide à mémoriser les méthodes, repérer ses erreurs et gagner en confiance avant un contrôle. Exercices gratuits proposés par un professeur particulier à Marseille pour réviser sciences numériques et technologie (SNT) en seconde.

Exercices corrigés, classés du plus simple au plus complexe. Cherche d'abord seul au brouillon, puis déplie la correction détaillée pour vérifier ta méthode et tes raisonnements.

Exercice 1 — Affectations successives

Facile

On considère le programme suivant.

a = 4
b = a - 9
a = a * b
b = b + a

a) Donner les valeurs de a et de b après chaque ligne, puis leurs valeurs finales.
b) Quel est le type des variables a et b à la fin ? Justifier.
c) On veut échanger les valeurs de deux variables a et b. Expliquer pourquoi les deux lignes a = b puis b = a ne conviennent pas, puis écrire une suite d'instructions correcte.

a) On exécute les lignes dans l'ordre.
Ligne 1 : a = 4 (b n'existe pas encore).
Ligne 2 : b prend la valeur 4 − 9 = −5.
Ligne 3 : a prend la valeur 4 × (−5) = −20 ; l'ancienne valeur 4 est écrasée.
Ligne 4 : b prend la valeur −5 + (−20) = −25 (on utilise la nouvelle valeur de a).
Valeurs finales : a = −20 et b = −25.

b) Au départ, 4 est un entier. Les opérations +, − et × entre entiers donnent des entiers : a et b sont de type int.

c) Après a = b, l'ancienne valeur de a est perdue : a et b contiennent tous les deux la valeur de b, et b = a ne change plus rien. Il faut sauvegarder a dans une variable auxiliaire :

c = a
a = b
b = c

Par exemple avec a = 2 et b = 8 : c = 2, puis a = 8, puis b = 2. Les valeurs sont bien échangées.

Exercice 2 — Valeurs et types d'expressions

Facile

Pour chaque expression, donner la valeur calculée par Python et son type.

a) 23 // 5
b) 23 % 5
c) 23 / 5
d) '7' + '2'
e) 3 ** 4

a) 23 = 5 × 4 + 3 : le quotient entier est 4. 23 // 5 vaut 4, de type int.

b) Avec la même division, le reste est 3 (et 0 ≤ 3 < 5). 23 % 5 vaut 3, de type int.

c) / est la division décimale : 23 ÷ 5 = 4,6. Elle renvoie toujours un flottant : 4.6, de type float.

d) '7' et '2' sont des chaînes (guillemets) : + les met bout à bout. Résultat : '72', de type str (et non le nombre 9).

e) ** est la puissance : 3⁴ = 3 × 3 × 3 × 3 = 81. Résultat : 81, de type int.

Exercice 3 — Lire une instruction conditionnelle

Facile

Une station météo exécute le programme suivant.

t = float(input('Température : '))
if t < 0:
    print('Gel')
elif t < 25:
    print('Normal')
else:
    print('Chaud')

a) Qu'affiche le programme si l'on saisit −2 ?
b) Qu'affiche-t-il si l'on saisit 25 ? Et 0 ?
c) Expliquer le rôle de float dans la première ligne.
d) Pourquoi le programme n'affiche-t-il jamais à la fois « Gel » et « Normal » pour −2, alors que −2 < 25 ?

a) t = −2. La condition −2 < 0 est vraie : le programme affiche Gel.

b) Pour 25 : 25 < 0 est faux, 25 < 25 est faux (l'inégalité est stricte), on exécute donc le else : Chaud.
Pour 0 : 0 < 0 est faux, 0 < 25 est vrai : Normal.

c) input renvoie toujours une chaîne de caractères. On ne peut pas comparer une chaîne à un nombre avec <. float convertit la saisie en flottant, ce qui accepte aussi les températures décimales comme 18.5. float rend la comparaison numérique possible.

d) Dans une structure if … elif … else, les conditions sont testées dans l'ordre et seul le premier bloc dont la condition est vraie est exécuté. Comme −2 < 0 est vrai, le bloc du if s'exécute et les branches elif et else sont ignorées.

Exercice 4 — Boucle for et fonction range

Moyen

a) Donner la liste des valeurs prises par i dans for i in range(2, 11, 3):.
b) Combien de fois la boucle for j in range(15): s'exécute-t-elle ? Quelle est la dernière valeur de j ?
c) Que vaut s à la fin du programme suivant ? Présenter le calcul.
```
s = 0
for k in range(1, 9):
    s = s + k * k
```
d) Écrire une boucle qui affiche les multiples de 7 de 7 à 70 inclus.

a) On part de 2, on avance de 3 en 3, et on s'arrête strictement avant 11 : 2, 5, 8 (la valeur suivante, 11, est exclue). i prend les valeurs 2, 5, 8.

b) range(15) donne les entiers de 0 à 14, soit 15 valeurs : la boucle s'exécute 15 fois et la dernière valeur de j est 14.

c) k prend les valeurs 1 à 8 et l'on ajoute k² à chaque tour :
s = 1, puis 1 + 4 = 5, 5 + 9 = 14, 14 + 16 = 30, 30 + 25 = 55, 55 + 36 = 91, 91 + 49 = 140, 140 + 64 = 204.
Le programme calcule 1² + 2² + … + 8² : s = 204.

d) Il faut partir de 7, avancer de 7, et inclure 70 : la borne de fin doit donc être strictement supérieure à 70.

for m in range(7, 71, 7):
    print(m)

Ce programme affiche 7, 14, …, 63, 70, soit 10 multiples. Avec range(7, 70, 7), 70 serait oublié.

Exercice 5 — Boucle while : tableau d'état

Moyen

On considère le programme suivant.

u = 3
n = 0
while u < 200:
    u = 3 * u - 2
    n = n + 1
print(n, u)

a) Construire le tableau d'état des variables u et n, en indiquant à chaque tour la valeur de la condition.
b) Qu'affiche le programme ?
c) On remplace la première ligne par u = 1. Expliquer ce qui se passe.

a) On teste la condition u < 200 avant chaque tour.

Étape	u	n	u < 200 ?
départ	3	0	vrai
tour 1	3 × 3 − 2 = 7	1	vrai
tour 2	3 × 7 − 2 = 19	2	vrai
tour 3	3 × 19 − 2 = 55	3	vrai
tour 4	3 × 55 − 2 = 163	4	vrai
tour 5	3 × 163 − 2 = 487	5	faux

Après le tour 5, 487 < 200 est faux : la boucle s'arrête.

b) Le programme affiche 5 487 : il a fallu 5 tours pour que u dépasse 200. Remarque : la dernière valeur, 487, dépasse largement 200, car la condition n'est testée qu'au début de chaque tour.

c) Avec u = 1 : 3 × 1 − 2 = 1. La valeur de u reste égale à 1 à chaque tour, donc la condition 1 < 200 reste toujours vraie. La boucle ne s'arrête jamais : c'est une boucle infinie, et le print n'est jamais atteint.

Exercice 6 — Écrire des fonctions

Moyen

a) Écrire une fonction moyenne3(a, b, c) qui renvoie la moyenne de trois nombres. Que renvoie moyenne3(12, 15, 9) ?
b) Écrire une fonction imc(masse, taille) qui renvoie l'indice de masse corporelle, égal à la masse (en kg) divisée par le carré de la taille (en m). Donner imc(58, 1.65) arrondi au dixième.
c) Écrire une fonction est_pair(n) qui renvoie True si l'entier n est pair et False sinon, sans utiliser de if.
d) Montrer que est_pair(-6) renvoie True.

a) La moyenne est la somme divisée par 3 ; les parenthèses sont indispensables, sinon seul c serait divisé.

def moyenne3(a, b, c):
    return (a + b + c) / 3

moyenne3(12, 15, 9) calcule (12 + 15 + 9) / 3 = 36 / 3 : elle renvoie 12.0 (un flottant, à cause de /).

def imc(masse, taille):
    return masse / taille ** 2

La puissance est calculée avant la division. 1,65² = 2,7225 et 58 / 2,7225 ≈ 21,304 : imc(58, 1.65) renvoie environ 21,3.

c) Un entier est pair lorsque le reste de sa division par 2 est nul. L'expression n % 2 == 0 est déjà un booléen : on peut la renvoyer directement.

def est_pair(n):
    return n % 2 == 0

d) −6 = 2 × (−3) + 0 : le reste de la division de −6 par 2 est 0, donc -6 % 2 vaut 0 et 0 == 0 vaut True. est_pair(-6) renvoie bien True.

Exercice 7 — Conditions composées : années bissextiles

Moyen

Une année est bissextile si elle est divisible par 4 mais pas par 100, ou si elle est divisible par 400.

a) Écrire une fonction bissextile(annee) qui renvoie True si l'année est bissextile et False sinon.
b) Donner, en justifiant, la valeur renvoyée pour 2028, 2100, 2000 et 2027.
c) Un élève propose return annee % 4 == 0. Expliquer l'erreur à l'aide d'un exemple.

a) « divisible par 4 » se traduit par annee % 4 == 0, « pas par 100 » par annee % 100 != 0. On combine avec and et or :

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

Les parenthèses rendent explicite l'ordre des tests.

b)
• 2028 = 4 × 507 : divisible par 4, et 2028 n'est pas divisible par 100 (le reste vaut 28). La première partie est vraie : True.
• 2100 est divisible par 4 et par 100, donc la première partie est fausse ; 2100 = 400 × 5 + 100, non divisible par 400 : False.
• 2000 = 400 × 5 : la seconde partie est vraie : True.
• 2027 = 4 × 506 + 3 : non divisible par 4, ni par 400 : False.

c) La fonction de l'élève renvoie True pour toute année divisible par 4. Pour 2100, elle renvoie True, alors que 2100 n'est pas bissextile (divisible par 100 mais pas par 400). L'élève a oublié l'exception des années séculaires.

Exercice 8 — Division euclidienne par soustractions successives

Difficile

Document 1 — Programme étudié.

def division(a, b):
    q = 0
    r = a
    while r >= b:
        r = r - b
        q = q + 1
    return q, r

La fonction renvoie deux valeurs, q et r. a et b sont des entiers positifs.
Document 2 — Mesures réalisées en classe avec b = 3.

a	Nombre de tours de boucle	Durée mesurée (ms)
3 000	1 000	0,07
30 000	10 000	0,7
300 000	100 000	7,1
3 000 000	1 000 000	70,4

1. Construire le tableau d'état de l'appel division(38, 9) et donner la valeur renvoyée.
2. Montrer qu'à la fin de l'exécution, on a toujours r < b, puis vérifier sur l'exemple de la question 1 que a = b × q + r.
3. À l'aide du document 2, décrire le lien entre a et le nombre de tours, puis entre a et la durée. Estimer la durée de division(3000000000, 3).
4. Expliquer ce qui se passe lors de l'appel division(25, 0).
5. Réécrire la fonction sans boucle, avec les opérateurs de Python, et expliquer l'intérêt de cette version.

1. On part de q = 0 et r = 38, et l'on retire 9 tant que r ≥ 9.

Étape	r	q	r ≥ 9 ?
départ	38	0	vrai
tour 1	29	1	vrai
tour 2	20	2	vrai
tour 3	11	3	vrai
tour 4	2	4	faux

La boucle s'arrête : la fonction renvoie (4, 2).

2. La boucle while ne s'arrête que lorsque sa condition r ≥ b devient fausse. Au moment du return, on a donc nécessairement r < b. Par ailleurs, chaque tour retire b à r et ajoute 1 à q, donc la quantité b × q + r ne change pas : elle vaut a au départ (q = 0, r = a) et reste égale à a. Vérification : 9 × 4 + 2 = 36 + 2 = 38. On a bien 38 = 9 × 4 + 2 avec 0 ≤ 2 < 9 : q et r sont le quotient et le reste de la division euclidienne.

3. Dans le document 2, le nombre de tours vaut a / 3, c'est-à-dire le quotient q : quand a est multiplié par 10, le nombre de tours est multiplié par 10. La durée est elle aussi multipliée par 10 environ (0,07 ; 0,7 ; 7,1 ; 70,4 ms) : la durée est proportionnelle au nombre de tours, soit environ 70,4 ms / 1 000 000 ≈ 70 nanosecondes par tour. Pour a = 3 000 000 000, soit 1 000 fois plus que la dernière ligne, il faut 1 000 000 000 tours et environ 70,4 ms × 1 000 ≈ 70 400 ms, soit environ 70 secondes.

4. Avec b = 0, l'instruction r = r − 0 ne modifie pas r, qui reste égal à 25. La condition 25 ≥ 0 est donc toujours vraie : la boucle est infinie et la fonction ne renvoie jamais de résultat. Cela correspond au fait que la division par 0 n'a pas de sens ; on devrait refuser b = 0 avant la boucle.

def division(a, b):
    return a // b, a % b

Python calcule directement le quotient (//) et le reste (%) : la durée ne dépend plus de la taille du quotient, alors que la version avec boucle demandait environ 70 s pour l'exemple de la question 3. Cette version est quasi instantanée ; avec b = 0, elle provoque une erreur explicite au lieu d'une boucle infinie.

Exercice 9 — Refroidissement d'un café : modèle et boucle while

Difficile

Un café versé à 80 °C refroidit dans une pièce à 20 °C. On le modélise ainsi : chaque minute, l'écart entre la température du café et celle de la pièce est multiplié par 0,95.
Document 1 — Programme.

T = 80
n = 0
while T >= 40:
    T = 20 + (T - 20) * 0.95
    n = n + 1
print(n, T)

Document 2 — Températures mesurées au thermomètre et valeurs du modèle.

Temps (min)	0	5	10	15	20
Mesure (°C)	80,0	66,1	56,2	47,5	41,8
Modèle (°C)	80,0	66,4	55,9	47,8	41,5

On donne

0, 95^{21} \approx 0, 3406

0, 95^{22} \approx 0, 3235

1. Expliquer pourquoi l'instruction T = 20 + (T - 20) * 0.95 traduit le modèle.
2. Calculer la valeur de T après le premier puis après le deuxième tour de boucle.
3. Justifier le choix d'une boucle while plutôt que d'une boucle for.
4. Le programme affiche 22 suivi d'une température proche de 39,4. Montrer que ce résultat est cohérent avec les données de l'énoncé, puis l'interpréter.
5. À l'aide du document 2, dire si le modèle est acceptable. Argumenter avec un calcul.
6. On remplace 40 par 15 dans la condition. Expliquer ce qui se passe.

1. T − 20 est l'écart entre la température du café et celle de la pièce. (T - 20) * 0.95 est le nouvel écart, multiplié par 0,95 ; en lui ajoutant 20, on obtient la nouvelle température. L'instruction calcule la température une minute plus tard, et n compte les minutes.

2. Tour 1 : T = 20 + (80 − 20) × 0,95 = 20 + 57 = 77 °C.
Tour 2 : T = 20 + (77 − 20) × 0,95 = 20 + 54,15 = 74,15 °C.

3. On cherche le nombre de minutes nécessaires pour que le café passe sous 40 °C : ce nombre est justement l'inconnue, on ne peut donc pas le mettre dans un range. On répète « tant que T ≥ 40 » : c'est une boucle non bornée.

4. Après n minutes, l'écart vaut 60 × 0,95ⁿ (il est multiplié par 0,95 à chaque minute), donc T = 20 + 60 × 0,95ⁿ.
Pour n = 21 : T ≈ 20 + 60 × 0,3406 ≈ 20 + 20,44 = 40,44 ≥ 40 : la boucle continue.
Pour n = 22 : T ≈ 20 + 60 × 0,3235 ≈ 20 + 19,41 = 39,41 < 40 : la boucle s'arrête.
Le programme affiche donc bien 22 et environ 39,4. Selon le modèle, le café passe sous 40 °C au bout de 22 minutes.

5. Écarts entre modèle et mesure : 66,4 − 66,1 = 0,3 ; 56,2 − 55,9 = 0,3 ; 47,8 − 47,5 = 0,3 ; 41,8 − 41,5 = 0,3 (et 0 au départ). L'écart maximal est de 0,3 °C, soit moins de 1 % de la température, de l'ordre de la précision d'un thermomètre courant. Le modèle est acceptable sur les 20 premières minutes.

6. T = 20 + 60 × 0,95ⁿ, et 60 × 0,95ⁿ est toujours positif : T reste strictement supérieur à 20 (en pratique, à cause des arrondis des flottants, il se bloque sur une valeur à peine supérieure à 20, environ 20.000000000000036, mais ne descend jamais en dessous). Physiquement, le café ne peut pas devenir plus froid que la pièce. La condition T ≥ 15 reste toujours vraie : la boucle est infinie et le programme n'affiche rien.

Exercice 10 — Somme des chiffres d'un entier

Difficile

Document 1 — Fonction étudiée.

def somme_chiffres(n):
    s = 0
    while n > 0:
        s = s + n % 10
        n = n // 10
    return s

Document 2 — Tests réalisés par un élève.

Appel	Résultat obtenu	Résultat attendu
`somme_chiffres(4071)`	12	12
`somme_chiffres(95)`	14	14
`somme_chiffres(0)`	0	0
`somme_chiffres(-38)`	0	11

1. Construire le tableau d'état des variables n et s pour l'appel somme_chiffres(4071).
2. Expliquer le rôle des expressions n % 10 et n // 10.
3. Expliquer le résultat anormal de la dernière ligne du document 2, puis proposer une correction de la fonction.
4. Un entier est divisible par 9 si et seulement si la somme de ses chiffres est divisible par 9. Écrire une fonction divisible_par_9(n) qui utilise somme_chiffres, et donner le résultat pour 4071.
5. Expliquer pourquoi une boucle for ne convient pas pour écrire somme_chiffres.

Étape	n % 10	s	n	n > 0 ?
départ	—	0	4071	vrai
tour 1	1	1	407	vrai
tour 2	7	8	40	vrai
tour 3	0	8	4	vrai
tour 4	4	12	0	faux

La fonction renvoie 12 = 4 + 0 + 7 + 1, conformément au document 2.

2. n % 10 est le reste de la division par 10, c'est-à-dire le chiffre des unités de n (4071 % 10 = 1). n // 10 est le quotient par 10 : il supprime le chiffre des unités (4071 // 10 = 407). À chaque tour, on ajoute le dernier chiffre à s puis on l'efface, jusqu'à ce qu'il ne reste plus de chiffre (n = 0).

3. Pour n = −38, la condition −38 > 0 est fausse dès le départ : la boucle ne s'exécute pas une seule fois et la fonction renvoie la valeur initiale s = 0. Correction : travailler sur la valeur absolue, en ajoutant au début de la fonction la ligne n = abs(n). Alors n = 38 et la fonction renvoie 8 + 3 = 11, le résultat attendu.

def divisible_par_9(n):
    return somme_chiffres(n) % 9 == 0

Pour 4071 : somme_chiffres(4071) = 12 et 12 = 9 × 1 + 3, le reste vaut 3 ≠ 0 : la fonction renvoie False. Vérification : 9 × 452 = 4068 et 4071 − 4068 = 3, donc 4071 n'est effectivement pas divisible par 9.

5. Une boucle for exige de connaître le nombre de tours avant de commencer. Ici, il y a un tour par chiffre, et ce nombre de chiffres dépend de n (4 pour 4071, 2 pour 95) : il n'est pas connu à l'avance. On répète « tant qu'il reste des chiffres », ce qui correspond à une boucle non bornée while.

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

Soutien scolaire à Marseille · Cours particuliers au lycée · Aide aux devoirs