Introduction

1 Introduction

Ce cours rassemble l’ensemble du contenu du cours Python pour la data science que je donne à l’ENSAE depuis 2020¹. Environ 190 élèves suivent ce cours chaque année. L’année 2024 a permis l’arrivée progressive d’une version anglophone équivalente à la version française visant à servir de cours d’introduction à la data science pour les instituts statistiques européens suite à un appel à projets européen.

Ce site (pythonds.linogaliana.fr/) est le point d’entrée principal du cours. Il rassemble l’ensemble des contenus faits en cours dans le cadre de travaux pratiques ou proposés en complément à des fins de formation en continue. Ce cours est open source et j’accueille avec plaisir les suggestions d’amélioration sur Github ou par le biais des commentaires en bas de chaque page.

Python étant un langage vivant et très dynamique, les pratiques évoluent et ce cours s’adapte en continu pour tenir compte de l’écosystème mouvant de la data science, en essayant néanmoins de distinguer les évolutions pérennes des pratiques des effets de mode.

Quelques éléments supplémentaires sont disponibles dans les slides introductives. Des éléments plus avancés sont présents dans un autre cours consacré à la mise en production de projets data science que je donne avec Romain Avouac en dernière année de l’ENSAE (ensae-reproductibilite.github.io/website).

Dérouler les slides ou consulter celles-ci sur plein écran.

Architecture du site web

Ce cours présente des tutoriels et des exercices complets qui peuvent être lus depuis ce site ou édités et testés dans un environnement interactif de type Jupyter Notebook (voir prochain chapitre pour plus de détails).

Chaque page est structurée sous la forme d’un problème concret et présente la démarche générique pour résoudre ce problème général. Tous les exemples s’appuient sur de l’open data et sont reproductibles.

Vous pouvez naviguer dans l’architecture du site via la table des matières ou par les liens vers le contenu antérieur ou postérieur à la fin de chaque page. Certaines parties, notamment celle consacrée à la modélisation, proposent des exemples fil-rouge pour illustrer la démarche, et les différentes approches possibles d’un même problème, de manière plus extensive.

2 Pourquoi faire du Python ?

Python, dont le logo assez reconnaissable prend la forme de , est un langage qui a déjà plus de trente ans mais qui a connu, au cours de la décennie 2010, une nouvelle jeunesse du fait de l’engouement autour de la data science.

Python, plus que tout autre langage informatique, réunit des communautés aussi diverses que des statisticiens, des développeurs, des gestionnaires d’applications ou d’infrastructures informatiques, des lycéens - Python est au programme du bac français depuis quelques années - ou des chercheurs dans des champs à la fois théoriques et appliqués.

Contrairement à beaucoup de langages informatiques qui fédèrent une communauté assez homogène, Python est parvenu à réunir largement grâce à quelques principes centraux : la lisibilité du langage, la simplicité à utiliser des modules, la simplicité à l’associer à des langages plus performants pour certaines tâches données, l’énorme volume de documentation disponible en ligne… Être le deuxième meilleur langage pour réaliser telle ou telle tâche peut ainsi être une source de succès lorsque la concurrence ne dispose pas d’un éventail aussi large d’avantages.

Le succès de Python, de par sa nature de langage couteau-suisse, est indissociable de l’émergence du profil du data scientist, profil capable de s’intégrer à différents niveaux dans la valorisation de données. Davenport et Patil (2012), dans la Harvard Business Review, ont ainsi pu parler du “boulot le plus sexy du 21e siècle” et ont pu, dix ans plus tard, faire un panorama complet de l’évolution des compétences attendues d’un data scientist dans la même revue (Davenport et Patil 2022). Ce ne sont d’ailleurs pas que les data scientists qui ont vocation à pratiquer Python ; dans le halo des emplois autour de la donnée (data scientist, data engineer, ML engineer…), Python fait office de tour de Babel permettant la communication entre ces différents profils interdépendants.

La richesse de Python permet de l’utiliser dans toutes les phases du traitement de la donnée, de sa récupération et structuration à partir de sources diverses à sa valorisation. Par le prisme de la data science, nous verrons que Python est un très bon candidat pour assister les data scientists dans tous les aspects du travail quotidien leur permettant de tirer de la valeur de gisements hétérogènes de données. Ce cours a néanmoins l’ambition, peut-être illusoire, d’être plus qu’un énième cours d’introduction au langage Python: il s’agit plutôt d’un cours d’introduction à la data science s’appuyant sur Python. En fait, apprendre Python est un prétexte pour apprendre à avoir les bons réflexes quand on est confronté à un jeu de données.

Ce cours introduit différents outils qui permettent de mettre en relation grâce à Python des données à des concepts théoriques issus de la statistique ou des sciences économiques et sociales. Néanmoins, ce cours va au-delà d’une simple introduction au langage et revient régulièrement sur les apports, mais aussi les limites, du langage pour répondre à des besoins opérationnels ou scientifiques.

