Python pour les (futurs) professeurs d’Alain Busser (Éditions Ellipses, décembre 2025, 217 p.) s’inscrit dans un contexte désormais bien installé : celui d’une présence forte de Python dans les programmes de mathématiques du lycée et du début du supérieur.

Mais l’ouvrage ne propose ni un simple manuel d’initiation à Python, ni un recueil d’exercices prêts à l’emploi. Il se situe ailleurs : dans une réflexion sur ce que la programmation peut apporter à la compréhension des mathématiques — et réciproquement.

1. Un positionnement clair : Python au service des mathématiques

Le livre s’adresse avant tout :
– aux enseignants de mathématiques (collège, lycée, CPGE, université),
– aux futurs professeurs préparant CAPES ou agrégation,
– aux formateurs,
– mais aussi aux enseignants d’informatique attentifs aux fondements du langage.
Il pourra également intéresser des étudiants curieux de comprendre plus finement le fonctionnement interne de Python.

Dès les premières pages, un choix fort apparaît : on n’y utilise quasiment jamais l’instruction print. L’auteur privilégie l’usage de la console interactive et surtout des fonctions. Ce parti pris est révélateur : il ne s’agit pas d’apprendre à “faire afficher” des résultats, mais de modéliser, formaliser, manipuler des objets.

Python n’est pas présenté comme une fin en soi. Il devient un vecteur d’apprentissage des mathématiques, grâce à :
– sa simplicité syntaxique,
– sa proximité avec la langue naturelle,
– sa capacité à rendre immédiatement testables des idées abstraites.

Il ne s’agit donc pas d’un cours de Python “pour matheux”, mais plutôt d’un “Python par l’exemple”, où chaque notion informatique est introduite parce qu’elle éclaire un concept mathématique.

2. Une progression large : de la Grande Section aux CPGE, des nombres entiers naturels aux catégories

L’ouvrage comporte 14 chapitres couvrant un spectre particulièrement vaste. Les notions mathématiques abordées vont :
– de la construction du nombre (niveau Grande Section),
– à l’arithmétique et aux suites du secondaire,
– jusqu’à l’algèbre linéaire post-bac,

voire à des thèmes hors programme comme le lambda-calcul ou la théorie des catégories.

Cette amplitude est l’un des points forts du livre : il ne se limite pas à accompagner les programmes, il nourrit la culture mathématique de l’enseignant.

3. Parcours par chapitres

Chapitre 1 : la console comme laboratoire

Ce premier chapitre pose les fondations essentielles de l’ouvrage en introduisant le fonctionnement de la console Python, véritable point d’entrée dans la pratique du calcul informatique.

Il présente la console comme un espace d’expérimentation où l’on distingue :
– les expressions, qui produisent des valeurs,
– et les instructions, qui modifient l’état de la mémoire.

On y découvre la notion d’affectation, permettant de créer et de faire évoluer des variables, ainsi que ses effets parfois contre-intuitifs par rapport à l’égalité mathématique.

Le chapitre introduit également les types d’objets manipulés par Python (entiers, chaînes, booléens…), chacun étant doté de méthodes associées qui définissent ses capacités (addition, comparaison, etc.).

Les booléens (True, False) et la valeur spéciale None sont présentés comme des objets fondamentaux pour structurer le raisonnement logique et gérer les cas où une fonction n’est pas définie.

Une place centrale est accordée aux fonctions, appelées à devenir le véritable cœur de l’ouvrage : leur définition, leur utilisation et leur importation depuis des modules constituent un outil essentiel pour structurer le calcul.

La console devient ainsi un véritable laboratoire mathématique dans lequel on peut explorer :
– les priorités opératoires,
– les effets des affectations successives,
– ou encore les erreurs classiques (division par zéro, incompatibilités de types).

