Fiche ultra-synthèse — Algorithmique & programmation (Python) — 2nde
Variables • affectation • tests • boucles • fonctions simples • listes • simulation.
Objectif : zéro piège + méthodes rapides (niveau solide / 2nde+).
Essentiel (à savoir par cœur)
1 Variables & types
Une variable est un nom qui stocke une valeur (et un type).
Types usuels : int (entier), float (réel),
bool (True/False), str (texte), list (liste).
Exemples :
n = 12 # int
x = 3.5 # float
ok = (n % 2 == 0) # bool
nom = "Basil" # str
L = [12, 15, 9] # list
Piège : input() renvoie toujours du texte (str) ⇒ penser à int() / float().
2 Affectation (=) vs test (==)
| Écriture | Sens |
|---|---|
| x = 7 | je stocke 7 dans x (affectation) |
| x == 7 | je teste “x vaut 7 ?” (Vrai/Faux) |
| x = x + 1 | j’incrémente x (nouveau x) |
Exemple (suite) : \(u_{n+1}=2u_n-3\)
u = u0
for k in range(n):
u = 2*u - 3
# u contient u_n
3 Tests (if / elif / else)
Comparaisons : == != <
<= > >=
Logique : and (ET), or (OU), not (NON)
# Exemple : x ∈ [0 ; 1] ?
if (x >= 0) and (x <= 1):
print("x appartient à [0 ; 1]")
else:
print("x n'appartient pas à [0 ; 1]")
Ordre des tests : mettre d’abord le cas le plus précis.
Exemple : “multiple de 6” avant “pair”.
4 Boucles (for / while)
for : nombre d’itérations connu (compteur).
while : on répète tant qu’une condition est vraie (arrêt par seuil).
while : on répète tant qu’une condition est vraie (arrêt par seuil).
# for : k = 0..n-1
for k in range(n):
...
# for : k = 1..n
for k in range(1, n+1):
...
# while : attention boucle infinie si rien ne change !
while condition:
...
Piège off-by-one : range(n) finit à \(n-1\).
Méthodes (procédures rapides 20/20)
A Somme / moyenne (stats)
- Initialiser : S = 0
- Parcourir : ajouter chaque valeur
- Moyenne : S / n (si \(n>0\))
L = [12, 15, 9, 18]
S = 0
for x in L:
S = S + x
moy = S / len(L) # ici len(L)=4
Cas limite : liste vide ⇒ éviter division par 0.
B Compter & fréquence
Pour estimer une proba par simulation :
compter le nombre de succès \(c\) sur \(N\) essais puis fréquence \(f=\dfrac{c}{N}\).
N = 10000
c = 0
for i in range(N):
# simuler une expérience
# si succès : c = c + 1
...
f = c / N
Interprétation : \(f\) est proche de \(p\) si \(N\) est grand (mais il y a toujours une fluctuation).
C Recherche “par seuil” (while)
- Initialiser une valeur
- Répéter tant que le seuil n’est pas atteint
- Mettre à jour pour garantir l’arrêt
# Plus petit k tel que 1 + 1/2 + ... + 1/k > 4
k = 0
S = 0.0
while S <= 4:
k = k + 1
S = S + 1.0/k
Sans mise à jour de k ou de S ⇒ boucle infinie.
D Fonctions (propre + testable)
Idée : écrire un bloc réutilisable avec une entrée et une sortie.
def frequence(L, a):
if len(L) == 0:
return 0.0
c = 0
for x in L:
if x == a:
c = c + 1
return c / len(L)
Contrôle rapide : si L=[2,2,3] et a=2, alors fréquence = \(2/3\).
Pièges classiques (à éviter)
1 “=“ vs “==“
x = 5 stocke 5.
x == 5 teste (Vrai/Faux).
Bug typique : vouloir tester mais écraser la variable.
x == 5 teste (Vrai/Faux).
Bug typique : vouloir tester mais écraser la variable.
2 Indentation
En Python, l’indentation définit les blocs (if, for, while).
Mauvaise indentation ⇒ programme différent de celui imaginé.
Mauvaise indentation ⇒ programme différent de celui imaginé.
3 Off-by-one (bornes)
range(n) donne \(0,1,\dots,n-1\).
Pour \(1..n\) : range(1, n+1).
Pour \(1..n\) : range(1, n+1).
4 Boucle infinie
Dans un while, il faut changer quelque chose à chaque tour pour sortir.
Exemple : incrémenter un compteur, diminuer une quantité, etc.
5 Types (input)
input() retourne une chaîne (str).
"2" + "3" donne "23".
Solution : int(input(...)).
"2" + "3" donne "23".
Solution : int(input(...)).
6 Simulation trop petite
Si \(N\) est faible, la fréquence varie beaucoup.
Pour stabiliser : augmenter \(N\) (ex : 10 000, 50 000).
Réflexe : tester sur des petits cas, puis sur un cas limite, puis sur un cas “grand”.
Un programme fiable = un programme testé.
Mini-tests (30 secondes chacun) — corrigés
Q1 Type
Que vaut type(3) ? et type(3.0) ?
Corrigé : int puis float.
Q2 Reste
Calculer 17 % 5 et interpréter.
Corrigé : 2 (car \(17=5\times 3 + 2\)).
Q3 Condition
Écrire le test : “\(x\in[-2 ; 5[\)”
Corrigé : (x >= -2) and (x < 5).
Q4 Boucle
Combien d’itérations : for k in range(3, 8) ?
Corrigé : 5 itérations (k = 3,4,5,6,7).
Q5 Somme
Compléter pour calculer \(1+2+\cdots+n\).
Corrigé : for k in range(1, n+1) et ajouter k à S.
Q6 Simulation
À quoi sert c / N dans une simulation ?
Corrigé : c’est la fréquence observée, estimation de la probabilité.
BONUS Mini-simulation prête à l’emploi : “au moins un 6 en 4 lancers”
import random
N = 50000
c = 0
for i in range(N):
ok = False
for k in range(4):
d = random.randint(1, 6)
if d == 6:
ok = True
if ok:
c = c + 1
print(c / N)
Vérification théorique (proba contraire) : \(1-\left(\dfrac{5}{6}\right)^4\).
Checklist (avant contrôle)
Je sais faire
- Définir des variables et comprendre leurs types.
- Utiliser l’affectation (=) et tester (==).
- Écrire un if/elif/else sans oublier l’indentation.
- Choisir for (compteur) ou while (seuil) et éviter les boucles infinies.
- Parcourir une liste, calculer somme/moyenne/fréquence.
- Faire une simulation : compteur \(c\), essais \(N\), fréquence \(c/N\).
Réflexes 20/20
1) Toujours initialiser (somme, compteur, booléen…).
2) Toujours tester : petits cas + cas limite + cas “grand”.
3) Toujours vérifier les bornes de boucle (range).
4) En simulation : \(N\) assez grand + interpréter la fluctuation.
2) Toujours tester : petits cas + cas limite + cas “grand”.
3) Toujours vérifier les bornes de boucle (range).
4) En simulation : \(N\) assez grand + interpréter la fluctuation.
À bannir : oublier int() / float(),
confondre = et ==,
boucle while sans mise à jour,
“range” mal borné.