Algorithmique et programmation Python en 2nde
Cours complet, points clés à retenir et exercices d'entraînement de algorithmique et programmation python pour les élèves de 2nde. Conforme au programme officiel.
Réviser notion par notion
Ce que tu vas réviser
- Variables, affectation, types (int, float, str, bool)
- Instructions conditionnelles (if, elif, else)
- Boucles bornées (for) et non bornées (while)
- Fonctions : définition, paramètres, return, appel
- Fonction renvoyant un nombre aléatoire ; répéter une expérience aléatoire
- Lire une fonction qui calcule une moyenne ou un écart type
Variables, affectation et types
Une variable est un nom qui désigne une valeur rangée en mémoire. L'affectation, écrite avec le signe =, donne une valeur à une variable : le signe = signifie « ranger dans », ce n'est pas une égalité mathématique. Les quatre types à connaître sont int (nombre entier), float (nombre à virgule, écrit avec un point en Python), str (chaîne de caractères, entre guillemets) et bool (booléen : True ou False).
Exemple
prix = 12.5 (float) ; quantite = 3 (int) ; total = prix * quantite donne 37.5 (float) ; nom = "Léa" (str) ; cher = total > 30 donne True (bool). Après n = 4 puis n = n + 1, la variable n vaut 5.
À retenir : On calcule d'abord la valeur à droite du signe =, puis on la range dans la variable à gauche.
Instructions conditionnelles : if, elif, else
Une instruction conditionnelle exécute un bloc d'instructions seulement si une condition est vraie. if (si) teste une première condition, elif (sinon si) en teste une autre si la précédente est fausse, else (sinon) traite tous les cas restants. Les blocs sont repérés par l'indentation (décalage vers la droite) et la ligne de test se termine par deux-points.
Exemple
Pour l'eau à la pression atmosphérique, selon sa température t (en °C) : ```python if t < 0: etat = "glace" elif t < 100: etat = "liquide" else: etat = "vapeur" ``` Avec t = 25, la première condition est fausse, la deuxième est vraie : etat vaut "liquide".
À retenir : Les conditions sont testées dans l'ordre et seul le premier bloc dont la condition est vraie est exécuté. Pour tester une égalité, on écrit == (et non =).
Boucles bornées (for) et non bornées (while)
Une boucle for répète un bloc un nombre de fois connu à l'avance : for i in range(n) répète n fois, i prenant les valeurs 0, 1, ..., n − 1 (et range(a, b) donne a, ..., b − 1). Une boucle while répète un bloc tant qu'une condition est vraie : on l'utilise quand on ne connaît pas à l'avance le nombre de répétitions.
Exemple
Somme des entiers de 1 à 10 avec for : ```python s = 0 for i in range(1, 11): s = s + i ``` À la fin, s vaut 55. Nombre d'années pour qu'un capital de 1 000 € placé à 5 % par an dépasse 1 500 € avec while : ```python c = 1000 n = 0 while c <= 1500: c = c * 1.05 n = n + 1 ``` À la fin, n vaut 9 (après 8 ans, le capital vaut environ 1 477,46 € ; après 9 ans, environ 1 551,33 €).
À retenir : for : nombre de répétitions connu ; while : on répète tant que la condition est vraie (attention à ce qu'elle finisse par devenir fausse).
Fonctions : définition, paramètres, return, appel
Une fonction se définit avec def, suivi de son nom et de ses paramètres entre parenthèses, puis de deux-points ; le bloc indenté contient les instructions, et return renvoie le résultat. On l'appelle en écrivant son nom suivi des valeurs des paramètres.
Exemple
```python def f(x): return 3*x**2 - 1 def aire_rectangle(longueur, largeur): return longueur * largeur ``` L'appel f(2) renvoie 3 × 4 − 1 = 11 et aire_rectangle(5, 3) renvoie 15.
À retenir : return renvoie une valeur qu'on peut réutiliser (dans un calcul, une variable) et termine la fonction ; print se contente d'afficher.
Fonction renvoyant un nombre aléatoire ; répéter une expérience
Le module random fournit des fonctions qui renvoient des nombres au hasard : randint(a, b) renvoie un entier au hasard entre a et b (inclus), chaque entier ayant la même probabilité ; random() renvoie un nombre à virgule au hasard dans [0 ; 1[. En appelant une telle fonction dans une boucle, on répète une expérience aléatoire et on obtient une série statistique (par exemple une fréquence).
Exemple
```python from random import randint def frequence_six(n): compteur = 0 for i in range(n): if randint(1, 6) == 6: compteur = compteur + 1 return compteur / n ``` frequence_six(1000) simule 1 000 lancers de dé et renvoie la fréquence des 6 : une valeur proche de $\frac{1}{6} \approx 0{,}167$, différente à chaque exécution.
À retenir : from random import randint (ou random) doit figurer au début du programme ; deux exécutions donnent en général des résultats différents.
Lire une fonction qui calcule une moyenne ou un écart type
Il faut savoir lire et comprendre une fonction qui calcule la moyenne ou l'écart type d'une série (ici donnée sous forme de liste, qu'on se contente de parcourir). La moyenne est la somme des valeurs divisée par leur nombre ; l'écart type est la racine carrée de la moyenne des carrés des écarts à la moyenne.
Exemple
```python from math import sqrt def moyenne(serie): s = 0 for x in serie: s = s + x return s / len(serie) def ecart_type(serie): m = moyenne(serie) s = 0 for x in serie: s = s + (x - m)**2 return sqrt(s / len(serie)) ``` Pour la série 8, 10, 12 : la moyenne vaut 10, les carrés des écarts valent 4, 0 et 4, donc l'écart type vaut $\sqrt{\frac{8}{3}} \approx 1{,}63$.
À retenir : Dans ces fonctions, la variable s est un accumulateur : elle vaut 0 au départ et on lui ajoute une quantité à chaque tour de boucle ; len(serie) est le nombre de valeurs.
Les points clés
- Le signe = est une affectation : la valeur de droite est rangée dans la variable de gauche
- Types : int (entier), float (nombre à virgule), str (texte), bool (True ou False)
- if / elif / else : seul le premier bloc dont la condition est vraie est exécuté ; == teste l'égalité
- for : nombre de répétitions connu à l'avance ; while : répétition tant qu'une condition est vraie
- Une fonction se définit avec def et renvoie son résultat avec return
- randint(a, b) renvoie un entier au hasard entre a et b inclus ; random() un nombre au hasard dans [0 ; 1[
- Moyenne et écart type se calculent avec une boucle et un accumulateur
L'essentiel
Un programme Python combine des variables typées, des conditions (if, elif, else), des boucles (for, while) et des fonctions (def, return). Avec le module random, on simule des expériences aléatoires, et on sait lire les fonctions qui calculent la moyenne et l'écart type d'une série.
Exercices d'entraînement
Entraîne-toi sur ces exercices, puis fais-toi corriger pas à pas par le tuteur.
Exercice 1
On considère la fonction suivante (k % 2 donne le reste de la division de k par 2) : ```python def mystere(n): s = 0 k = 1 while k <= n: if k % 2 == 0: s = s + k k = k + 1 return s ``` 1) Que renvoie mystere(6) ? Détaille l'exécution. 2) Que calcule cette fonction en général ?
Corrige cet exercice avec le tuteur →Exercice 2
1) Écris une fonction somme_deux_des() qui simule le lancer de deux dés équilibrés (avec randint) et renvoie la somme obtenue. 2) Écris une fonction frequence_sept(n) qui répète n fois cette expérience et renvoie la fréquence des sommes égales à 7. 3) Sachant que la probabilité d'obtenir une somme égale à 7 est $\frac{6}{36}$, de quelle valeur la fréquence renvoyée devrait-elle être proche quand n est grand ?
Corrige cet exercice avec le tuteur →