Chapitre 15 — Informatique

Python — Apprendre à programmer

Variables, boucles, fonctions, listes. Applications en maths et éditeur Python interactif.

📋 Sommaire

Introduction
Cours
Exemples guidés
Exercices interactifs
Fiche de synthèse

1. Introduction

Python est l'un des langages de programmation les plus populaires au monde. Facile à lire, puissant et polyvalent, il est utilisé en sciences des données, en intelligence artificielle, en physique, en finance et — bien sûr — en mathématiques.

Bonne nouvelle : aucune installation requise ! Chaque exemple ci-dessous peut être modifié et exécuté directement dans le navigateur. Cliquez sur ▶ Exécuter pour lancer le code.

Voici votre tout premier programme Python :

bonjour.py

print("Bonjour, monde !")
print("Python, c'est simple et puissant.")
print(2 + 2, "=", 4)

Sortie

2. Cours

A. Variables et types

Définition — Variable

Une variable est une case mémoire nommée. On la crée par une affectation avec =. Python détecte automatiquement le type.

Les quatre types fondamentaux

Type	Nom Python	Exemples	Description
Entier	`int`	`3, -7, 1000`	Nombre entier relatif
Décimal	`float`	`3.14, -0.5`	Nombre à virgule flottante
Chaîne	`str`	`"Bonjour", 'abc'`	Texte entre guillemets
Booléen	`bool`	`True, False`	Vrai ou Faux

Opérateurs arithmétiques

Op.	Signification	Exemple	Résultat
`+`	Addition	`3+4`	`7`
`-`	Soustraction	`10-3`	`7`
`*`	Multiplication	`5*3`	`15`
`/`	Division (réelle)	`7/2`	`3.5`
`//`	Division entière	`7//2`	`3`
`%`	Modulo (reste)	`7%2`	`1`
`**`	Puissance	`2**10`	`1024`

variables.py

x = 5          # entier
y = 3.14       # flottant
nom = "Alice"  # chaine
actif = True   # booleen

print("x =", x, "  type:", type(x))
print("y =", y, "  type:", type(y))
print("nom =", nom)