Enfin, le chapitre propose une pédagogie de l’erreur particulièrement féconde :
les messages d’erreur ne sont pas évités, mais utilisés comme des instruments de compréhension permettant de clarifier les concepts et d’affiner le raisonnement.

L’introduction aux modules ouvre également la voie à une extension progressive des capacités du langage.

Chapitre 2 : Ensembles et probabilités

À la fin du XIXe siècle, Gottlob Frege initie un vaste projet : reconstruire l’ensemble des mathématiques à partir des relations entre ensembles. Cette approche sera prolongée au XXe siècle par Georg Cantor, David Hilbert, Bertrand Russell, Alfred Tarski ou encore Nicolas Bourbaki, qui feront des ensembles le socle de l’édifice mathématique.

Le chapitre s’inscrit dans cette perspective fondationnelle en introduisant les ensembles comme objets omniprésents :
– le plan est un ensemble de points,
– une courbe est un ensemble de points,
– et résoudre une équation revient à déterminer l’ensemble de ses solutions.

Python permet de modéliser concrètement ces notions à partir d’un univers fini U, par exemple celui des résultats possibles d’un lancer de dé simulé à l’aide de range et converti en ensemble avec set.

On y explore :
– l’appartenance (in),
– l’inclusion (issubset),
– l’intersection (intersection),
– la réunion (union),
– et le complémentaire (difference).

Les ensembles peuvent être définis par compréhension, à partir de prédicats, c’est-à-dire de fonctions renvoyant des valeurs booléennes. Cette correspondance fondamentale entre ensembles et prédicats est centrale : appartenir à un ensemble revient à vérifier une propriété.

Les quantificateurs logiques introduits par Frege (« pour tout », « il existe ») peuvent être simulés en Python grâce aux fonctions all et any.

Ces opérations confèrent aux ensembles une structure d’algèbre de Boole, où :
– l’intersection correspond à l’opérateur logique and,
– la réunion à or,
– et le complément à not.

Une équation apparaît alors comme un prédicat, et résoudre une équation revient à déterminer l’ensemble des valeurs qui la rendent vraie.

Cette approche prépare l’introduction de la notion de mesure, illustrée par le cardinal d’un ensemble (len), qui respecte l’inclusion et l’additivité.

La nécessité d’une structure stable pour définir une mesure conduit à introduire les boréliens, fermés par union, intersection et complémentaire, sur lesquels Lebesgue définit sa mesure.

Dans ce cadre, une probabilité devient une mesure normalisée sur une algèbre de Boole, conformément à l’axiomatique de Kolmogorov.

Python permet de modéliser simplement ces probabilités à partir de cardinaux, puis de les affiner à l’aide des probabilités conditionnelles inspirées de Bayes, en utilisant des fractions pour obtenir des résultats exacts.

Le chapitre établit ainsi une continuité entre logique, ensembles, mesure et probabilités, tout en préparant l’introduction de la notion centrale de fonction.

Chapitre 3 Couples, n-uplets et tuples

Ce troisième chapitre introduit les couples, n-uplets et tuples, en partant d’un problème fondamental : comment représenter mathématiquement des objets dont l’ordre des éléments compte.

Depuis René Descartes, un point du plan est repéré par deux coordonnées (abscisse, ordonnée). Or, un ensemble ne permet pas de représenter un tel point, car :
– il ne tient pas compte de l’ordre,
– et ne distingue pas les répétitions (le point (2,2) serait confondu avec 2).

Cela conduit à introduire la notion de couple ordonné, que Python modélise naturellement avec les tuples.

Le chapitre montre que, conceptuellement, un couple peut être construit :
– à partir d’ensembles (travaux de Tarski ou Grothendieck),
– à partir de fonctions (Kuratowski),
– ou encore comme un algorithme (approche fonctionnelle de Church).

Ces différentes constructions soulignent le rôle fondamental du couple comme brique élémentaire pour formaliser les relations.