3 Pourquoi faire du Python pour l’analyse de données ?

Cette question est un peu différente car si Python est un langage commun pour découvrir la programmation informatique du fait de sa simplicité d’usage, comment se fait-il qu’il se soit imposé comme le langage dominant dans l’écosystème de la data et de l’IA ?

Python est d’abord connu, dans le monde de la data science, pour avoir fourni très tôt les outils utiles à l’entraînement d’algorithmes de machine learning, avant même que cette approche devienne incontournable. Certes, le succès de Scikit Learn, de Tensorflow ou plus récemment de PyTorch dans la communauté de la data science ont beaucoup contribué à l’adoption de Python². Cependant, réduire Python à quelques librairies de machine learning serait réducteur tant il s’agit d’un véritable couteau-suisse pour les data scientists, les social scientists, les économistes ou plus généralement pour les praticiens de la donnée quelque soit leur champ d’application. La success story de Python n’est pas seulement le fait d’avoir proposé des librairies de machine learning à un moment adéquat: ce langage dispose de réels atouts pour de nouveaux praticiens de la donnée.

L’intérêt de Python est son rôle central dans un écosystème plus large autour d’outils puissants, flexibles et open-source. Il appartient, comme le langage , à cette classe de langages pouvant servir au quotidien pour des tâches très diversifiées. Dans de nombreux domaines explorés dans ce cours, Python est, de loin, le langage informatique proposant l’écosystème le plus complet et le plus simple d’accès. Contrairement à d’autres langages très populaires, notamment JavaScript ou Rust, la courbe d’appentissage de Python est très légère et on peut rapidement être opérationnel et produire du code de qualité, si on a les bons réflexes (que ce cours, ainsi que celui de mise en production, ambitionnent de donner).

En plus des projets d’IA (Note 3.1), Python est incontournable dès lors qu’on désire récupérer des données par le biais d’API ou de web scraping³, deux approches que nous explorerons dans la première partie du cours. Dans les domaines de l’analyse de données tabulaires⁴, de la publication de contenu web ou de la production de graphiques, Python présente un écosystème de plus en plus similaire à du fait de l’investissement croissant de Posit et sa traduction en Python des librairies qui ont fait le succès de dans le domaine de l’analyse de données (ggplot notamment)

Note 3.1: Pourquoi parler si peu d’IA dans un cours de Python ?

Bien qu’une partie conséquente de ce cours évoque les problématiques de machine learning et d’algorithmie, je rechigne généralement à rentrer dans la mode, particulièrement forte depuis fin 2022 et la sortie de ChatGPT, de tout dénommer IA.

En premier lieu car le terme est souvent mal défini, galvaudé et instrumentalisé par des acteurs qui profitent de sa charge symbolique forte, lié à notre imaginaire de la science fiction, pour vendre un produit “miracle” ou au contraire activer nos peurs.

Mais aussi car ce terme recouvre énormément de méthodes potentielles si on accepte une définition large. Les parties modélisation et NLP de ce cours, celles les plus proches du sujet IA, se concentrent sur les méthodes d’apprentissage. Si on reprend les définitions suivantes Russell et Norvig (2020) ou de l’IA Act Européen, on peut faire rentrer beaucoup plus que ces méthodes dans le concept d’intelligence artificielle:

« L’étude des agents [intelligents] qui reçoivent des perceptions de l’environnement et agissent. Chacun de ces agents est mis en oeuvre par une fonction qui associe les perceptions aux actions, et nous couvrons différentes manières de de représenter ces fonctions, telles que les systèmes de production, les agents réactifs, les planificateurs logiques, les réseaux de neurones et les systèmes de gestion de l’information et les systèmes de théorie de la décision »

Russell et Norvig (2020)

« Système basé sur une machine qui est conçu pour fonctionner avec différents niveaux d’autonomie et qui peut faire preuve d’adaptabilité après son déploiement, et qui, pour des objectifs explicites ou implicites, déduit, à partir des données qu’il reçoit, comment générer des résultats tels que des prédictions, du contenu, des recommandations ou des décisions qui peuvent influencer des environnements physiques ou virtuels »

AI Act européen

Pour en apprendre plus sur ce sujet, voici une présentation que j’ai faite sur le sujet de l’IA en 2024:

Dérouler les slides ou consulter celles-ci sur plein écran.

Enfin, la question est également pédagogique. Quand on parle d’IA depuis 2023, on pense à l’IA générative. Je pense que pour comprendre le fonctionnement de cette approche, radicalement différent d’autres paradigmes, et être capable de mettre en oeuvre des projets d’IA générative porteurs de valeur, il faut avoir des notions sur les apports et les limites de l’approche scientifique du machine learning. Sinon, on se retrouve à construire des usines à gaz pour des besoins simples ou à être incapables d’évaluer l’apport d’une approche générative par rapport à d’autres approches. Ce cours étant introductif, j’ai donc choisi de me concentrer sur le machine learning et du NLP basique, là encore à un niveau assez introductifs mais néanmoins déjà un peu creusés, et laisser aux curieux le soin de s’autoformer sur les sujets genIA.

