Un prof de maths qui te répond·30 €/mois

Découvrir
MathLvlMon espace
Seconde

Algorithmique et Python en Seconde

Variables, boucles, conditions et fonctions Python pour les maths en Seconde.

Mis à jour le

En seconde, l'algorithmique se fait en Python. Tu écris des programmes courts qui calculent, testent et répètent, et tu apprends à lire, compléter ou corriger un programme plus long.

Au programme : variables et types (entier, flottant, chaîne de caractères, booléen) ; affectation ; instructions conditionnelles (if/elif/else) ; boucles bornées (for) et non bornées (while) ; fonctions à un ou plusieurs arguments ; fonctions qui renvoient le résultat d'une expérience aléatoire, puis répétition de cette expérience pour obtenir une série de fréquences. Premiers algorithmes : accumulateurs (somme, compte, maximum), recherche d'un seuil, balayage d'une fonction, simulation d'un dé ou d'une pièce. Les listes ne sont pas exigées en seconde.

Pièges classiques : confondre = (affectation) et == (test) ; oublier que range(1, n) s'arrête à n − 1 ; initialiser un produit à 0 ; placer un return dans la boucle ; écrire une boucle while dont la condition ne change jamais.

Cours et fiche

📘

Leçon

Le cours complet du chapitre

Exercices corrigés

5 exercices
1

Plaquette 1 – Variables, boucles, conditions et fonctions

2

Plaquette 2 – Fonctions, accumulateurs et types de variables

3

Plaquette 3 – Boucles while, seuils et algorithmes classiques

4

Plaquette 4 – Simulations aléatoires et statistiques

5

Plaquette 5 – Problèmes de synthèse : programmes complets à écrire et à corriger

Quiz interactif

Auto-évaluation

Teste tes connaissances et vérifie que tu maîtrises le chapitre.

QCM — Algorithmique et Python (51 questions)

Leçon complète

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

  • and, or, not
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 1/6 quand n 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 4 espaces).
  • Oublier que range(a, b) s'arrête à b - 1 : pour aller de 1 à n inclus, on écrit range(1, n + 1).
  • Mal initialiser un accumulateur : un produit part de 1, pas de 0.
  • 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…

Tout sur algorithmique et python au lycée

Variables, fonctions, boucles, listes, puis seuils, dichotomie et simulations : le Python du programme de la Seconde à la Terminale.

Tous les chapitres de Seconde

Poursuis ta révision avec les autres chapitres du programme de Seconde.