Le produit cartésien de deux ensembles est alors introduit comme l’ensemble de tous les couples possibles formés à partir de leurs éléments. Il permet de représenter graphiquement des relations sous forme de graphes orientés.

Une relation apparaît ainsi comme une partie d’un produit cartésien, c’est-à-dire un ensemble de couples reliant des éléments entre eux (par exemple une relation d’ordre ou de doublement).

Cette approche permet de redéfinir les variables de Python comme des couples (nom, valeur), et les fonctions comme des relations particulières associant à chaque élément du domaine au plus une image.

Une fonction peut ainsi être vue :
– comme un ensemble de couples,
– ou, plus efficacement, comme un dictionnaire associant à chaque clé une valeur.

Python propose enfin une modélisation directe des fonctions via lambda ou le mot-clé def, rejoignant l’approche du lambda-calcul.

Le chapitre se conclut par la généralisation aux triplets, quadruplets et plus généralement aux tuples, permettant de représenter des points de l’espace, des vecteurs ou des données multidimensionnelles.

Il prépare ainsi le passage des relations aux fonctions, en montrant comment celles-ci émergent naturellement des couples ordonnés.

Chapitre 4 Construction des nombres entiers

Ce chapitre présente la construction des nombres entiers naturels, point de départ de l’édifice numérique (qui mènera ensuite aux rationnels, réels et complexes). Contrairement à l’usage historique, la construction commence à partir de 0, comme en Python.

La première approche, due à Richard Dedekind, repose sur la fonction successeur S qui associe à chaque entier son suivant. Pour garantir une structure correcte des entiers, on introduit aussi la fonction prédécesseur P, définie pour tout entier sauf 0. Cette construction relie les entiers à la théorie des ensembles : l’inclusion correspond à l’ordre, la réunion à l’addition et le produit cartésien à la multiplication.

Giuseppe Peano formalise ensuite les propriétés des entiers à l’aide d’axiomes : il définit récursivement l’ordre, l’addition, la soustraction et la multiplication (vue comme addition itérée). La divisibilité et la division peuvent alors être construites par des algorithmes comme ceux d’Euclide.

John von Neumann propose une construction purement ensembliste des entiers : chaque entier est l’ensemble de tous les entiers qui le précèdent, ce qui permet de modéliser l’ordre par l’appartenance.

Alonzo Church adopte une approche fonctionnelle : les entiers deviennent des opérateurs appliquant une fonction un certain nombre de fois. Les opérations arithmétiques sont alors définies par composition de fonctions (lambda-calcul).

Le chapitre introduit enfin la théorie des catégories, où objets et morphismes structurent les mathématiques. Les entiers peuvent y être vus comme des catégories particulières ou comme des opérateurs agissant sur des unités.

La construction des entiers relatifs est obtenue en considérant des classes d’équivalence de couples d’entiers naturels, représentant les différences entre nombres.

Chapitre 5 Arithmétique des nombres entiers

Le chapitre construit l’arithmétique des entiers en interprétant les nombres naturels comme des opérateurs d’addition itérée : multiplier par 3 revient à ajouter trois fois. Cette approche permet de définir naturellement la multiplication et ses propriétés algébriques.

La division euclidienne découle ensuite de la propriété archimédienne : pour deux entiers a et b ≠0, il existe un quotient et un reste. Elle permet de formaliser la divisibilité et de définir le pgcd, calculable efficacement par l’algorithme d’Euclide, ainsi que le ppcm.

La notion de nombre premier apparaît quand tous les entiers inférieurs à n sont premiers avec lui, ou encore lorsque n possède exactement deux diviseurs. Des tests de primalité plus efficaces consistent à chercher des diviseurs seulement jusqu’à n, ou à utiliser le crible d’Ératosthène pour obtenir tous les nombres premiers jusqu’à une borne donnée.

Voici une petite correction du script proposé dans le livre :

