Algorithmique et Python en seconde : cours complet
En seconde, tu passes de Scratch à Python, un vrai langage de programmation utilisé dans la recherche, l'industrie, le web. Tu manipules variables (entiers, flottants, chaînes de caractères, booléens), fonctions, boucles et conditions, et tu programmes de vrais algorithmes mathématiques. Les listes ne sont pas au programme de seconde : elles arrivent en première.
Python : les bases
Variables
a = 5 # entier
b = 3.14 # décimal (float)
nom = "Léa" # chaîne de caractères
ok = True # booléen
Opérations
3 + 5 # → 8
10 / 3 # → 3.333...
10 // 3 # → 3 (division entière)
10 % 3 # → 1 (reste)
2 ** 8 # → 256 (puissance)
Affichage et saisie
print("Bonjour", nom)
age = int(input("Quel âge as-tu ? "))
Conditions
if x > 0:
print("positif")
elif x == 0:
print("nul")
else:
print("négatif")
Opérateurs de comparaison
== (égal), != (différent), <, >, <=, >=
Opérateurs logiques
if 0 < x and x < 10:
print("entre 0 et 10")
Boucles
Boucle for
for i in range(5): # 0, 1, 2, 3, 4
print(i)
for i in range(1, 11): # 1 à 10
print(i)
Boucle while
n = 0
while n < 100:
n = n + 1
print(n)
Accumulateurs : résumer une boucle sans liste
Un accumulateur est une variable initialisée avant la boucle et mise à jour à chaque tour. Il suffit pour calculer une somme, un produit, un compte ou un maximum, sans stocker les valeurs.
s = 0 # somme
for k in range(1, 101):
s = s + k
print(s) # 5050
c = 0 # compte
for k in range(1, 101):
if k % 3 == 0 or k % 5 == 0:
c = c + 1
print(c) # 47
| Objectif |
Initialisation |
Mise à jour |
| somme |
s = 0 |
s = s + valeur |
| produit |
p = 1 |
p = p * valeur |
| compte |
c = 0 |
c = c + 1 sous condition |
| maximum |
m = première valeur |
si valeur > m : m = valeur |
Fonctions
Définition
def carre(x):
return x * x
print(carre(5)) # 25
Avec plusieurs paramètres
def maximum(a, b):
if a > b:
return a
else:
return b
Sans retour (procédure)
def dire_bonjour(nom):
print("Bonjour", nom)
Algorithmes classiques
Moyenne et écart type au fil d'une boucle
On accumule la somme des valeurs et la somme de leurs carrés ; la variance est la moyenne des carrés moins le carré de la moyenne.
from math import sqrt
def indicateurs(n):
s = 0
s2 = 0
for k in range(1, n + 1):
s = s + k
s2 = s2 + k * k
m = s / n
return m, sqrt(s2 / n - m * m)
print(indicateurs(5)) # (3.0, 1.414...)
Multiples : tester et chercher le plus grand
def est_multiple(a, b):
return a % b == 0
def plus_grand_multiple(a, b):
m = 0
while m + a <= b:
m = m + a
return m
print(est_multiple(84, 7)) # True
print(plus_grand_multiple(7, 100)) # 98
a % b est le reste de la division euclidienne de a par b : a est multiple de b quand ce reste vaut 0. La seconde fonction avance de a en a tant qu'on ne dépasse pas b.
Maximum d'une fonction par balayage
def maximum():
meilleur = 0
xmax = 0
for x in range(0, 7):
a = x * (6 - x)
if a > meilleur:
meilleur = a
xmax = x
return meilleur, xmax
print(maximum()) # (9, 3)
Modules utiles
Module math
import math
math.sqrt(16) # 4.0
math.pi # 3.14159...
math.cos(0) # 1.0
math.floor(3.7) # 3 (partie entière)
Module random
import random
random.randint(1, 6) # entier entre 1 et 6
random.random() # entre 0 et 1
Programmes types
Tirage d'un dé
import random
def lancer_de():
return random.randint(1, 6)
Simulation de la loi des grands nombres
import random
def frequence_six(n):
cpt = 0
for _ in range(n):
if random.randint(1, 6) == 6:
cpt += 1
return cpt / n
print(frequence_six(10000)) # proche de 1/6 ≈ 0.167
En appelant cette fonction plusieurs fois, on obtient une série statistique de fréquences : elles changent d'un appel à l'autre (fluctuation d'échantillonnage) et se rapprochent de 611/6 quand nn grandit (loi des grands nombres).
Calcul itératif
def somme_n_premiers(n):
s = 0
for i in range(1, n+1):
s += i
return s
print(somme_n_premiers(100)) # 5050
Erreurs fréquentes à éviter
- Confondre
= (affectation) et == (test d'égalité).
- Mauvaise indentation : essentielle en Python (souvent 44 espaces).
- Oublier que
range(a, b) s'arrête à b−1b - 1 : pour aller de 11 à nn inclus, on écrit range(1, n + 1).
- Mal initialiser un accumulateur : un produit part de 11, pas de 00.
- Boucle infinie : penser à modifier la condition de sortie.
- Type incorrect :
input() retourne toujours une chaîne, convertir avec int() ou float().
FAQ — Algorithmique et Python en seconde
Pourquoi Python plutôt que Scratch ?
Python est professionnel, utilisé dans la vraie vie (recherche, IA, web). Il prépare aux études supérieures et au monde du travail.
Comment exécuter du Python ?
Avec un éditeur EduPython, Pyzo, Thonny, ou en ligne (replit.com, basthon.fr). En lycée, Edupython est très utilisé.
Quelle est la différence entre une fonction et une procédure ?
Une fonction retourne une valeur (return). Une procédure fait une action sans retourner de valeur (juste un print() par exemple).
À quoi sert l'algorithmique ?
À résoudre n'importe quel problème : calculs scientifiques, traitement de données, intelligence artificielle, jeux, sites web…