Néanmoins, il ne s’agit pas, par ces éléments, de rentrer dans la guéguerre stérile vs Python. Ces deux langages ayant beaucoup plus de points de convergence que de divergence, il est très simple de transposer les bonnes pratiques d’un langage à l’autre. Il s’agit d’un point qui est développé plus amplement dans le cours plus avancé que je donne avec Romain Avouac en dernière année d’ENSAE : ensae-reproductibilite.github.io/website.

A terme, les data scientists et chercheurs en sciences sociales ou en économie utiliseront de manière presque indifférente, et en alternance, ou Python. Ce cours présentera ainsi régulièrement des analogies avec pour aider les personnes découvrant Python, mais connaissant déjà bien , à mieux comprendre certains messages.

4 Pourquoi apprendre Python quand il existe des IA génératrices de code ?

Les assistants de code, notamment Copilot et ChatGPT, ont changé à jamais le développement de code. Ces outils font maintenant parti des outils quotidiens des data scientists et offrent beaucoup de confort car ils peuvent, à l’aide d’instructions plus ou moins claires, générer du code Python. Et ces IA ayant étaient entraînées à partir de l’ensemble du code présent sur internet, et parfois spécialisées à répondre à des problèmes de développement, elles aident beaucoup. L’ambition du vibe coding est d’aller une étape plus loin dans ce processus en renforçant la prise d’initiative des LLM qui ne passerait plus par l’intermédiaire de l’humain pour accéder aux ressources de calcul qui permettent d’exécuter le code proposé.

Puisque maintenant les IA génèrent du code, pourquoi continuer à apprendre à coder ?

Car coder ce n’est pas juste produire des lignes de code, c’est se confronter à un problème, adopter une stratégie par étape pour y répondre, réfléchir à plusieurs solutions possibles et choisir la meilleure en arbitrant entre plusieurs objectifs (vitesse, simplicité, etc.), tester et corriger, etc. Le code est un outil au service d’un problème d’ingenieurie. Les IA savent très bien coder, elles savent relier un problème à des ressources sur lesquelles elles ont appris et savent bien transposer un problème rencontré dans un autre langage à Python.

Mais encore faut-il savoir formuler le problème, savoir juger de la qualité de la réponse du LLM, être capable de remettre en question la proposition de l’assistant pour corriger une erreur ou obtenir une réponse plus satisfaisante. Les LLM sont une recherche google très raffinée: si vous n’avez pas les bons mots clés pour faire une recherche Google, votre recherche sera décevante. Il en va de même avec les LLM même si l’aspect conversationnel en langage naturel réduit la barrière à l’entrée.

La confrontation à un jeu de données relève avant tout d’une démarche d’ingénierie. Le code n’est pas une fin en soi, mais un outil au service d’un raisonnement structuré, visant à résoudre un problème concret. Comme un ingénieur qui conçoit un pont à partir d’un besoin de traversée, le data scientist part d’un objectif opérationnel — construire un algorithme de sélection, mesurer l’impact d’un lancement produit, prédire une évolution de ventes — pour le formuler de manière exploitable. Cela implique de traduire des concepts scientifiques ou business en questions analytiques, puis de décomposer le problème en étapes logiques, chacune traduite en instructions que la machine peut exécuter.

Dans ce cadre, un LLM peut jouer un rôle d’assistant, mais seulement si le problème est bien posé. Si les étapes sont floues ou mal définies, la réponse du modèle sera approximative, voire inutile. Sur une tâche standard, le résultat pourra sembler correct, mais sur une question plus spécifique, il faudra souvent affiner, reformuler, itérer… et parfois ne jamais obtenir de réponse satisfaisante. Non pas parce que le modèle est mauvais, mais parce que l’ingénierie du problème en amont fait toute la différence⁵.

Une dernière raison pour laquelle se contenter d’une IA de code sans recul critique est que ces dernières sont forcément en retard par rapport aux usages puisqu’elles ont été entraînées sur des données passées. L’écosystème Python est très dynamique et, même si les IA des principaux fournisseurs de services sont fréquemment réentrainées et peuvent maintenant accéder à internet pour rafraichir leurs connaissances, certaines librairies peuvent rapidement s’imposer dans leur domaine.

Par exemple, en cette année 2025, uv a connu une adoption rapide, comme ruff l’année d’avant. Il faudra encore un peu de temps pour que les IA génératives proposent d’elles-mêmes ce gestionnaire d’environnement plutôt que poetry. L’existence d’IA génératives ne dispense donc pas, comme avant, d’avoir une veille technique active et d’être vigilant sur l’évolution des pratiques.

5 Objectifs du cours

5.1 Initier à la démarche de la data science