def est_premier(n):
    d = 2
    while d*d<=n:    #Ici dans le livre c'est < pas <=
        if n%d==0:
            return False
        d += 1
    return n>1

En effet, sans cette correction, les carrés parfaits des nombres premiers sont considérés comme premiers.

Tout entier admet une décomposition unique en facteurs premiers, ce qui permet de calculer pgcd et ppcm en manipulant les exposants des facteurs. Cette unicité est exploitée dans le codage de Gödel, qui représente des tuples d’entiers par un seul entier via des produits de puissances de nombres premiers.

L’arithmétique modulaire, basée sur le reste, mène à l’arithmétique de Presburger et au théorème des restes chinois, permettant de reconstruire un entier à partir de ses restes modulo plusieurs nombres premiers entre eux. Ces méthodes de codage rapide sont utilisées en algorithmique et en cryptographie (par exemple dans RSA).

Enfin, le chapitre évoque d’autres structures sur ℕ, comme la permutation liée aux suites de Collatz, illustrant la richesse des approches possibles en théorie des nombres.

Chapitre 6 Dyadiques et décimaux

Ce chapitre introduit les fractions dyadiques et les nombres décimaux comme étapes intermédiaires entre les entiers et les rationnels, selon les inclusions ℤ ⊂ D₂ ⊂ D ⊂ ℚ. Les fractions dyadiques — fractions dont le dénominateur est une puissance de 2 — sont particulièrement naturelles car elles résultent de divisions successives par deux, fréquentes en géométrie comme dans la vie courante.

Elles jouent un rôle fondamental en informatique : en Python, les nombres réels sont modélisés par des flottants (float), qui représentent en réalité des approximations dyadiques. Grâce à la méthode as_integer_ratio, on peut retrouver l’écriture fractionnaire correspondante et vérifier que le dénominateur est bien une puissance de 2.

Toute fraction dyadique possède une écriture binaire finie. À l’inverse, des rationnels comme 1/3 ou 1/5 ont une écriture binaire infinie, ce qui explique certaines approximations numériques. L’étude de la représentation binaire permet notamment d’analyser des systèmes dynamiques comme la suite logistique définie par $u_{n + 1} = 4u_n(1 - u_n)$, dont le comportement peut devenir chaotique.

Le chapitre montre aussi que tous les nombres décimaux ne sont pas dyadiques : par exemple 0,2 ne peut être représenté exactement en mémoire, d’où des paradoxes apparents comme 0,1 + 0,2 ≠ 0,3.

Pour effectuer des calculs décimaux exacts, Python propose le module decimal, qui permet de représenter fidèlement des fractions de dénominateur une puissance de 10 et de régler la précision des calculs. Cette maîtrise de l’approximation influe directement sur le comportement de suites récurrentes ou de modèles financiers, notamment lorsque des arrondis interviennent.

getcontext().prec = 2
x=Decimal('0.36')
4*x*(1-x)

getcontext().prec = 2
x=Decimal('0.36')
x*(1-x)*4

Chapitre 7 Fractions

Ce chapitre propose plusieurs constructions des fractions, d’abord comme classes d’équivalence de couples d’entiers $(a,b)$ selon la relation $a×d=b×c$. Les fractions ne sont alors plus des objets isolés mais des ensembles de représentants équivalents (par exemple $\dfrac12, \dfrac24, \dfrac48$…). Cette structure peut être modélisée en Python à l’aide d’une structure de type union-find, permettant de construire des partitions et de retrouver efficacement la forme irréductible d’une fraction.

Les fractions sont ensuite interprétées comme des opérateurs linéaires : multiplier par $\dfrac32$, c’est appliquer le triple de la moitié. Dans cette perspective fonctionnelle, une fraction agit sur les nombres comme une transformation, prolongeant l’interprétation des entiers comme opérateurs d’addition itérée.

