Algorithmique et Python — cours de Première
Variables, types et affectation, Conditions et boucles, Fonctions, Listes Lecture ≈ 5 min.
1. Variables, types et affectation
Un algorithme est une suite finie et non ambiguë d'instructions. En Python, une variable reçoit une valeur avec =. Les types usuels sont int (entier), float (décimal approché), bool (booléen), str (texte) et list (liste).
x = 3
x = x + 1 # x vaut maintenant 4
y = 2.5
test = (x > 0) # booléen True
x = 4 affecte 4 à x ; x == 4 teste si x vaut 4. Les opérateurs de comparaison sont <, <=, >, >=, == et !=.
2. Conditions et boucles
if condition:
instructions
elif autre_condition:
autres_instructions
else:
instructions_finales
L'indentation délimite les blocs. Les connecteurs logiques sont and, or et not.
for k in range(n):répète un bloc pourkallant de 0 àn-1.while condition:répète tant que la condition est vraie. Il faut garantir que la condition finira par devenir fausse.
def somme_entiers(n):
s = 0
for k in range(1, n + 1):
s = s + k
return s
L'appel somme_entiers(100) renvoie 5050.
3. Fonctions
Une fonction regroupe un traitement réutilisable. Ses paramètres sont locaux et return renvoie le résultat.
def image_f(x):
return 2*x**2 - 5*x - 3
def discriminant(a, b, c):
return b**2 - 4*a*c
Prévoir des cas ordinaires, des cas limites et des valeurs dont le résultat est calculable à la main. Un test réussi ne prouve pas l'algorithme, mais un seul test échoué révèle une erreur.
4. Listes
Une liste ordonnée stocke plusieurs valeurs. Pour L = [4, 7, 1], L[0] vaut 4, len(L) vaut 3 et L.append(9) ajoute 9. Les indices commencent à 0.
L.remove(v)supprime la première occurrence de la valeurv; une erreur survient si elle est absente.L.pop(i)supprime et renvoie l'élément d'indicei. Sans argument,L.pop()retire le dernier élément.del L[i]supprime l'élément d'indicei;del L[a:b]supprime une tranche.
Exemple : avec L = [4, 7, 4], L.remove(4) supprime la première occurrence de la valeur 4 et donne [7, 4] ; en revanche, sur la liste initiale [4, 7, 4], L.pop(1) raisonne sur l'indice et retire donc la valeur 7, laissant [4, 4].
def moyenne(L):
total = 0
for valeur in L:
total = total + valeur
return total / len(L)
def ecart_type(L):
m = moyenne(L)
total = 0
for valeur in L:
total = total + (valeur - m)**2
return (total / len(L))**0.5
[k**2 for k in range(6)] construit [0, 1, 4, 9, 16, 25]. Cette notation compacte reste lisible pour des transformations simples.
5. Algorithmes sur les suites
def terme(n):
u = 100
for k in range(n):
u = 0.8*u + 10
return u
Après n passages, u contient bien un. C'est un invariant de boucle.
def premier_rang_seuil():
n = 0
u = 80
while u >= 5:
u = 0.75*u
n = n + 1
return n
La fonction renvoie 10. La boucle termine car la quantité positive est multipliée par 0,75 à chaque passage.
def termes(u0, a, b, n):
L = [u0]
u = u0
for k in range(n):
u = a*u + b
L.append(u)
return L
La liste contient n + 1 termes, du rang 0 au rang n.
6. Balayage et dichotomie
Pour repérer la première valeur où une fonction dépasse un seuil, on avance d'un pas fixé. Le résultat dépend de ce pas.
def balayage(f, seuil, debut, pas):
x = debut
while f(x) < seuil:
x = x + pas
return x
La justification rigoureuse suppose que f est continue sur [a ; b] et que f(a)f(b) ≤ 0. Il existe alors au moins une racine ; si f est en plus strictement monotone, elle est unique. On coupe l'intervalle en deux et garde une moitié où le produit des valeurs aux bornes est négatif ou nul. Le théorème de continuité garantissant l'existence est une anticipation de Terminale ; en Première, la dichotomie est surtout expérimentée sur des fonctions usuelles dont le graphique fait apparaître la racine.
def dichotomie(f, a, b, precision):
while b - a > precision:
m = (a + b) / 2
if f(a) * f(m) <= 0:
b = m
else:
a = m
return (a + b) / 2
7. Simulations probabilistes
random(), importée du module random, fournit un nombre décimal dans [0 ; 1[. L'événement random() < p simule un succès de probabilité p.
from random import random
def bernoulli(p):
if random() < p:
return 1
return 0
def frequence(p, n):
succes = 0
for k in range(n):
succes = succes + bernoulli(p)
return succes / n
from random import randint
def moyenne_de(n):
total = 0
for k in range(n):
total = total + randint(1, 6)
return total / n
def echantillons(n, repetitions):
L = []
for k in range(repetitions):
L.append(moyenne_de(n))
return L
Pour un dé équilibré, μ = 3,5 et σ = √3512 ≈ 1,708. On peut compter dans L les moyennes comprises entre 3,5 − 2σ/√n et 3,5 + 2σ/√n, puis recommencer avec plusieurs tailles.
8. Approcher l'exponentielle : expérimentation
L'équation y' = y, y(0) = 1, suggère que sur un petit pas h, la valeur augmente d'environ hy. Le programme suivant approche ex :
def expo_euler(x, n):
h = x / n
y = 1
for k in range(n):
y = y + h*y
return y
Pour x = 1, augmenter n donne des valeurs qui se rapprochent de e. Cette expérimentation ne remplace pas la définition mathématique et l'erreur n'est pas étudiée formellement en Première.
9. Erreurs fréquentes
- Oublier les deux-points ou l'indentation après
if,for,whileoudef. - Utiliser
=à la place de==dans un test. - Écrire
range(n)en croyant obtenir 1, ..., n. - Accéder à
L[len(L)]: le dernier indice estlen(L)-1. - Créer une boucle
whiledont aucune variable ne modifie la condition. - Confondre résultats flottants et valeurs exactes ;
0.1 + 0.2peut ne pas s'afficher exactement comme 0,3.