Ce cours s’adresse aux praticiens de la data science, discipline entendue ici au sens large comme la combinaison de techniques issues des mathématiques, de la statistique et de l’informatique pour produire de la connaissance utile à partir de données. Comme la data science n’est pas uniquement une discipline scientique mais vise également à fournir un ensemble d’outils pour répondre à des objectifs opérationnels, l’apprentissage du principal outil nécessaire à l’acquisition de connaissances en data science, à savoir le langage Python, est également l’occasion d’évoquer la démarche scientifique rigoureuse à adopter face à des données. Ce cours a pour objectif de présenter la démarche face à un jeu de données, les problèmes rencontrés, les solutions pour les surmonter et les implications que ces dernières peuvent avoir. Il ne s’agit donc pas que d’un cours sur un outil technique, désincarné de problématiques scientifiques.

Faut-il avoir un background en mathématiques pour ce cours ?

Ce cours présuppose qu’on désire faire un usage de Python intense en données dans un cadre statistique rigoureux. Il ne revient que de manière secondaire sur les fondements statistiques ou algorithmiques derrière certaines des techniques évoquées, souvent l’objet d’enseignements dédiés, notamment à l’ENSAE.

Ne pas connaître ces notions n’empêche ainsi pas de comprendre le contenu de ce site web car les concepts plus avancés sont généralement présentés à part, dans des encadrés dédiés. La facilité d’usage de Python évite de devoir programmer soi-même un modèle, ce qui rend possible l’application de modèles dont on n’est pas expert. La connaissance des modèles sera plutôt nécessaire dans l’interprétation des résultats.

Pour autant, même s’il est relativement facile d’utiliser des modèles complexes avec Python, il est fort utile d’avoir du recul sur ceux-ci avant de se lancer dans une démarche de modélisation. Il s’agit de l’une des raisons pour lesquelles la modélisation arrive si tardivement dans ce cours: en plus de faire appel à des concepts statistiques avancés, il est nécessaire, pour produire une modélisation pertinente, d’avoir appréhendé les faits stylisés dans nos données. Bien comprendre la structure des données et leur adéquation avec les hypothèses d’un modèle est indispensable pour construire une modélisation de qualité.

5.2 Reproductibilité

Ce cours donne une place centrale à la notion de reproductibilité. Cette exigence se traduit de diverses manières dans cet enseignement, en premier lieu en permettant que tous les exemples et exercices de ce cours soient testés par le biais de notebooks Jupyter⁶.

L’ensemble du contenu du site web est reproductible dans des environnements informatiques divers. Il est bien sûr possible de copier-coller les morceaux de code présents dans ce site, grâce au bouton présent au dessus des exemples de code:

1x = "Essayez de me copier-coller"

1

Cliquez sur le bouton pour copier ce contenu et le coller ailleurs.

Néanmoins, comme ce site présente de nombreux exemples, les allers et retours entre un environnement de test de Python et celui-ci pourraient être pénibles. Chaque chapitre est donc facilement récupérable sous forme de notebook Jupyter grâce à des boutons au début de chaque page. Voici, par exemple, ces boutons pour le premier chapitre consacré à Pandas :

Les recommandations concernant les environnements à privilégier pour utiliser ces notebooks sont reportées au prochain chapitre.

L’exigence de reproductibilité se manifeste également dans le choix des exemples pris pour ce cours. L’ensemble du contenu de ce site s’appuie sur des données ouvertes, qu’il s’agisse de données françaises (principalement issues de la plateforme centralisatrice data.gouv ou du site web de l’Insee) ou de données américaines. Les résultats sont donc reproductibles pour quelqu’un disposant d’un environnement identique⁷.

Note

Des chercheurs américains ont pu parler de crise de la reproductibilité dans le domaine du machine learning (Kapoor et Narayanan 2022). Les dérives de l’écosystème de la publication scientifique et les enjeux économiques derrière les publications académiques dans le domaine du machine learning ont une place privilégiée parmi les facteurs pouvant l’expliquer.

Néanmoins, l’enseignement universitaire porte également une responsabilité dans ce domaine. Les étudiants et chercheurs ne sont pas formés à ces sujets et s’ils n’adoptent pas cette exigence tôt dans leur parcours, ils n’y seront plus forcément incités ultérieurement. Pour cette raison, en plus de former à Python et à la data science, ce cours introduit à l’usage du logiciel de contrôle de version Git dans une partie dédiée.

Tous les projets des élèves doivent être open source, ce qui est l’une des meilleures manières, pour un enseignant, de trouver une consigne pour que les élèves produisent un code de qualité.

5.3 Évaluation

Les élèves de l’ENSAE valident le cours grâce à un projet approfondi. Les éléments relatifs à l’évaluation du cours, ainsi qu’une liste des projets déjà effectués, sont disponibles dans la section Évaluation.

6 Plan du cours

Ce cours est une introduction aux enjeux de la data science à travers l’apprentissage du langage Python. Comme le terme “data science” l’indique, une partie importante de ce cours est consacrée au travail sur les données: récupération, structuration, exploration, mise en relation.