Elles apparaissent aussi comme des quotients, dont l’écriture fractionnaire est souvent plus simple et plus exacte que les représentations décimales ou binaires. Les opérations usuelles sur les fractions font alors de ℚ un corps, où chaque élément non nul possède un inverse.

Le chapitre aborde également l’écriture mixte issue de la division euclidienne, utile dans des contextes concrets comme l’acoustique des tuyaux d’orgue, où des rapports de longueurs fractionnaires déterminent les harmoniques.

Les fractions de Farey et l’arbre de Stern-Brocot permettent ensuite d’approcher efficacement des réels par des rationnels simples, via l’opération de médiante. Ces constructions arborescentes relient approximation numérique, théorie des engrenages et suites de Fibonacci.

Les fractions continuées fournissent une représentation unique des rationnels (et infinie pour les irrationnels), particulièrement adaptée à l’approximation de constantes comme $\sqrt2$ ou $e$.

Enfin, le chapitre évoque les fractions égyptiennes, décompositions en sommes d’inverses d’entiers, ainsi que des approches plus algébriques inspirées par Conway, reliant fractions, matrices et calculabilité, jusqu’au langage Fractran où un programme est une simple liste de fractions.

En page 118, la même formule est présente deux fois, Alain Busser nous donne la bonne seconde formule :

Chapitre 8 Structure de corps

Ce chapitre introduit la structure de corps, ensemble muni d’une addition et d’une multiplication compatibles, où tout élément non nul possède un inverse. Il montre que ℚ et ℝ sont des corps, contrairement à ℤ, et prend pour exemple fondamental le corps à deux éléments ℤ/2ℤ, implémenté en Python à l’aide des booléens et de l’opérateur XOR.

La représentation des réels en Python met en évidence les limites du calcul numérique : les flottants sont des approximations dyadiques, susceptibles de rompre des propriétés algébriques comme l’associativité. Des constantes irrationnelles comme e ou π sont alors approchées par des algorithmes itératifs ou des séries, éventuellement en précision arbitraire.

Le chapitre développe ensuite l’étude des corps finis ℤ/pℤ, dans lesquels toute division revient à multiplier par un inverse calculé grâce à l’algorithme d’Euclide étendu. Des extensions permettent de construire des corps à pⁿ éléments, analogues discrets des nombres complexes.

Les nombres algébriques, solutions d’équations polynomiales, forment eux aussi un corps. Des extensions quadratiques comme ℚ[√2] permettent d’obtenir des approximations rationnelles de √2 via des suites récurrentes, notamment celles issues des équations de Pell. Le quotient de deux termes successifs fournit alors des approximations de √2, de même que les quotients des termes de la suite de Fibonacci approchent le nombre d’or.

Enfin, le chapitre introduit les courbes elliptiques, sur lesquelles une loi de groupe permet d’additionner des points à coordonnées rationnelles pour en produire de nouveaux. Définies sur des corps finis, elles jouent un rôle majeur en cryptographie moderne.

Le chapitre se conclut par la résolution algorithmique d’équations polynomiales (degrés 2 et 3), illustrant comment les structures de corps permettent de relier calcul symbolique, approximation numérique et modélisation mathématique.

Chapitre 9. Mathématiques des textes

Ce chapitre propose un changement de perspective : les chaînes de caractères ne sont plus de simples objets informatiques, mais des structures algébriques à part entière. Munies de la concaténation, elles forment un monoïde dont l’étude ouvre la voie à des problèmes mathématiques originaux, où les mots remplacent les nombres.

Les premiers exemples relèvent de la cryptographie classique. Le chiffre de César, attribué à Jules César, est interprété comme un morphisme entre monoïdes grâce aux fonctions ord et chr. L’analyse fréquentielle introduite par Al-Kindi permet d’en montrer les faiblesses, conduisant au chiffrement polyalphabétique de Blaise de Vigenère.

