Que faut-il savoir faire en Python en seconde SNT ?

En SNT de seconde, on attend de savoir utiliser des variables et des affectations, les types de base (entier, flottant, chaîne, booléen), les instructions conditionnelles if, elif, else, les boucles bornées (for) et non bornées (while), et définir puis appeler des fonctions. Il faut aussi savoir lire un programme court et prévoir ce qu'il affiche.

Quelle est la différence entre une boucle for et une boucle while en Python ?

La boucle for est une boucle bornée : on connaît à l'avance le nombre de répétitions, par exemple for i in range(10) répète 10 fois. La boucle while est non bornée : elle répète tant qu'une condition est vraie, et on ne sait pas d'avance combien de tours elle fera. Avec while, il faut vérifier que la condition finit par devenir fausse, sinon la boucle est infinie.

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

Le signe = est l'affectation : x = 3 donne la valeur 3 à la variable x. Le signe == est une comparaison : x == 3 vaut True si x est égal à 3, False sinon. Dans un if ou un while, on utilise toujours ==.

À quoi sert une fonction en Python ?

Une fonction regroupe des instructions sous un nom, pour les réutiliser sans les réécrire. On la définit avec def, elle reçoit des paramètres et renvoie un résultat avec return. Par exemple, def carre(x): return x * x permet d'écrire carre(9) pour obtenir 81.

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

print affiche une valeur à l'écran mais ne la transmet pas au reste du programme. return renvoie la valeur au programme qui a appelé la fonction, qui peut alors la stocker dans une variable ou la réutiliser dans un calcul. Une fonction sans return renvoie la valeur spéciale None.

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

Ce cours de sciences numériques et technologie (SNT) en seconde sur « Programmation en Python » suit le programme officiel de sciences numériques et technologie (SNT) 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 : L'essentiel : variables, affectations, types, Opérations, conversions et saisie, Instructions conditionnelles, Boucles bornées et non bornées. 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 sciences numériques et technologie (SNT).

L'essentiel : variables, affectations, types

Variable et affectation. Une variable est un nom qui désigne une valeur rangée en mémoire. L'instruction x = 7 est une affectation : elle se lit « x prend la valeur 7 ». Le signe = n'est pas une égalité mathématique : x = x + 1 signifie « la nouvelle valeur de x est l'ancienne plus 1 ».

Les quatre types de base.

Type	Nom	Exemples
`int`	entier	`12`, `-3`
`float`	flottant (nombre à virgule)	`3.5`, `-0.25`
`str`	chaîne de caractères	`'SNT'`, `'42'`
`bool`	booléen	`True`, `False`

En Python, la virgule décimale s'écrit avec un point : 3.5.

Séquence et blocs. Les instructions s'exécutent dans l'ordre, de haut en bas. Après une ligne terminée par : (if, for, while, def), le bloc qui suit est indenté de 4 espaces : c'est l'indentation, et elle seule, qui délimite le bloc.

Exemple.

a = 5
b = a + 2
a = b * 3

Ligne 2 : b prend la valeur 5 + 2 = 7. Ligne 3 : a prend la valeur 7 × 3 = 21 ; l'ancienne valeur 5 est écrasée. À la fin, a = 21 et b = 7.

Opérations, conversions et saisie

Opérateurs sur les nombres.

Opérateur	Rôle	Exemple	Résultat
`+ - *`	somme, différence, produit	`6 * 4`	`24`
`/`	division décimale	`17 / 4`	`4.25`
`//`	quotient entier	`17 // 4`	`4`
`%`	reste de la division	`17 % 4`	`1`
`**`	puissance	`2 ** 5`	`32`

La division / renvoie toujours un flottant : 10 / 2 vaut 5.0.

Opérations sur les chaînes. + met bout à bout deux chaînes (concaténation) : 'Bon' + 'jour' donne 'Bonjour'. * répète une chaîne : 'ab' * 3 donne 'ababab'.

Saisie et conversions. input('message') affiche le message et renvoie ce que l'utilisateur tape, toujours sous forme de chaîne. On convertit avec int(), float() ou str() : int('12') vaut 12, str(8) vaut '8', int(6.7) vaut 6 (la partie décimale est supprimée, sans arrondi).

Exemple.

prenom = input('Prénom ? ')
annee = int(input('Année de naissance ? '))
print('Bonjour ' + prenom)
print(2026 - annee)

Sans int, la soustraction 2026 - annee provoquerait une erreur, car on ne soustrait pas une chaîne d'un entier.

Astuce. type(x) affiche le type de x : pratique pour comprendre une erreur de type.

Instructions conditionnelles

Structure if / elif / else.

if condition1:
    bloc exécuté si condition1 est vraie
elif condition2:
    bloc exécuté si condition1 est fausse et condition2 vraie
else:
    bloc exécuté si aucune condition n'est vraie

Les conditions sont testées dans l'ordre ; seul le premier bloc dont la condition est vraie est exécuté. elif et else sont facultatifs.

Comparaisons et opérateurs logiques. Une condition est un booléen. Comparaisons : == (égal), != (différent), <, <=, >, >=. On combine avec and (les deux vraies), or (au moins une vraie), not (contraire).

Exemple.

note = 13.5
if note >= 14:
    print('Bien')
elif note >= 10:
    print('Admis')
else:
    print('Non admis')

13,5 ≥ 14 est faux ; 13,5 ≥ 10 est vrai : le programme affiche Admis, puis ignore le else.

Test de divisibilité. « n est pair » s'écrit n % 2 == 0 : le reste de la division par 2 est nul.

Boucles bornées et non bornées