C’est l’objet de la première partie du cours “Manipuler des données” qui sert de fondement au reste du cours. Malheureusement, de nombreuses formations en data science, statistiques appliquées ou sciences économiques et sociales, font l’impasse sur cette part du travail des data scientists - qu’on appelle parfois “data wrangling” ou “feature engineering” - qui, en plus de représenter une part importante du temps de travail des data scientists, est indispensable pour construire un modèle pertinent.

L’objectif de cette partie est d’illustrer les enjeux liés à la récupération de plusieurs types de sources de données et à leur exploitation par le biais de Python. Les exemples seront diversifiés, pour illustrer la richesse des données qui peuvent être analysées avec Python: statistiques d’émissions communales de \(CO_2\) en France, données de transactions immobilières, diagnostics énergétiques des logements, données de fréquentation des stations vélib…

La deuxième partie est consacrée à la production de visualisations avec Python. Après avoir récupéré et nettoyé des données, on désire généralement synthétiser celles-ci par le biais de tableaux, de productions graphiques ou de cartes. Cette partie est une introduction rapide à ce sujet (“Communiquer avec Python”). Assez introductive, l’objectif de cette partie est surtout de donner quelques notions qui sont consolidées par la suite.

La troisième partie est consacrée à la modélisation à travers l’exemple fil rouge de la science électorale (“Modéliser avec Python”). L’objectif de cette partie est d’illustrer la démarche scientifique du machine learning, les choix méthodologiques et techniques afférents et ouvrir vers les enjeux suivants qui seront évoqués dans la suite du cursus universitaire.

La quatrième partie du cours fait un pas de côté pour se consacrer aux enjeux spécifiques liés à l’exploitation des données textuelles. Il s’agit du chapitre d’“Introduction au Natural Language Processing (NLP)” avec Python”. Ce champ de recherche étant particulièrement actif, il ne s’agit que d’une introduction au sujet. Pour aller plus loin, se référer à Russell et Norvig (2020), chapitre 24.

Ce chapitre propose aussi une partie consacrée au contrôle de version avec le logiciel Git (Découvrir Git). Pourquoi proposer ce contenu dans le cadre d’un cours de Python ? Car apprendre Git permettra de produire de meilleurs codes Python, de les échanger, voire même de les tester dans des environnements reproductibles ou de mettre à disposition les résultats en ligne (c’est une utilisation plus avancée, objet du cours de mise en production). Ce pas de côté dans l’apprentissage de Python est très utile, a fortiori dans un monde où Github sert de vitrine et où les entreprises et administrations exigent, à juste titre, que leurs data scientists sachent faire du Git.

Références

Davenport, Thomas H, et DJ Patil. 2012. « Data scientist, the sexiest job of the 21st century ». Harvard business review 90 (5): 70‑76. https://hbr.org/2012/10/data-scientist-the-sexiest-job-of-the-21st-century.

———. 2022. « Is data scientist still the sexiest job of the 21st century? » Harvard Business Review 90.

Kapoor, Sayash, et Arvind Narayanan. 2022. « Leakage and the Reproducibility Crisis in ML-based Science ». arXiv. https://doi.org/10.48550/ARXIV.2207.07048.

Russell, Stuart J., et Peter Norvig. 2020. Artificial Intelligence: A Modern Approach (4th Edition). Pearson. http://aima.cs.berkeley.edu/.

Informations additionnelles

environment files have been tested on.

Latest built version: 2025-06-05

Python version used:

'3.12.3 (main, Feb  4 2025, 14:48:35) [GCC 13.3.0]'