Le chapitre aborde ensuite les graphes sous l’angle combinatoire des mots. Le problème des ponts de Königsberg étudié par Leonhard Euler devient une question sur les chaînes de caractères décrivant des parcours, menant à la notion de chemin eulérien. Les travaux de William Rowan Hamilton prolongent cette approche avec les circuits hamiltoniens et les présentations de groupes par générateurs et relations.

L’étude se poursuit avec le problème du mot, posé par Axel Thue, qui interroge l’existence d’algorithmes de simplification symbolique. Les systèmes de réécriture d’Emil Post montrent que toute fonction calculable peut être simulée par manipulation de mots, reliant logique, calcul et théorie des langages. Ces idées annoncent les travaux de Alan Turing sur la calculabilité.

Des suites textuelles comme la suite look-and-say de John Conway ou le mot de Fibonacci illustrent la richesse combinatoire des langages. Les règles de réécriture permettent également de générer des fractales telles que la courbe de Helge von Koch ou le triangle de Wacław Sierpiński.

Enfin, les automates de Mealy et la logique des combinateurs, initiée par Moses Schönfinkel et développée par Haskell Curry, montrent que raisonner revient fondamentalement à manipuler des symboles. Le chapitre établit ainsi un lien profond entre théorie des langages, logique formelle et fondements du calcul.

Chapitre 10. Complexes

Ce chapitre introduit les nombres complexes comme objets de calcul effectifs dans Python via le module cmath, où l’unité imaginaire est notée j. Les opérations algébriques usuelles (somme, produit, conjugaison, module) permettent d’explorer concrètement la résolution d’équations polynomiales : dans C, toute équation du second degré admet des solutions, et les méthodes classiques pour les équations cubiques (notamment celle de Cardan) deviennent programmables.

Les racines de l’unité et la formule d’Euler, due à Leonhard Euler, permettent d’étendre des fonctions comme le logarithme aux nombres négatifs, révélant leur nature multivaluée. Cette ambivalence conduit à la notion de surface de Riemann introduite par Bernhard Riemann, où l’on interprète les discontinuités comme des changements de feuillet.

La trigonométrie complexe généralise alors les identités classiques grâce aux travaux d’Abraham de Moivre, permettant de définir les fonctions hyperboliques et d’appliquer cosinus et sinus à tout nombre complexe. Ces outils ouvrent la voie à des applications géométriques comme l’étude du demi-plan de Poincaré via l’action du groupe modulaire.

Le chapitre aborde ensuite l’arithmétique dans C avec les entiers de Gauss introduits par Carl Friedrich Gauss : ces nombres permettent d’étendre les notions de divisibilité et de primalité au plan complexe. Cette construction inspire les entiers d’Eisenstein étudiés par Gotthold Eisenstein, où apparaissent de nouvelles symétries algébriques.

L’itération de fonctions complexes mène aux ensembles fractals étudiés par Gaston Julia et Pierre Fatou, puis à l’ensemble de Mandelbrot défini par Benoît Mandelbrot, illustrant la richesse dynamique des transformations quadratiques.

Enfin, les quaternions introduits par William Rowan Hamilton étendent les complexes à la dimension 4, fournissant un cadre algébrique pour modéliser les rotations de l’espace. Leur généralisation par Arthur Cayley et Leonard Eugene Dickson mène aux octonions, structures non associatives illustrant les limites de la multiplication algébrique.

Chapitre 11. Analyse

Ce chapitre montre comment Python permet d’aborder concrètement les méthodes fondamentales de l’analyse numérique à partir des suites. Celles-ci servent depuis l’Antiquité à approcher des constantes : l’algorithme de Héron permet ainsi d’obtenir rapidement une valeur approchée de √2 par itération. Cette démarche est généralisée par des méthodes plus puissantes comme celle de Newton-Raphson, tandis que l’algorithme de Gauss-Salamin fournit une approximation particulièrement efficace de π grâce à la moyenne arithmético-géométrique introduite par Carl Friedrich Gauss.

