Niveau 2ⁿᵈᵉ · Cours
🎯 À la fin de ce chapitre, je sais : utiliser des variables et une instruction conditionnelle · écrire une boucle for et une boucle while · définir et appeler une fonction · simuler une expérience aléatoire avec le module random.
Au collège, tu as programmé avec des blocs (Scratch). En seconde, on écrit les mêmes idées en Python : les instructions sont les mêmes, seule l'écriture change.
Un algorithme est une suite d'instructions exécutées dans l'ordre, du haut vers le bas.
Un programme donne toujours le même résultat pour les mêmes données d'entrée — sauf s'il utilise le hasard.
Programmer, c'est décrire précisément les étapes d'un calcul.
En Python, l'INDENTATION (le décalage à droite) indique ce qui est à l'intérieur d'un bloc.
Un magasin applique 10 % de remise à partir de 50 € d'achat. Écrire ce calcul une fois pour toutes, c'est stocker le montant dans une VARIABLE, puis TESTER s'il dépasse le seuil.
Une VARIABLE est un nom qui désigne une valeur stockée en mémoire. L'AFFECTATION s'écrit avec un simple signe égal : prix = 60 met la valeur 60 dans la variable prix.
Les principaux TYPES sont : int (entier), float (nombre décimal), bool (True ou False) et str (chaîne de caractères).
Une INSTRUCTION CONDITIONNELLE exécute un bloc seulement si un test est vrai : if condition: … else: …
prix = 60
if prix >= 50:
prix_final = prix * 0.9
else:
prix_final = prix
print(prix_final)Méthode — lire un programme conditionnel.
1) Je note la valeur de chaque variable au départ : prix vaut 60.
2) J'évalue le test : 60 >= 50 est vrai.
3) J'exécute le bloc correspondant : prix_final vaut 60 × 0,9 = 54. Le programme affiche 54.
Contre-exemple : le signe = n'est pas le signe égal des mathématiques.
En Python, x = x + 1 n'est pas une équation impossible : c'est une AFFECTATION qui remplace la valeur de x par l'ancienne augmentée de 1. Le test d'égalité, lui, s'écrit avec deux signes égal : ==.
Affectation : nom = valeur. Test d'égalité : ==.
if condition: … else: … — les deux-points et l'indentation délimitent le bloc.
Question 1 — Qu'affiche le programme du cours si prix vaut 60 ?
Question 2 — Comment teste-t-on l'égalité de deux valeurs en Python ?
Question 3 — Que vaut x après les instructions x = 5 puis x = x + 3 ?
Calculer la somme des 100 premiers entiers à la main est long ; écrire 100 lignes de programme aussi. La boucle répète une instruction autant de fois qu'il le faut, sans la réécrire.
Une BOUCLE BORNÉE (for) répète un bloc un nombre de fois connu à l'avance : for i in range(n): répète n fois, avec i qui prend les valeurs 0, 1, …, n − 1.
Une BOUCLE NON BORNÉE (while) répète un bloc TANT QU'une condition reste vraie : le nombre de répétitions n'est pas connu à l'avance.
# Boucle bornée : somme des entiers de 1 a n
somme = 0
for i in range(1, n + 1):
somme = somme + i
# Boucle non bornee : plus petit n tel que 2**n depasse 1000
n = 0
while 2**n <= 1000:
n = n + 1Méthode — choisir sa boucle.
1) Si je connais le nombre de répétitions, j'utilise for.
2) Si je répète jusqu'à ce qu'une condition soit atteinte, j'utilise while.
3) Dans une boucle while, je vérifie que la variable du test change à chaque tour, sinon la boucle ne s'arrête jamais.
range(1, 5) parcourt 1, 2, 3, 4 : la borne de gauche est incluse, celle de droite est EXCLUE.
C'est pourquoi on écrit range(1, n + 1) pour aller jusqu'à n inclus.
Contre-exemple : la boucle while 2**n <= 1000 sans la ligne n = n + 1 tourne indéfiniment.
La condition ne changerait jamais : le programme resterait bloqué. Toute boucle non bornée doit faire progresser son test.
for : nombre de tours connu · while : répétition sous condition.
range(a, b) : de a inclus à b EXCLU.
Question 1 — Combien de tours effectue la boucle for i in range(5) ?
Question 2 — Quelles valeurs parcourt range(1, 5) ?
Question 3 — Quelle boucle utiliser pour chercher le plus petit n tel que 2 puissance n dépasse 1000 ?
Si tu dois calculer l'aire de dix rectangles différents, tu ne vas pas réécrire dix fois le même calcul. Une fonction Python l'écrit une seule fois, et on la RÉUTILISE autant qu'on veut.
Une FONCTION Python se définit avec def nom(arguments): et renvoie une valeur avec l'instruction return.
Les ARGUMENTS sont les données d'entrée ; la valeur renvoyée est le résultat. On APPELLE la fonction en écrivant son nom suivi des valeurs choisies entre parenthèses.
def aire(longueur, largeur):
return longueur * largeur
def moyenne(notes):
total = 0
for note in notes:
total = total + note
return total / len(notes)
print(aire(5, 3)) # affiche 15
print(moyenne([12, 14, 16])) # affiche 14.0Méthode — écrire une fonction.
1) Je choisis un nom parlant et je liste les données nécessaires : def aire(longueur, largeur).
2) J'écris le calcul dans le bloc indenté.
3) Je termine par return, qui renvoie le résultat à qui a appelé la fonction.
Contre-exemple : une fonction sans return ne renvoie rien.
Si on remplace return par print, la valeur s'affiche mais ne peut plus être réutilisée dans un calcul : aire(5, 3) * 2 provoquerait alors une erreur.
L'appel doit respecter l'ORDRE des arguments : aire(5, 3) donne 15, et aire(3, 5) aussi.
Mais pour une fonction comme puissance(base, exposant), l'ordre change tout : 2**3 = 8 alors que 3**2 = 9.
def nom(arguments): … return résultat — puis on appelle nom(valeurs).
return renvoie une valeur réutilisable ; print se contente de l'afficher.
Question 1 — Que renvoie l'appel aire(5, 3) avec la fonction du cours ?
Question 2 — Quel mot-clé permet de renvoyer un résultat ?
Question 3 — Que se passe-t-il si une fonction n'a pas de return ?
Pour vérifier qu'un jeu est équitable, mieux vaut le simuler 10 000 fois que d'y jouer un après-midi entier. Le module random fournit le hasard dont le programme a besoin.
Le module random fournit des fonctions de tirage aléatoire. randint(a, b) renvoie un entier compris entre a et b, BORNES INCLUSES ; random() renvoie un décimal de l'intervalle [0 ; 1[.
Pour estimer une probabilité, on répète l'expérience un grand nombre de fois et on calcule la FRÉQUENCE des succès.
from random import randint
def lance_deux_des():
return randint(1, 6) + randint(1, 6)
def frequence_de_7(n):
succes = 0
for i in range(n):
if lance_deux_des() == 7:
succes = succes + 1
return succes / nMéthode — simuler une expérience.
1) J'écris une fonction qui réalise UNE expérience.
2) J'écris une seconde fonction qui la répète n fois et compte les succès.
3) Je renvoie la fréquence, c'est-à-dire succes / n. Pour la somme 7 avec deux dés, on obtient environ 0,167, ce qui correspond à 6/36.
Contre-exemple : deux appels de frequence_de_7(1000) ne donnent pas le même nombre.
C'est attendu : le résultat dépend du hasard. Seul l'ordre de grandeur se stabilise quand n augmente.
randint(a, b) : entier de a à b, bornes incluses. random() : décimal dans [0 ; 1[.
Fréquence estimée = nombre de succès / nombre de répétitions.
Question 1 — Que peut renvoyer randint(1, 6) ?
Question 2 — Dans frequence_de_7, que représente succes / n ?
Question 3 — Quelle ligne faut-il écrire avant d'utiliser randint ?
Ton mémo complet est dans l’encadré « Mémo ». Prêt·e pour les défis ?