Algorithmique et Python en Première spé : cours complet
En Première spé, tu approfondis Python : tu utilises les listes et dictionnaires plus en profondeur, tu manipules les modules (math, random, statistics, matplotlib), tu écris des fonctions récursives, et tu simules des expériences aléatoires.
Rappels Python
Variables et types
x = 5 # int
y = 3.14 # float
s = "Bonjour" # str
b = True # bool
L = [1, 2, 3] # list
Structures de contrôle
if x > 0:
print("positif")
elif x == 0:
print("nul")
else:
print("négatif")
for i in range(10):
print(i)
while x < 100:
x += 1
Listes : opérations avancées
Création
L = [0] * 10 # [0, 0, ..., 0]
L = [i**2 for i in range(10)] # [0, 1, 4, 9, ..., 81]
Méthodes utiles
L.append(x) # ajouter à la fin
L.insert(i, x) # insérer à l'index i
L.remove(x) # supprimer la valeur x
L.pop(i) # enlever et retourner l'élément i
L.sort() # tri en place
sorted(L) # nouvelle liste triée
L.reverse() # inverse en place
L[::-1] # nouvelle liste inversée
len(L) # longueur
sum(L), max(L), min(L)
Slicing
L = [10, 20, 30, 40, 50]
L[1:3] # [20, 30]
L[:2] # [10, 20]
L[2:] # [30, 40, 50]
Modules
Module math
import math
math.sqrt(16)
math.pi
math.cos(math.pi / 4)
math.factorial(5) # 120
math.gcd(12, 18) # 6 (PGCD)
math.comb(5, 2) # 10 (coefficient binomial)
Module random
import random
random.random() # entre 0 et 1
random.randint(1, 10) # entre 1 et 10
random.choice([1, 2, 3]) # un élément au hasard
random.shuffle(L) # mélange en place
random.sample(range(100), 10) # 10 éléments distincts
Module statistics
import statistics
statistics.mean(L)
statistics.median(L)
statistics.stdev(L)
statistics.variance(L)
Fonctions
Fonction simple
def carre(x):
return x * x
Plusieurs arguments
def aire_triangle(b, h):
return b * h / 2
Argument par défaut
def saluer(nom, langue="fr"):
if langue == "fr":
print("Bonjour", nom)
else:
print("Hello", nom)
Fonctions et listes
def moyenne(L):
return sum(L) / len(L)
def max_perso(L):
m = L[0]
for x in L:
if x > m:
m = x
return m
Algorithmes classiques
Algorithme d'Euclide (PGCD)
def pgcd(a, b):
while b != 0:
a, b = b, a % b
return a
Recherche dichotomique
def dichotomie(L, x):
a, b = 0, len(L) - 1
while a <= b:
m = (a + b) // 2
if L[m] == x:
return m
elif L[m] < x:
a = m + 1
else:
b = m - 1
return -1
Tri par insertion
def tri_insertion(L):
for i in range(1, len(L)):
x = L[i]
j = i - 1
while j >= 0 and L[j] > x:
L[j + 1] = L[j]
j -= 1
L[j + 1] = x
Simulations
Lancer un dé
import random
def lancer_de():
return random.randint(1, 6)
Loi binomiale
def binomiale(n, p):
return sum(1 for _ in range(n) if random.random() < p)
# Estimation de E(X) pour B(20, 0.3)
n_simul = 10000
moyenne = sum(binomiale(20, 0.3) for _ in range(n_simul)) / n_simul
print(moyenne) # ≈ 6
Marche aléatoire
def marche(n_pas):
x = 0
for _ in range(n_pas):
x += random.choice([-1, 1])
return x
Programmation graphique avec matplotlib
import matplotlib.pyplot as plt
x = list(range(100))
y = [i**2 for i in x]
plt.plot(x, y)
plt.xlabel("x")
plt.ylabel("x²")
plt.title("Courbe de la fonction carré")
plt.show()
Erreurs fréquentes à éviter
- Indentation mal faite (essentielle en Python).
- Mauvais index : les listes commencent à 00.
- Confondre
= et ==.
- Modifier une liste pendant qu'on la parcourt : risque d'erreur.
- Oublier d'importer un module avant de l'utiliser.
FAQ — Algorithmique et Python en Première spé
Pourquoi utiliser des fonctions ?
Pour réutiliser du code, organiser un programme, le rendre plus lisible et testable.
Quelle est la différence entre liste et tuple ?
Une liste est modifiable ([1, 2, 3]). Un tuple est immuable ((1, 2, 3)).
À quoi servent les simulations ?
À estimer des probabilités difficiles à calculer théoriquement, à vérifier un modèle, à explorer un phénomène.
Comment éviter les boucles infinies ?
Vérifier que la condition de sortie sera atteinte : la variable de boucle doit être modifiée à chaque tour.