Package	Version
affine	2.4.0
aiobotocore	2.22.0
aiohappyeyeballs	2.6.1
aiohttp	3.11.18
aioitertools	0.12.0
aiosignal	1.3.2
altair	5.4.1
annotated-types	0.7.0
anyio	4.9.0
appdirs	1.4.4
argon2-cffi	25.1.0
argon2-cffi-bindings	21.2.0
arrow	1.3.0
asttokens	3.0.0
async-lru	2.0.5
attrs	25.3.0
babel	2.17.0
beautifulsoup4	4.13.4
black	24.8.0
bleach	6.2.0
blis	1.3.0
boto3	1.37.3
botocore	1.37.3
branca	0.8.1
Brotli	1.1.0
cartiflette	0.0.3
Cartopy	0.24.1
catalogue	2.0.10
cattrs	24.1.3
certifi	2025.4.26
cffi	1.17.1
charset-normalizer	3.4.2
click	8.2.1
click-plugins	1.1.1
cligj	0.7.2
cloudpathlib	0.21.1
comm	0.2.2
commonmark	0.9.1
confection	0.1.5
contextily	1.6.2
contourpy	1.3.2
cycler	0.12.1
cymem	2.0.11
dataclasses-json	0.6.7
debugpy	1.8.14
decorator	5.2.1
defusedxml	0.7.1
diskcache	5.6.3
duckdb	1.3.0
et_xmlfile	2.0.0
executing	2.2.0
fastexcel	0.14.0
fastjsonschema	2.21.1
fiona	1.10.1
folium	0.19.6
fontawesomefree	6.6.0
fonttools	4.58.0
fqdn	1.5.1
frozenlist	1.6.0
fsspec	2025.5.0
geographiclib	2.0
geopandas	1.0.1
geoplot	0.5.1
geopy	2.4.1
graphviz	0.20.3
great-tables	0.12.0
greenlet	3.2.2
h11	0.16.0
htmltools	0.6.0
httpcore	1.0.9
httpx	0.28.1
httpx-sse	0.4.0
idna	3.10
imageio	2.37.0
importlib_metadata	8.7.0
importlib_resources	6.5.2
inflate64	1.0.1
ipykernel	6.29.5
ipython	9.3.0
ipython_pygments_lexers	1.1.1
ipywidgets	8.1.7
isoduration	20.11.0
jedi	0.19.2
Jinja2	3.1.6
jmespath	1.0.1
joblib	1.5.1
json5	0.12.0
jsonpatch	1.33
jsonpointer	3.0.0
jsonschema	4.23.0
jsonschema-specifications	2025.4.1
jupyter	1.1.1
jupyter-cache	1.0.0
jupyter_client	8.6.3
jupyter-console	6.6.3
jupyter_core	5.7.2
jupyter-events	0.12.0
jupyter-lsp	2.2.5
jupyter_server	2.16.0
jupyter_server_terminals	0.5.3
jupyterlab	4.4.3
jupyterlab_pygments	0.3.0
jupyterlab_server	2.27.3
jupyterlab_widgets	3.0.15
kaleido	0.2.1
kiwisolver	1.4.8
langchain	0.3.25
langchain-community	0.3.9
langchain-core	0.3.61
langchain-text-splitters	0.3.8
langcodes	3.5.0
langsmith	0.1.147
language_data	1.3.0
lazy_loader	0.4
loguru	0.7.3
lxml	5.4.0
mapclassify	2.8.1
marisa-trie	1.2.1
Markdown	3.8
markdown-it-py	3.0.0
MarkupSafe	3.0.2
marshmallow	3.26.1
matplotlib	3.10.3
matplotlib-inline	0.1.7
mdurl	0.1.2
mercantile	1.2.1
mistune	3.1.3
mizani	0.11.4
multidict	6.4.4
multivolumefile	0.2.3
murmurhash	1.0.13
mypy_extensions	1.1.0
narwhals	1.40.0
nbclient	0.10.0
nbconvert	7.16.6
nbformat	5.10.4
nest-asyncio	1.6.0
networkx	3.4.2
nltk	3.9.1
notebook	7.4.3
notebook_shim	0.2.4
numpy	2.2.6
openpyxl	3.1.5
orjson	3.10.18
overrides	7.7.0
OWSLib	0.33.0
packaging	24.2
pandas	2.2.3
pandocfilters	1.5.1
parso	0.8.4
pathspec	0.12.1
patsy	1.0.1
Pebble	5.1.1
pexpect	4.9.0
pillow	11.2.1
pip	25.1.1
platformdirs	4.3.8
plotly	6.1.2
plotnine	0.13.6
polars	1.8.2
preshed	3.0.9
prometheus_client	0.22.1
prompt_toolkit	3.0.51
propcache	0.3.1
psutil	7.0.0
ptyprocess	0.7.0
pure_eval	0.2.3
py7zr	0.22.0
pyarrow	17.0.0
pybcj	1.0.6
pycparser	2.22
pycryptodomex	3.23.0
pydantic	2.11.5
pydantic_core	2.33.2
pydantic-settings	2.9.1
Pygments	2.19.1
pynsee	0.1.8
pyogrio	0.11.0
pyparsing	3.2.3
pyppmd	1.1.1
pyproj	3.7.1
pyshp	2.3.1
python-dateutil	2.9.0.post0
python-dotenv	1.0.1
python-json-logger	3.3.0
python-magic	0.4.27
pytz	2025.2
pywaffle	1.1.1
PyYAML	6.0.2
pyzmq	26.4.0
pyzstd	0.17.0
rasterio	1.4.3
referencing	0.36.2
regex	2024.11.6
requests	2.32.3
requests-cache	1.2.1
requests-toolbelt	1.0.0
retrying	1.3.4
rfc3339-validator	0.1.4
rfc3986-validator	0.1.1
rich	14.0.0
rpds-py	0.25.1
s3fs	2025.5.0
s3transfer	0.11.3
scikit-image	0.24.0
scikit-learn	1.6.1
scipy	1.13.0
seaborn	0.13.2
Send2Trash	1.8.3
setuptools	80.8.0
shapely	2.1.1
shellingham	1.5.4
six	1.17.0
smart-open	7.1.0
sniffio	1.3.1
soupsieve	2.7
spacy	3.8.4
spacy-legacy	3.0.12
spacy-loggers	1.0.5
SQLAlchemy	2.0.41
srsly	2.5.1
stack-data	0.6.3
statsmodels	0.14.4
tabulate	0.9.0
tenacity	9.1.2
terminado	0.18.1
texttable	1.7.0
thinc	8.3.6
threadpoolctl	3.6.0
tifffile	2025.5.24
tinycss2	1.4.0
topojson	1.9
tornado	6.5.1
tqdm	4.67.1
traitlets	5.14.3
typer	0.15.3
types-python-dateutil	2.9.0.20250516
typing_extensions	4.13.2
typing-inspect	0.9.0
typing-inspection	0.4.1
tzdata	2025.2
Unidecode	1.4.0
uri-template	1.3.0
url-normalize	2.2.1
urllib3	2.4.0
wasabi	1.1.3
wcwidth	0.2.13
weasel	0.4.1
webcolors	24.11.1
webdriver-manager	4.0.2
webencodings	0.5.1
websocket-client	1.8.0
widgetsnbextension	4.0.14
wordcloud	1.9.3
wrapt	1.17.2
xlrd	2.0.1
xyzservices	2025.4.0
yarl	1.20.0
yellowbrick	1.5
zipp	3.21.0