# Operations
print("\nCalculs :")
print("x + y =", x + y)
print("x ** 3 =", x ** 3)
print("17 // 5 =", 17 // 5, "   reste :", 17 % 5)

Sortie

B. Structures conditionnelles

Syntaxe — if / elif / else

En Python, l'indentation (4 espaces) est obligatoire pour délimiter les blocs. Les opérateurs de comparaison sont : ==, !=, <, <=, >, >=. Les opérateurs logiques : and, or, not.

conditions.py

note = 14   # modifiez cette valeur !

if note >= 16:
    mention = "Tres Bien"
elif note >= 14:
    mention = "Bien"
elif note >= 12:
    mention = "Assez Bien"
elif note >= 10:
    mention = "Passable"
else:
    mention = "Insuffisant"

print("Note :", note, "/ 20  -->  Mention :", mention)

n = 17
if n % 2 == 0:
    print(n, "est pair")
else:
    print(n, "est impair")

Sortie

C. Boucles

Boucle for

Parcourt une séquence. range(a, b) génère les entiers de a à b−1. range(n) génère 0, 1, …, n−1.

Boucle while

Répète le bloc tant que la condition est vraie. Indispensable pour les algorithmes de seuil.

boucles.py

print("=== Boucle for ===")
somme = 0
for i in range(1, 11):   # i de 1 a 10
    somme += i
print("Somme 1+2+...+10 =", somme)

print("\nTable de multiplication de 7 :")
for k in range(1, 11):
    print("7 x", k, "=", 7 * k)

print("\n=== Boucle while ===")
# Seuil : plus petit n tel que 2^n > 1000
n = 0
while 2**n <= 1000:
    n += 1
print("Plus petit n tel que 2^n > 1000 : n =", n, "  (2^n =", 2**n, ")")

Sortie

D. Fonctions

Définition — Fonction Python

Une fonction est un bloc de code réutilisable, défini avec def. Elle peut recevoir des paramètres et retourner un résultat avec return.

fonctions.py

def carre(x):
    return x ** 2

def discriminant(a, b, c):
    return b**2 - 4*a*c

def resoudre_trinome(a, b, c):
    delta = discriminant(a, b, c)
    if delta > 0:
        x1 = (-b - delta**0.5) / (2*a)
        x2 = (-b + delta**0.5) / (2*a)
        print("Delta > 0 : x1 =", round(x1,4), "  x2 =", round(x2,4))
    elif delta == 0:
        x0 = -b / (2*a)
        print("Delta = 0 : solution double x0 =", round(x0,4))
    else:
        print("Delta < 0 : pas de solution reelle")

print("Carres :", [carre(k) for k in range(1, 6)])
print()
resoudre_trinome(1, -5, 6)   # x^2 - 5x + 6 = 0
resoudre_trinome(1, -2, 1)   # x^2 - 2x + 1 = 0
resoudre_trinome(1,  0, 1)   # x^2 + 1 = 0

Sortie

E. Listes

Définition — Liste

Une liste est une collection ordonnée entre crochets [ ]. Les indices commencent à 0. lst[-1] désigne le dernier élément.

Opérations courantes

lst[i] — accès à l'indice i
len(lst) — longueur
lst.append(x) — ajouter en fin
lst.sort() — tri croissant
sum(lst) — somme
min(lst) / max(lst)
sorted(lst) — nouvelle liste triée
[f(x) for x in lst] — compréhension

listes.py

notes = [12, 15, 8, 17, 11, 14, 9, 16]

print("Notes :", notes)
print("Nombre :", len(notes))
print("Moyenne :", sum(notes) / len(notes))
print("Max :", max(notes), "  Min :", min(notes))

# Tri
print("Triees :", sorted(notes))

# Comprehension de liste
doubles = [n * 2 for n in notes]
print("Doublees :", doubles)

# Filtrage
admis = [n for n in notes if n >= 10]
print("Admis (>= 10) :", admis)

notes.append(13)
print("Apres ajout de 13 :", notes)

Sortie

F. Applications en mathématiques

Python et les maths : suites, algorithmes de seuil, intégration numérique, simulations probabilistes — autant de thèmes au programme de Terminale traités en quelques lignes.

F.1 — Suites et algorithme de seuil

suites.py

def suite_arithmetique(u0, r, n):
    return [u0 + k * r for k in range(n + 1)]

def suite_geometrique(u0, q, n):
    return [u0 * (q ** k) for k in range(n + 1)]

arith = suite_arithmetique(2, 3, 7)
print("Suite arith. (u0=2, r=3) :", arith)
print("  Somme S7 =", sum(arith))

geom = suite_geometrique(1, 2, 9)
print("\nSuite geom.  (u0=1, q=2) :", geom)
print("  Somme S9 =", sum(geom))

# Algorithme de seuil
print("\nSeuil : premier n tel que (0.9)^n < 0.01")
u, n = 1, 0
while u >= 0.01:
    u *= 0.9
    n += 1
print("  n =", n, "  (0.9)^n =", round(u, 8))

Sortie

F.2 — Intégration numérique (méthode des rectangles)

integration.py

import math

def integrale_rectangles(f, a, b, n):
    h = (b - a) / n
    return sum(f(a + k * h) for k in range(n)) * h

# Integrale de sin(x) sur [0, pi] = 2
f1 = lambda x: math.sin(x)
print("Integrale de sin(x) sur [0, pi] (valeur exacte = 2) :")
for n in [10, 100, 1000]:
    approx = integrale_rectangles(f1, 0, math.pi, n)
    print("  n =", n, "  approx =", round(approx, 8), "  erreur =", round(abs(approx - 2), 2e-8))

# Approximation de pi
print("\nApproximation de pi via l'integrale de 4/(1+x^2) sur [0,1] :")
f2 = lambda x: 4 / (1 + x**2)
for n in [100, 10000]:
    pi_approx = integrale_rectangles(f2, 0, 1, n)
    print("  n =", n, "  pi ~=", round(pi_approx, 8), "  erreur =", round(abs(pi_approx - math.pi), 10))

Sortie

F.3 — Simulation probabiliste

probabilites.py

import random

def simuler_pile_ou_face(n):
    piles = sum(1 for _ in range(n) if random.random() < 0.5)
    return piles / n

print("Loi des grands nombres — pile ou face :")
for n in [10, 100, 1000, 10000]:
    freq = simuler_pile_ou_face(n)
    print("  n =", n, "  frequence Pile =", round(freq, 5), "  ecart =", round(abs(freq - 0.5), 5))

print("\nFrequences relatives : 6000 lancers d'un de :")
lancers = [random.randint(1, 6) for _ in range(6000)]
for face in range(1, 7):
    freq = lancers.count(face) / 6000
    barre = "#" * int(freq * 100)
    print("  Face", face, ":", round(freq, 4), " ", barre)

Sortie

3. Exemples guidés

Exemple 1 — Factorielle et coefficients binomiaux

On programme \(n!\) puis \(\binom{n}{k}\) pour reconstruire le triangle de Pascal.

exemple1_pascal.py

def factorielle(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

def binom(n, k):
    return factorielle(n) // (factorielle(k) * factorielle(n - k))

print("Triangle de Pascal (lignes 0 a 6) :")
for n in range(7):
    ligne = [binom(n, k) for k in range(n + 1)]
    print("  n=" + str(n) + " :", ligne)

print()
print("C(10,3) =", binom(10, 3))
print("C(20,10) =", binom(20, 10))

Sortie

Exemple 2 — Méthode de Newton

La suite \(x_{n+1} = x_n - \dfrac{f(x_n)}{f'(x_n)}\) converge très vite vers une racine de \(f\). On approche \(\sqrt[3]{2}\) en résolvant \(x^3-2=0\).

exemple2_newton.py

def newton(f, df, x0, epsilon=1e-10, max_iter=50):
    x = x0
    for i in range(max_iter):
        fx = f(x)
        if abs(fx) < epsilon:
            print("  Convergence en", i, "iterations.")
            break
        x = x - fx / df(x)
    return x

import math

f  = lambda x: x**3 - 2
df = lambda x: 3 * x**2

racine = newton(f, df, x0=1.0)
print("Racine cubique de 2 par Newton :")
print("  racine^3 =", round(racine**3, 15), " (doit valoir 2)")
print("  math.pow(2,1/3) =", round(2**(1/3), 15))

# Resoudre cos(x) = x
f2  = lambda x: math.cos(x) - x
df2 = lambda x: -math.sin(x) - 1
sol = newton(f2, df2, x0=0.5)
print("\nSolution de cos(x) = x :")
print("  x =", round(sol, 12))

Sortie

Exemple 3 — Crible d'Ératosthène

Algorithme classique pour trouver tous les nombres premiers jusqu'à \(N\).

exemple3_crible.py

def crible(N):
    est_premier = [True] * (N + 1)
    est_premier[0] = est_premier[1] = False
    for p in range(2, int(N**0.5) + 1):
        if est_premier[p]:
            for m in range(p*p, N + 1, p):
                est_premier[m] = False
    return [n for n in range(N + 1) if est_premier[n]]

premiers = crible(100)
print("Premiers <= 100 (", len(premiers), "nombres ) :")
print(premiers)

grands = crible(1000)
print("\nPremiers <= 1000 :", len(grands), "nombres")
print("Les 5 derniers :", grands[-5:])

jumeaux = [(p, p+2) for p in premiers if p+2 in premiers]
print("\nPaires de premiers jumeaux <= 100 :", jumeaux)

Sortie

Exemple 4 — Suite de Fibonacci et nombre d'or

\(F_0=0,\ F_1=1,\ F_{n+1}=F_n+F_{n-1}\). Le rapport \(\dfrac{F_{n+1}}{F_n}\) converge vers \(\varphi=\dfrac{1+\sqrt{5}}{2}\).

exemple4_fibonacci.py

import math
phi = (1 + math.sqrt(5)) / 2
print("Nombre d'or phi =", round(phi, 10))

F = [0, 1]
for k in range(2, 21):
    F.append(F[-1] + F[-2])
print("\nFibonacci F0 a F20 :")
print(F)

print("\nConvergence des rapports vers phi :")
for n in [5, 10, 15, 19]:
    rapport = F[n+1] / F[n]
    print("  F[" + str(n+1) + "]/F[" + str(n) + "] =", round(rapport, 10),
          "  erreur :", round(abs(rapport - phi), 2))

Sortie

4. Exercices interactifs

Complétez le code dans chaque éditeur, puis cliquez sur ▶ Exécuter pour tester votre solution.

⭐ Facile Exercice 1 — Calculatrice

Écrire une fonction calculatrice(a, op, b) qui prend deux nombres et un opérateur ('+', '-', '*', '/') et retourne le résultat.

ex1.py

def calculatrice(a, op, b):
    pass  # a completer !

print(calculatrice(5, '+', 3))   # attendu : 8
print(calculatrice(10, '-', 4))  # attendu : 6
print(calculatrice(7, '*', 6))   # attendu : 42
print(calculatrice(15, '/', 4))  # attendu : 3.75

Sortie

ex1_corrige.py

def calculatrice(a, op, b):
    if op == '+':
        return a + b
    elif op == '-':
        return a - b
    elif op == '*':
        return a * b
    elif op == '/':
        if b == 0:
            return "Erreur : division par zero"
        return a / b
    else:
        return "Operateur inconnu"

print(calculatrice(5, '+', 3))
print(calculatrice(10, '-', 4))
print(calculatrice(7, '*', 6))
print(calculatrice(15, '/', 4))
print(calculatrice(5, '/', 0))

Sortie

⭐ Facile Exercice 2 — Maximum sans max()

Sans utiliser la fonction max(), écrire mon_max(lst) qui retourne le plus grand élément d'une liste.

ex2.py

def mon_max(lst):
    pass  # a completer !

print(mon_max([3, 1, 7, 2, 9, 4]))   # 9
print(mon_max([-5, -1, -8, -2]))      # -1
print(mon_max([42]))                   # 42

Sortie

ex2_corrige.py

def mon_max(lst):
    maxi = lst[0]
    for element in lst:
        if element > maxi:
            maxi = element
    return maxi

print(mon_max([3, 1, 7, 2, 9, 4]))
print(mon_max([-5, -1, -8, -2]))
print(mon_max([42]))

Sortie

⭐⭐ Moyen Exercice 3 — Suite et algorithme de seuil

Soit \(u_0=100\) et \(u_{n+1}=0{,}85\,u_n\). Écrire une fonction qui retourne les \(N\) premiers termes, et une autre qui trouve le plus petit \(n\) tel que \(u_n < 1\).

ex3.py

def termes_suite(u0, q, N):
    pass  # a completer

def seuil(u0, q, limite):
    pass  # a completer

termes = termes_suite(100, 0.85, 10)
print("10 premiers termes :", termes)
n_seuil = seuil(100, 0.85, 1)
print("Plus petit n tel que u_n < 1 : n =", n_seuil)

Sortie

ex3_corrige.py

def termes_suite(u0, q, N):
    termes = [u0]
    for _ in range(N - 1):
        termes.append(round(termes[-1] * q, 4))
    return termes

def seuil(u0, q, limite):
    u, n = u0, 0
    while u >= limite:
        u *= q
        n += 1
    return n

print("10 premiers termes :", termes_suite(100, 0.85, 10))
n_s = seuil(100, 0.85, 1)
print("Plus petit n tel que u_n < 1 : n =", n_s)
print("Verification : 100 * 0.85^" + str(n_s) + " =", round(100 * 0.85**n_s, 6))

Sortie

⭐⭐ Moyen Exercice 4 — Moyenne, variance, écart-type

Sans bibliothèque externe, calculer la moyenne \(\bar{x}\), la variance \(V=\frac{1}{n}\sum(x_i-\bar{x})^2\) et l'écart-type \(\sigma=\sqrt{V}\).

ex4.py

def statistiques(valeurs):
    pass  # retourner (moyenne, variance, ecart_type)

donnees = [12, 15, 8, 17, 11, 14, 9, 16, 13, 10]
moy, var, et = statistiques(donnees)
print("Moyenne :", round(moy, 4))
print("Variance :", round(var, 4))
print("Ecart-type :", round(et, 4))

Sortie

ex4_corrige.py

def statistiques(valeurs):
    n   = len(valeurs)
    moy = sum(valeurs) / n
    var = sum((x - moy)**2 for x in valeurs) / n
    et  = var ** 0.5
    return moy, var, et

donnees = [12, 15, 8, 17, 11, 14, 9, 16, 13, 10]
moy, var, et = statistiques(donnees)
print("Donnees :", donnees)
print("Moyenne :", round(moy, 4))
print("Variance :", round(var, 4))
print("Ecart-type :", round(et, 4))
dans = [x for x in donnees if moy - et <= x <= moy + et]
print("Valeurs dans [x-s ; x+s] :", dans, "soit", len(dans), "/", len(donnees))

Sortie

⭐⭐⭐ Difficile Exercice 5 — Dichotomie

Implémenter la méthode de dichotomie pour approcher une racine de \(f\) sur \([a,b]\) avec \(f(a)\cdot f(b)\leq 0\). L'utiliser pour approcher \(\sqrt{2}\).

ex5.py

def dichotomie(f, a, b, epsilon=1e-10):
    pass  # a completer

f = lambda x: x**2 - 2
racine = dichotomie(f, 1, 2)
print("Racine approchee :", round(racine, 12))
print("Verification : racine^2 =", round(racine**2, 12))

Sortie

ex5_corrige.py

def dichotomie(f, a, b, epsilon=1e-10):
    iterations = 0
    while (b - a) > epsilon:
        m = (a + b) / 2
        if f(a) * f(m) <= 0:
            b = m
        else:
            a = m
        iterations += 1
    print("  Iterations :", iterations)
    return (a + b) / 2

import math

f = lambda x: x**2 - 2
print("Racine de x^2 - 2 sur [1, 2] :")
r = dichotomie(f, 1, 2)
print("  Approchee :", round(r, 12))
print("  math.sqrt(2) :", round(math.sqrt(2), 12))
print("  Erreur :", abs(r - math.sqrt(2)))

f2 = lambda x: x**3 - 3
print("\nRacine cubique de 3 :")
r2 = dichotomie(f2, 1, 2)
print("  Approchee :", round(r2, 12))

Sortie

⭐⭐⭐ Difficile Exercice 6 — Simulation de la loi binomiale

Simuler \(X\sim\mathcal{B}(20,\,0{,}3)\) sur 10 000 essais. Comparer l'espérance et la variance simulées aux valeurs théoriques \(E(X)=np\) et \(V(X)=np(1-p)\).

ex6.py

import random

def simuler_binomiale(n, p, nb_essais):
    pass  # retourner liste des nb_essais valeurs de X

resultats = simuler_binomiale(20, 0.3, 10000)
if resultats:
    moy = sum(resultats) / len(resultats)
    print("Esperance theorique :", 20 * 0.3)
    print("Esperance simulee   :", round(moy, 4))
    print("Variance theorique  :", 20 * 0.3 * 0.7)
    var = sum((x - moy)**2 for x in resultats) / len(resultats)
    print("Variance simulee    :", round(var, 4))

Sortie

ex6_corrige.py

import random

def simuler_binomiale(n, p, nb_essais):
    resultats = []
    for _ in range(nb_essais):
        succes = sum(1 for _ in range(n) if random.random() < p)
        resultats.append(succes)
    return resultats

n, p, nb = 20, 0.3, 10000
res = simuler_binomiale(n, p, nb)
moy = sum(res) / nb
var = sum((x - moy)**2 for x in res) / nb

print("B(" + str(n) + ", " + str(p) + ") simulee sur", nb, "essais :")
print("  Esperance : theorique =", n*p, " | simulee =", round(moy, 4))
print("  Variance  : theorique =", round(n*p*(1-p), 4), " | simulee =", round(var, 4))

print("\nDistribution (k ou P(X=k) > 2%) :")
for k in range(n + 1):
    freq = res.count(k) / nb
    if freq > 0.02:
        barre = "#" * int(freq * 200)
        print("  k=" + str(k).rjust(2) + "  freq=" + str(round(freq,4)).ljust(6) + "  " + barre)

Sortie

📌 Fiche de synthèse Python

Structures essentielles

Concept	Syntaxe
Affectation	`x = 5`
Affichage	`print(x, "texte", 3+4)`
Commentaire	`# commentaire`
Condition	`if cond: ... elif ...: ... else: ...`
Boucle for	`for i in range(n): ...`
Boucle while	`while condition: ...`
Fonction	`def f(x): ... return ...`
Lambda	`f = lambda x: x**2`
Compréhension	`[f(x) for x in lst if cond]`

Fonctions mathématiques — module `math`

math.sqrt(x) — racine carrée
math.pi — \(\pi\)
math.e — \(e\)
math.sin(x), math.cos(x)
math.log(x) — \(\ln(x)\)
math.factorial(n) — \(n!\)
abs(x) — valeur absolue
round(x, n) — arrondi

Bonnes pratiques

Indentation : toujours 4 espaces.
Noms explicites : moyenne_notes plutôt que mn.
Tester : vérifier sur des cas simples avant les cas complexes.
Boucle while : s'assurer que la condition finit par devenir fausse.
Commenter : expliquer le pourquoi, pas le quoi.

← Précédent Accueil →

Python — Apprendre à programmer

📋 Sommaire

1. Introduction

2. Cours

A. Variables et types

B. Structures conditionnelles

C. Boucles

D. Fonctions

E. Listes

F. Applications en mathématiques

F.1 — Suites et algorithme de seuil

F.2 — Intégration numérique (méthode des rectangles)

F.3 — Simulation probabiliste

3. Exemples guidés

4. Exercices interactifs

📌 Fiche de synthèse Python

Structures essentielles

Fonctions mathématiques — module math

Bonnes pratiques

Fonctions mathématiques — module `math`