Le calcul du logarithme de 2 peut être obtenu soit par des méthodes d’intégration, soit par la résolution numérique de l’équation $e^x = 2$, illustrant différentes approches : dichotomie, méthode de Newton ou méthode de la sécante. Ces techniques montrent comment les fonctions peuvent être manipulées comme objets numériques pour approcher leurs zéros.

Le chapitre aborde également le calcul trigonométrique à travers des algorithmes historiques comme la table des sinus construite par Aryabhata, ou l’algorithme CORDIC permettant de calculer sinus et cosinus à partir de la tangente.

Les notions de limite et de suite de Cauchy fournissent des critères d’arrêt pour les calculs itératifs, tandis que la dérivée est introduite comme une fonctionnelle reliant fonctions et approximations locales. Les recherches du XIXe siècle sur la dérivabilité apparaissent avec des exemples de fonctions continues mais non dérivables étudiées par Bernhard Riemann et Karl Weierstrass.

L’intégration numérique est ensuite abordée par différentes méthodes d’approximation : rectangles, trapèzes, milieux ou méthode de Simpson, améliorées par les quadratures de Gauss fondées sur des polynômes orthogonaux.

Enfin, le calcul différentiel est appliqué aux équations différentielles à l’aide du schéma d’Euler ou de méthodes plus précises comme celle de Carl Runge et Martin Kutta. L’ensemble illustre comment Python devient un outil d’expérimentation permettant d’approximer solutions, primitives ou aires, et de relier ainsi calcul numérique et interprétation géométrique.

Chapitre 12. Algèbre linéaire

Ce chapitre propose une approche géométrique de l’algèbre linéaire en Python en privilégiant la manipulation des vecteurs plutôt que le calcul matriciel, rendu plus délicat par l’usage du module numpy. À l’aide du module turtle, les vecteurs du plan sont modélisés par la classe Vec2D, permettant d’identifier points et vecteurs dans un repère affine.

Les opérations usuelles sur les vecteurs — addition, soustraction, multiplication par un scalaire — sont mises en œuvre pour calculer des milieux, des distances ou des vecteurs directeurs. Le produit scalaire permet d’accéder à des notions métriques comme l’angle entre deux vecteurs, tandis que le déterminant fournit un test de colinéarité et une interprétation géométrique en termes d’aire du parallélogramme engendré.

Ces outils rendent possible l’étude des droites du plan : tests d’alignement de points, équations vectorielles ou cartésiennes, et caractérisation de courbes algébriques. Le chapitre s’ouvre ensuite aux systèmes dynamiques dans le plan, en particulier sur le tore, où certaines transformations conservent les aires mais produisent des comportements pseudo-aléatoires proches du chaos.

En dimension 3, une classe Vec3D permet de généraliser ces notions : produit scalaire, produit vectoriel, colinéarité, orthogonalité ou coplanarité deviennent calculables. Ces outils s’appliquent à des problèmes géométriques comme l’alignement de points ou l’étude de configurations spatiales.

Enfin, une correspondance entre cercles du plan et points de l’espace est introduite : chaque cercle peut être représenté par un triplet de coordonnées satisfaisant une équation quadratique. Cette modélisation permet d’étudier des propriétés comme l’orthogonalité de cercles ou leur appartenance à un même faisceau, illustrant l’apport des structures vectorielles à la géométrie plane et hyperbolique.

Chapitre 13. Statistiques

Ce dernier chapitre montre comment Python devient un véritable laboratoire probabiliste et statistique. Tout commence avec les listes, structure de base pour manipuler des données numériques : construction par extension, compréhension ou ajouts successifs. Les fonctions intégrées (sorted, len, sum, min, max) permettent de calculer en quelques lignes médiane, moyenne, variance et écart-type, illustrant la simplicité d’une statistique descriptive à une variable.

