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
🔧 Fiches méthodes
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.

🧩 Atelier d’auto-apprentissage

Apprenez à traduire les formules, écrire des fonctions et programmer des suites grâce à 10 exercices progressifs autocorrectifs.

Commencer les exercices

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

🔧 Fiches méthodes

Méthodes à maîtriser pour ce chapitre.

Méthode — Algorithme de recherche de seuil

Étape 1 : Définir la suite \((u_n)\) et le seuil \(S\).

Étape 2 : Initialiser \(n=0\), \(u=u_0\).

Étape 3 : Boucle while : tant que la condition n'est pas atteinte, incrémenter \(n\) et calculer \(u_{n+1}\).

Étape 4 : Retourner le rang \(n\) et la valeur \(u_n\).

Exemple détaillé — Premier \(n\) tel que \(0{,}5^n < 0{,}001\)

u = 1      # u_0 = 1
n = 0
while u >= 0.001:
    n = n + 1
    u = 0.5 * u
print(f"n = {n}, u_n = {u:.6f}")
# Résultat : n = 10, u_n = 0.000977

Vérification : \(0{,}5^{10}=1/1024\approx0{,}000977<0{,}001\) ✓

Méthode — Simulation de probabilités (Monte-Carlo)

Étape 1 : Importer random. Fixer un grand \(N\) (ex. 100 000).

Étape 2 : Répéter \(N\) fois l'expérience et compter les succès.

Étape 3 : Estimer \(\hat{p}=\text{nb\_succès}/N\).

Exemple détaillé — Simulation de \(X\sim\mathcal{B}(10;0{,}3)\)

import random

N = 100000
succes = 0
for _ in range(N):
    nb = sum(1 for _ in range(10) if random.random() < 0.3)
    if nb == 3:
        succes += 1

print(f"P(X=3) ≈ {succes/N:.4f}")
# Résultat attendu ≈ 0.2668

Piège à éviter

En Python, l'indentation est syntaxique. Une erreur d'indentation provoque un IndentationError immédiat. Utiliser des espaces (4 par niveau) ou des tabulations, jamais les deux.

📌 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

🔧 Fiches méthodes

📌 Fiche de synthèse Python

Structures essentielles

Fonctions mathématiques — module math

Bonnes pratiques

Fonctions mathématiques — module `math`