Boucle bornée : for. for i in range(n): répète le bloc n fois ; i prend successivement les valeurs 0, 1, …, n − 1. Variantes : range(a, b) donne a, a + 1, …, b − 1 (b exclu) ; range(a, b, p) avance de p en p.

Exemple : somme des entiers de 1 à 6.

s = 0
for k in range(1, 7):
    s = s + k

k prend les valeurs 1 à 6 ; s vaut successivement 1, 3, 6, 10, 15, 21.

Boucle non bornée : while. while condition: répète le bloc tant que la condition est vraie. La condition est testée avant chaque tour ; le nombre de tours n'est pas connu à l'avance. Le bloc doit modifier une variable de la condition, sinon la boucle ne s'arrête jamais (boucle infinie).

Exemple : placement à 3 % par an. On place 500 € ; au bout de combien d'années dépasse-t-on 600 € ?

c = 500
n = 0
while c <= 600:
    c = c * 1.03
    n = n + 1
print(n)

Après 6 ans, c ≈ 597,03 ≤ 600 : on continue. Après 7 ans, c ≈ 614,94 : la condition devient fausse. Le programme affiche 7.

Fonctions

Définition et appel.

def nom_fonction(parametre1, parametre2):
    instructions
    return resultat

def définit la fonction (rien n'est calculé à ce moment) ; l'appel nom_fonction(valeur1, valeur2) exécute le bloc avec ces valeurs, appelées arguments. return renvoie le résultat et termine la fonction.

Exemple.

def perimetre_rectangle(L, l):
    return 2 * (L + l)

p = perimetre_rectangle(4.5, 3)

L'appel calcule 2 × (4,5 + 3) = 15 : la variable p vaut 15.0 (flottant, car 4.5 est un flottant).

print ou return ? print affiche à l'écran, pour l'utilisateur. return transmet la valeur au programme, qui peut la stocker ou la réutiliser. Une fonction sans return renvoie None.

Variables locales. Les paramètres et les variables créées dans une fonction n'existent que pendant son exécution : on ne peut pas les utiliser après l'appel.

Méthodes

Méthode 1 — Prévoir le résultat d'un programme (tableau d'état)

Faire un tableau avec une colonne par variable (et une colonne pour la condition si besoin).
Exécuter le programme ligne par ligne, en écrivant une nouvelle ligne du tableau à chaque modification.
Pour une boucle, écrire une ligne par tour ; pour un while, tester la condition avant chaque tour.
Conclure en donnant les valeurs finales et ce qui est affiché.

Exemple rédigé.

x = 3
for i in range(3):
    x = 2 * x - 1

Étape	i	x
départ	—	3
tour 1	0	2 × 3 − 1 = 5
tour 2	1	2 × 5 − 1 = 9
tour 3	2	2 × 9 − 1 = 17

range(3) donne 3 tours : à la fin, x = 17.

Méthode 2 — Choisir entre for et while

Se demander si le nombre de répétitions est connu avant de commencer.
Si oui : boucle for avec range.
Si non (on répète « jusqu'à ce que… ») : boucle while, dont la condition est le contraire de la condition d'arrêt.
Initialiser les variables avant la boucle, et vérifier que la condition finit par devenir fausse.

Exemple rédigé. Une culture compte 40 bactéries et double chaque heure. Combien d'heures pour dépasser 1 000 ? On ignore le nombre de tours : boucle while. On s'arrête quand b > 1000, donc on continue tant que b <= 1000.

b = 40
h = 0
while b <= 1000:
    b = 2 * b
    h = h + 1

b vaut 80, 160, 320, 640, puis 1 280 > 1 000 : h = 5 heures.

Méthode 3 — Écrire une fonction

Choisir un nom explicite et repérer les données nécessaires : ce seront les paramètres.
Écrire la ligne def nom(parametres):.
Écrire le calcul dans le bloc indenté, puis return du résultat.
Tester avec un appel dont on connaît le résultat.

Exemple rédigé. Prix TTC avec une TVA de 20 % : le seul paramètre est le prix hors taxe.

def prix_ttc(ht):
    return ht * 1.2

Test : prix_ttc(35) renvoie 35 × 1,2 = 42.0, ce qui est bien le résultat attendu.

Pièges et erreurs classiques

= au lieu de ==. if x = 4: provoque une erreur de syntaxe : dans une condition, on compare avec ==.

range s'arrête avant la borne. range(5) donne 0, 1, 2, 3, 4 (5 valeurs, sans 5) ; range(1, 5) donne 1, 2, 3, 4.

input renvoie une chaîne. Si l'on tape 3 puis 4, input() + input() donne '34' et non 7 : il faut convertir avec int ou float.

Deux-points et indentation. Oublier le : après if, for, while ou def, ou mal indenter, provoque une erreur ou change le sens du programme : une ligne sortie du bloc n'est plus répétée.

Boucle infinie. Un while dont le bloc ne modifie pas la condition, ou dont la condition ne peut jamais devenir fausse, ne s'arrête pas.

print n'est pas return. Une fonction qui affiche son résultat sans le renvoyer donne None au programme appelant.

Flottants approchés. 0.1 + 0.2 == 0.3 vaut False, car les flottants sont stockés de façon approchée : on évite de tester l'égalité de deux flottants.

En bref

x = valeur affecte ; == compare.
Types : int, float, str, bool ; input renvoie une chaîne, à convertir.
// quotient entier, % reste, / division décimale (toujours un flottant).
if … elif … else : seul le premier cas vrai est exécuté.
for i in range(n) : n tours, i de 0 à n − 1 (boucle bornée).
while condition : répète tant que la condition est vraie (boucle non bornée) ; attention aux boucles infinies.
def f(parametres): … return resultat ; return renvoie, print affiche.

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