La régression linéaire est ensuite abordée grâce à numpy et matplotlib : la fonction polyfit calcule la droite des moindres carrés, rendant concrète l’approximation affine d’un nuage de points et reliant géométrie analytique et traitement de données.

Le chapitre introduit alors les variables aléatoires via le module random. Les lois uniforme et gaussienne permettent de simuler le hasard, tandis que l’épreuve de Bernoulli mène naturellement à la loi binomiale. Les coefficients binomiaux sont calculés efficacement par programmation dynamique, idée popularisée par Richard Bellman. La loi binomiale est construite comme fonction paramétrée, ce qui permet de vérifier expérimentalement les formules d’espérance $E(X) = np$ et de variance $V(X) = np(1−p)$, dans le cadre axiomatique posé par Andrey Kolmogorov.

Une étude originale conclut le chapitre avec le jeu du divhasard, fondé sur un dé icosaédrique : la variable aléatoire étudiée associe à chaque face le nombre de ses diviseurs. La loi de probabilité est construite à l’aide de dictionnaires Python, puis représentée graphiquement. Simulations, espérance (3,3) et variance (2,31) sont calculées et comparées aux résultats théoriques — formule de variance déjà étudiée par Christiaan Huygens.

Le chapitre illustre ainsi une idée centrale de l’ouvrage : la programmation permet non seulement de calculer, mais d’expérimenter, de simuler et de vérifier les lois mathématiques avant même de les démontrer formellement.

4. Les points forts

Python comme outil pédagogique

L’ouvrage démystifie la programmation. On comprend que :
– programmer, c’est formaliser ;
– formaliser, c’est faire des mathématiques.

L’approche est résolument “hands-on” : le lecteur est invité à tester, modifier, expérimenter.

Richesse mathématique

La couverture est large et ambitieuse : arithmétique, analyse, probabilités, algèbre, logique des combinateurs…

Les références culturelles et historiques (clins d’œil à Monty Python, Gödel, etc.) apportent une dimension vivante et parfois humoristique.

Code court, exploitable

Les extraits proposés sont généralement courts, commentés, et directement utilisables en classe — ou facilement adaptables.

Par exemple, une simple fonction comme :

def imc(masse, taille):
    return masse / taille**2

peut devenir le point de départ d’une activité : modifier la fonction pour renvoyer une interprétation qualitative, discuter du statut d’un modèle, interroger la validité des seuils.

On perçoit bien ici l’idée centrale du livre : faciliter la compréhension des mathématiques à travers Python.

5. Quelques limites

L’ouvrage est exigeant.

Un enseignant totalement novice en Python pourra trouver certains passages techniques.

Certains chapitres (catégories, corps finis…) sont denses et relèvent davantage de la culture mathématique que de l’application immédiate en classe.

Mais ces choix font aussi sa force : le livre élève le niveau de réflexion et refuse la simplification excessive.

6. Pour qui, et comment l’utiliser ?

Pour qui ?
– Enseignants souhaitant intégrer Python de manière conceptuelle.
– Candidats aux concours.
– Formateurs organisant stages ou ateliers.
– Amateurs éclairés curieux du dialogue entre mathématiques et programmation.

Comment l’utiliser ?
– En formation initiale ou continue.
– En autoformation, en testant systématiquement les exemples.
– Comme réservoir d’idées pour des TP, des projets ou des prolongements culturels.

Conclusion

Python pour les (futurs) professeurs est bien plus qu’un manuel technique. C’est une invitation à repenser le lien entre expérimentation et démonstration, entre calcul et structure, entre code et concept.

En refusant le gadget et en assumant une vraie ambition mathématique, Alain Busser propose un ouvrage stimulant et inspirant. Pour un enseignant de mathématiques, la lecture ne fournit pas seulement des scripts : elle nourrit une réflexion sur notre manière d’enseigner à l’ère du numérique.

Et c’est sans doute là sa contribution la plus précieuse.