View file history

md`Ce fichier a été modifié __${table_commit.length}__ fois depuis sa création le ${creation_string} (dernière modification le ${last_modification_string})`

creation = d3.min(
  table_commit.map(d => new Date(d.Date))
)

last_modification = d3.max(
  table_commit.map(d => new Date(d.Date))
)

creation_string = creation.toLocaleString("fr", {
  "day": "numeric",
  "month": "long",
  "year": "numeric"
})

last_modification_string = last_modification.toLocaleString("fr", {
  "day": "numeric",
  "month": "long",
  "year": "numeric"
})

html`<div>${git_history_table}</div>`

html`<div>${git_history_plot}</div>`

SHA	Date	Author	Description
ba2663fa	2025-06-04 15:39:53	Lino Galiana	Améliore l’intro (#608)
3f1d2f3f	2025-03-15 15:55:59	Lino Galiana	Fix problem with uv and malformed files (#599)
388fd975	2025-02-28 17:34:09	Lino Galiana	Colab again and again… (#595)
488780a4	2024-09-25 14:32:16	Lino Galiana	Change badge (#556)
5d15b063	2024-09-23 15:39:40	lgaliana	Handling badges problem
f8b04136	2024-08-28 15:15:04	Lino Galiana	Révision complète de la partie introductive (#549)
0908656f	2024-08-20 16:30:39	Lino Galiana	English sidebar (#542)
a987feaa	2024-06-23 18:43:06	Lino Galiana	Fix broken links (#506)
69a45850	2024-06-12 20:02:14	Antoine Palazzolo	correct link (#502)
005d89b8	2023-12-20 17:23:04	Lino Galiana	Finalise l’affichage des statistiques Git (#478)
16842200	2023-12-02 12:06:40	Antoine Palazzolo	Première partie de relecture de fin du cours (#467)
1f23de28	2023-12-01 17:25:36	Lino Galiana	Stockage des images sur S3 (#466)
69cf52bd	2023-11-21 16:12:37	Antoine Palazzolo	[On-going] Suggestions chapitres modélisation (#452)
a7711832	2023-10-09 11:27:45	Antoine Palazzolo	Relecture TD2 par Antoine (#418)
e8d0062d	2023-09-26 15:54:49	Kim A	Relecture KA 25/09/2023 (#412)
154f09e4	2023-09-26 14:59:11	Antoine Palazzolo	Des typos corrigées par Antoine (#411)
6178ebeb	2023-09-26 14:18:34	Lino Galiana	Change quarto project type (#409)
9a4e2267	2023-08-28 17:11:52	Lino Galiana	Action to check URL still exist (#399)
80823022	2023-08-25 17:48:36	Lino Galiana	Mise à jour des scripts de construction des notebooks (#395)
3bdf3b06	2023-08-25 11:23:02	Lino Galiana	Simplification de la structure 🤓 (#393)
dde3e934	2023-07-21 22:22:05	Lino Galiana	Fix bug on chapter order (#385)
2dbf8533	2023-07-05 11:21:40	Lino Galiana	Add nice featured images (#368)
f21a24d3	2023-07-02 10:58:15	Lino Galiana	Pipeline Quarto & Pages 🚀 (#365)

git_history_table = Inputs.table(
  table_commit,
  {
    format: {
      SHA: x => md`[${x}](${github_repo}/commit/${x})`,
      Description: x => md`${replacePullRequestPattern(x, github_repo)}`,
      /*Date: x => x.toLocaleString("fr", {
        "month": "numeric",
        "day": "numeric",
        "year": "numeric"
        })
      */
    }
  }
)

git_history_plot = Plot.plot({
  marks: [
    Plot.ruleY([0], {stroke: "royalblue"}),
    Plot.dot(
          table_commit,
          Plot.pointerX({x: (d) => new Date(d.date), y: 0, stroke: "red"})),
    Plot.dot(table_commit, {x: (d) => new Date(d.Date), y: 0, fill: "royalblue"})
  ]
})

function replacePullRequestPattern(inputString, githubRepo) {
    // Use a regular expression to match the pattern #digit
    var pattern = /#(\d+)/g;

    // Replace the pattern with ${github_repo}/pull/#digit
    var replacedString = inputString.replace(pattern, '[#$1](' + githubRepo + '/pull/$1)');

    return replacedString;
}

github_repo = "https://github.com/linogaliana/python-datascientist"

table_commit = {

// Get the HTML table by its class name
var table = document.querySelector('.commit-table');

// Check if the table exists
if (table) {
    // Initialize an array to store the table data
    var dataArray = [];

    // Extract headers from the first row
    var headers = [];
    for (var i = 0; i < table.rows[0].cells.length; i++) {
        headers.push(table.rows[0].cells[i].textContent.trim());
    }

    // Iterate through the rows, starting from the second row
    for (var i = 1; i < table.rows.length; i++) {
        var row = table.rows[i];
        var rowData = {};

        // Iterate through the cells in the row
        for (var j = 0; j < row.cells.length; j++) {
            // Use headers as keys and cell content as values
            rowData[headers[j]] = row.cells[j].textContent.trim();
        }

        // Push the rowData object to the dataArray
        dataArray.push(rowData);
    }
  }

  return dataArray

}

// Get the element with class 'git-details'
{
  var gitDetails = document.querySelector('.commit-table');

  // Check if the element exists
  if (gitDetails) {
      // Hide the element
      gitDetails.style.display = 'none';
  }
}

Plot = require('@observablehq/plot@0.6.12/dist/plot.umd.min.js')

Notes de bas de page

1. Ce cours était auparavant donné par Xavier Dupré.

2. Scikit Learn est une librairie développée par les laboratoires de recherche publique français de l’INRIA depuis 2007. C’est un projet open source depuis le début. Le projet est désormais maintenu par :probabl., une startup dédiée à la gestion du projet open source Scikit et tout son écosystème associé qui rassemble une partie des équipes de recherche de l’INRIA qui a a participé au développement de l’écosystème incontournable du machine learning.

   Tensorflow est une librairie initialement développée par Google pour leurs besoins internes, celle-ci a été rendue publique en 2015. Bien que moins de moins en moins utilisée, notamment du fait de la popularité de PyTorch, cette librairie a eu une influence importante dans les années 2010 en favorisant l’usage des réseaux de neurone dans la recherche ou pour l’exploitation à des fins opérationnelles.

   PyTorch est une librairie développée par Meta depuis 2018 et rattachée depuis 2022 à la PyTorch foundation. Il s’agit aujourd’hui du principal framework pour entraîner des réseaux de neurones.

3. Dans ces deux domaines, le concurrent le plus sérieux pour Python est Javascript. Néanmoins, la communauté autour de ce dernier langage est plus orientée autour des problématiques de développement web que de data science.

4. Les données tabulaires sont des données structurées, organisées, comme leur nom l’indique, sous forme de tableau permettant de mettre en correspondance des observations avec des variables. Cette structuration se distingue d’autres types de données plus complexes: textes libres, images, sons, vidéos… Dans le domaine des données non structurées, Python est le langage d’analyse hégémonique. Dans le domaine des données tabulaires, l’avantage compétitif de Python est moindre, notamment par rapport à , mais ces deux langages proposent un noyau de fonctionnalités assez similaires. Nous aurons l’occasion de régulièrement faire le parallèle entre ces deux langages lors des chapitres consacrés à la librairie Pandas.

5. On this topic, see Thomas Wolf’s blog post The Einstein AI model. Although the post focuses on disruptive innovation and pays less attention to incremental progress, it’s insightful in understanding that LLMs—despite bold predictions from tech influencers—are still just tools. They may excel at standardized tasks, but for now, they remain assistants.

6. Un notebook est un environnement interactif qui permet d’écrire et d’exécuter du code en direct. Il combine, dans un seul document, du texte, du code qui peut être exécuté et dont les sorties s’affichent après calculs. C’est extrêmement pratique pour l’apprentissage du langage Python. Pour plus de détails, consultez la documentation officielle de Jupyter.

7. Le fait d’ouvrir les chapitres sous la forme de notebooks dans des environnements standardisés, ce qui sera proposé à partir du prochain chapitre, permet d’assurer que vous disposiez d’un environnement contrôlé. Les installations personnelles de Python ont toutes les chances d’avoir subies des bidouillages modifiant votre environnement et pouvant provoquer des erreurs inattendues et difficiles à comprendre: ce n’est donc pas un usage recommandé pour ce cours. Comme vous pourrez le découvrir dans le prochain chapitre, les environnements cloud offrent un confort en ce qui concerne la standardisation des environnements.