Python pour la data science

Lino Galiana

doi:10.5281/zenodo.8229676

Les exercices sont présentés sous la forme de notebook jupyter. Ils peuvent être exécutés dans plusieurs environnement, au gré des préférences et des connaissances de chacun :

Sur un environnement temporaire ;
Sur une installation personnelle ;
Dans un conteneur docker.

Concernant la première méthode, qui est celle recommandée, chaque chapitre présente les badges suivants qui permettent d’ouvrir la page web en question dans l’environnement de prédilection. Par exemple, pour ouvrir le chapitre relatif à numpy dans l’un des environnements temporaires proposés, les badges suivants sont proposés :

Quel que soit l’environnement d’exécution des scripts, l’un des objectifs de ce cours est d’adopter un environnement favorable à la reproductibilité des traitements. Ils devraient donc fonctionner, dès lors que l’environnement est bien configuré, d’une manière similaire quel que soit la machine qui exécute le code.

Comme la reproductibilité est une notion centrale dans une démarche scientifique mais également importante dans le monde de l’entreprise ou de l’administration, en supplément des notions relatives à Python, ce cours montrera comment utiliser Git avec Python et évoquera un certain nombre de critères de qualité du code qui sont devenus des standards dans la communauté open-source, dans l’industrie et dans l’administration. Ces compétences ne sont pas propres à Python et seront utiles pour tout projet ultérieur. Un cours dédié à cette question est proposé par Romain Avouac et moi en dernière année de l’ENSAE. Son contenu est disponible sur https://ensae-reproductibilite.github.io/website/.

Le projet final devra impérativement être associé à un dépôt sur Github (nous reviendrons dessus) et répondre à ces critères de qualité, qui serviront toute la vie.

Ce cours vise à acculturer à la conduite de projets de data-science avec Python. L’environnement foisonnant de la data-science nécessite un certain nombre d’éléments supplémentaires à Python. La suite de ce chapitre permettra de décrire les configurations à mettre en oeuvre pour être en mesure d’exploiter la richesse de l’écosystème Python.

1 Installer un environnement adapté à la data-science sur son ordinateur personnel

Cette partie présente plusieurs éléments de configuration d’un environnement en local. Cependant, cette approche est de moins en moins fréquente. En effet, plusieurs facteurs conjoints ont amené à privilégier des serveurs plutôt que des installations locales (évolutions dans les technologies cloud, besoins accrus de ressources, besoins de plus de contrôle sur la confidentialité des données en limitant leur prolifération…). Au sein des administrations et des entreprises, les approches cloud, où l’utilisateur se voit mis à disposition une interface graphique alors que les calculs sont déportés sur un serveur distant, est de plus en plus fréquent.

1.1 Installer `Python` en local

Pour installer Python, il est recommandé d’utiliser la distribution Anaconda qui permet d’installer une distribution minimale de Python ainsi qu’éventuellement un environnement plus complet :

Sous Windows, il suffit de télécharger l’exécutable puis l’exécuter (cf. la doc officielle ;
Sous Mac, se reporter à la doc officielle ;
Sous Linux, suivre les instructions de la doc officielle selon sa distribution

Passer par Anaconda permet:

d’installer Python ;
d’installer par défaut une multitude de packages utiles ;
de pouvoir utiliser un gestionnaire de package nommé conda.

Anaconda permet de créer des environnements isolés et facilite l’installation de certaines librairies qui nécessitent l’usage de langages externes (par exemple du C++).

1.2 Installer un environnement de développement

Les notebooks Jupyter (extension .ipynb) sont très utilisés en data science. Ils sont en particulier très adaptés à la réalisation d’analyses exploratoires. Les notebooks permettent de mêler du code, du texte et des sorties graphiques ou des tableaux. L’intérêt principal des notebooks est qu’ils permettent d’exécuter du code très facilement dans un environnement Python donné (le kernel Jupyter). Ils sont particulièrement pratiques pour ajouter du code ou du texte à un document déjà existant, d’où le terme de notebook.

Néanmoins, passée l’étape d’exploration, il est recommandé de plutôt recourir à des scripts au format .py. L’utilisation du format .py est l’un des premiers gestes pour favoriser la reproductibilité des analyses. Ces scripts peuvent être édités à l’aide d’éditeurs de texte adaptés au code, comme Visual Studio (mon préféré), Sublime Text, ou PyCharm (privilégier Pycharm Community Edition) entre autres.

Ces éditeurs offrent des fonctionalités supplémentaires pratiques :

nombreux plugins pour une pleine utilisation de l’écosystème Python: éditeur de Markdown, interface Git, etc.
fonctionalités classiques d’un IDE dont manque Jupyter: autocomplétion, diagnostic du code, etc.
intégration avec les environnements Conda

1.3 Installation de `Git`

Le principe de Git ainsi que son usage avec Python sont présentés dans une partie dédiée. Cette partie se concentre ainsi sur la question de la configuration de Git.

Git est un langage dont la fonction est de tracer l’historique de modification d’un fichier. Pour disposer de ce langage, il est nécessaire d’installer le logiciel Git Bash. Grâce à lui, Git sera disponible et des outils externes, notamment les interfaces de développement comme Visual Studio, pourront l’utiliser.

2 Exécution dans un environnement temporaire sur un serveur distant

Comme évoqué précédemment, les technologies dominantes dans le domaine du traitement des données ont amené à une évolution des pratiques depuis quelques années. La multiplication de données volumineuses qui dépassent les capacités en RAM voire en stockage des machines personnelles, les progrès dans les technologies de stockage type cloud, l’adhésion de la communauté aux outils de versioning (le plus connu étant Git) sont autant de facteurs ayant amené à repenser la manière de traiter des données. Les infrastructures à l’état de l’art permettent ainsi de découpler stockage des données, stockage du code et exécution des traitements sur les données. L’exécution des traitements s’effectue ainsi sur des machines à la durée de vie courte qui stockent temporairement données et code ensembles pour tester les traitements.

Avec les dépôts sur Github ou Gitlab, on dissocie environnement de stockage des codes et d’exécution de ceux-ci. Un système de stockage S3, présenté dans un chapitre ultérieur, permet en supplément de dissocier l’environnement de stockage des données de ces deux premiers environnements. Sur le dépôt Github de ce cours {{< githubrepo >}}, on peut naviguer dans les fichiers (et voir tout l’historique de modification de ceux-ci). Mais, comment exécuter les scripts sans passer par un poste local ?

Depuis quelques années, des services en ligne permettant de lancer une instance Jupyter à distance (analogue à celle que vous pouvez lancer en local en utilisant Anaconda) ont émergé. Parmi celles-ci :

Le SSP Cloud , plateforme développée par l’Insee qui fournit des environnements bac à sable basés sur des technologie de conteneurisation
Google colaboratory ;
Github Visual Studio Editor ;
Binder ;

Il est également possible d’exécuter des codes sur les services d’intégration continue de Gitlab (service Gitlab CI) ou de Github (via Github Actions). Il s’agit d’une approche bash, c’est-à-dire que les scripts sont exécutés par une console à chaque interaction avec le dépôt distant Gitlab/Github, sans session ouverte pour les éditer. Cette approche est très appropriée pour assurer la reproductibilité d’une chaîne de traitement (on peut aller jusqu’au déploiement de visualisations automatiques¹) mais n’est pas très pratique pour le griffonnage.

Kaggle propose des compétitions de code mais donne également la possibilité d’exécuter des notebooks, comme les solutions précédentes. Il existe une API Kaggle pour accéder à des données Kaggle hors du système Kaggle

Warning

Les performances de ces solutions peuvent être variables. Les serveurs publics mis à disposition ne sont pas forcément des foudres de guerre. Avec ceux-ci, on vérifie plutôt la reproductibilité des scripts avec des jeux d’exemples. Il est bien sûr interdit de mettre des données confidentielles dessus: ces dernières doivent rester dans des infrastructures où elles sont autorisées.

Quand on est dans une entreprise ou administration, qui dispose de serveurs propres, on peut aller plus loin en utilisant ces outils pour automatiser l’ensemble de la chaîne de traitement.

Attention: il n’y a pas de garantie de perennité de service (notamment avec Binder où 10 minutes d’inactivité mènent à l’extinction du service). Il s’agit plus d’un service pour griffoner dans le même environnement que celui du dépôt Git que de solutions durables. Les sessions sur l’environnement SSPCloud sont plus durables mais il convient de garder à l’esprit qu’elles sont également temporaires.

2.0.1 SSP Cloud

Onyxia, l’autre petit nom du SSP Cloud, est une plateforme libre service mutualisée de traitement de données statistiques et de datascience.

Ce cloud met à disposition aux statisticiens et aux data scientists de l’État un catalogue de services et un environnement de travail simple, rapide et collaboratif, permettant de lancer facilement ces outils et d’y connecter ses données et son code.

Au-delà des ressources techniques, cette plateforme représente une opportunité pour les statisticiens publics et les étudiants de découvrir et d’adopter de nouvelles méthodes de travail. Elle est aussi utilisé à des fins de formations et d’auto-formations.

Dans cet environnement, Jupyter et Visual Studio sont tous deux disponibles.

2.0.2 Google colaboratory

Google met à disposition une plateforme de calculs basée sur le format Jupyter Notebook. Un grand avantage de cette solution est la mise à disposition gratuite de GPUs de qualité raisonnable, outil quasi-indispensable dans les projets basés sur des méthodes de deep learning. Il est possible de connecter les notebooks ouverts à Google Drive ou à Github. L’icone fournit un raccourci pour lancer le notebook dans un environnement dédié.

2.0.3 Github Visual Studio Editor

Microsoft qui possède à la fois Github et Visual Studio a récemment lancé une offre Github dev qui permet d’ouvrir et lancer un notebook Jupyter depuis un navigateur web.

En plus des fonctionalités attendues du logiciel Visual Studio Cette interface permet également de gérer les issues et pull request d’un dépôt Github.

2.0.4 La technologie en arrière-plan : Docker

Docker est l’outil open-source de référence en matière de création d’environnements isolés et auto-suffisants (les conteneurs). En pratique, une application codée en Python ne repose que rarement seulement sur du code produit par son développeur, elle fait généralement intervenir des dépendances : d’autres librairies Python, ainsi que des librairies liées au système d’exploitation sur laquelle elle est développée. Docker va permettre d’empaqueter l’application ainsi que toutes ses dépendances et rendre son exécution portable, c’est à dire indépendante du système sur laquelle elle est éxécutée.

Docker est utilisé dans le cadre de cours afin d’assurer la reproductibilité des exemples. Plus de détails sont disponibles dans le cours de dernière année d’ENSAE dédié à la mise en production de projets data science (https://ensae-reproductibilite.github.io/website/).

Il est possible d’utiliser les images Docker sur lesquelles reposent l’environnement de reproductibilité du cours. Celles-ci sont mises à disposition sur DockerHub, le principal réseau de mise à disposition d’images Docker. Il existe une image minimale qui intègre Python et Quarto.

Pour utiliser l’image Visual Studio:

docker pull linogaliana/python-datascientist-vstudio
docker run --rm -p 8787:8787 -e PASSWORD=test linogaliana/python-datascientist-vstudio

En se rendant depuis un navigateur sur localhost:8887/, et en rentrant le mot de passe test (défini plus haut), on peut ainsi accéder à l’interface désirée (attention il s’agit d’un environnement temporaire, pas pérenne).

3 Installer des packages supplémentaires

Un module est un script qui a vocation à définir des objets utilisés postérieurement par un interpréteur. C’est un script .py autosuffisant, définissant des objets et des relations entre eux et le monde extérieur (d’autres modules). Un package est un ensemble cohérent de modules. Par exemple scikit-learn propose de nombreux modules utiles pour le machine learning.

Python, sans ajout de briques supplémentaires, trouvera rapidement ses limites. Même dans les scripts les plus simples, on a généralement besoin de packages qui évitent de réinventer la roue.

Les packages sont les éléments qui font la richesse des langages open-source.
Ils sont l’équivalent des packages R ou Stata. Le monde de développeurs Python est très prolifique : des mises à jour sont très souvent disponibles, les bibliothèques de packages sont très nombreuses. Un data scientist prendra l’habitude de jongler avec des dizaines de packages dont il connaîtra quelques fonctions et où, surtout, il saura aller chercher de l’information. Le rythme des mises à jour et des ajouts de fonctionalités s’est accéléré ces dernières années. Les grandes compagnies du numérique ont elles-mêmes opensourcées des librairies devenues centrales dans l’écosystème de la data-science (TensorFlow par Google, PyTorch par Facebook…)

Les forums, notamment StackOverflow regorgent de bons conseils. Les deux meilleurs conseils qu’on puisse donner :

regarder la documentation officielle d’un package. Les bons packages sont généralement très bien documentés et beaucoup d’erreurs peuvent être évitées en apprenant à chercher dans la documentation ;
en cas d’erreur : copiez-collez l’erreur sur votre moteur de recherche préféré. Quelqu’un aura déjà posé la question, sans doute sur stackoverflow. Néanmoins, ne copiez-collez pas la réponse sans comprendre la solution.

3.0.1 Les gestionnaires de packages

Les packages d’un langage open-source sont mis à disposition sur des dépôts. Le CTAN est ainsi le dépôt LaTeX le plus connu, le CRAN celui du langage R.

En Python, il existe deux gestionnaires de packages qu’on utilise associés à deux dépôts différents :

pip associé au dépôt PyPi
conda associé au dépôt Anaconda

Anaconda a permis, il y a quelques années, de faciliter grandement l’installation de librairies dépendants d’autres langages que Python (notamment des librairies C pour améliorer la performance des calculs). Ces dernières sont compliquées à installer, notamment sur Windows. Le fait de proposer des librairies pré-compilées sur une grande variété de systèmes d’exploitation a été une avancée d’anaconda. PyPi a adopté ce même principe avec les wheels ce qui finalement, rend les installations avec pip à nouveau intéressantes (sauf pour certaines librairies en Windows).

Anaconda a deux défauts par rapport à pip :

l’installation de packages via pip est plus rapide que via conda. conda est en effet plus précautionneux sur l’interaction entre les différentes versions des packages installés. mamba a récemment été développé pour accélérer l’installation de packages dans un environnement conda²
les versions disponibles sur PyPi sont plus récentes que celles sur le canal par défaut d’Anaconda. En effet, pour un développeur de packages, il est possible de publier un package de manière automatique sur PyPi L’utilisation du canal alternatif qu’est la conda forge permet de disposer de versions plus récentes des packages et limite l’écart avec les versions disponibles sur PyPi.

Warning

Les conditions d’utilisation du canal par défaut d’Anaconda sont assez restrictives. L’utilisation d’Anaconda dans un cadre commercial est ainsi, depuis 2020, soumis à l’achat de licences commerciales d’Anaconda pour réduire le problème de passager clandestin. Il est ainsi recommandé, notamment lorsqu’on travaille dans le secteur privé où du code Python peut être utilisé, de ne pas ignorer ces conditions pour ne pas se mettre en faute juridiquement.

La conda forge n’est pas soumise à ces conditions et est ainsi préférable dans les entreprises.

3.0.2 Comment installer des packages

Avec Anaconda, il faut passer par la ligne de commande et taper

conda install <nom_module>

Par exemple conda install geopandas. Depuis une cellule de notebook Jupyter, on ajoute un point d’exclamation pour indiquer à Jupyter que la commande doit être interprétée comme une commande shell et non une commande Python

!conda install <nom_module> -y

L’option -y permet d’éviter que conda nous demande confirmation sur l’installation du package. Pour mettre à jour un package, on fera conda upgrade plutôt que conda install

Avec pip, on va cette fois taper

pip install <nom_module>

pip permet également d’installer des librairies directement depuis Github à condition que Anaconda et Git sachent communiquer (ce qui implique en général que Git soit dans le PATH du système d’exploitation). Par exemple, pour installer le package pynsee

pip install git+https://github.com/InseeFrLab/Py-Insee-Data.git#egg=pynsee

La partie dédiée aux environnement virtuels du cours de dernière année de l’ENSAE présente plus d’éléments sur les différences moins évidentes entre pip et conda.

Informations additionnelles

environment files have been tested on.

Latest built version: 2024-04-27

Python version used:

'3.11.6 | packaged by conda-forge | (main, Oct  3 2023, 10:40:35) [GCC 12.3.0]'

Package	Version
affine	2.4.0
aiobotocore	2.12.2
aiohttp	3.9.3
aioitertools	0.11.0
aiosignal	1.3.1
alembic	1.13.1
aniso8601	9.0.1
annotated-types	0.6.0
appdirs	1.4.4
archspec	0.2.3
astroid	3.1.0
asttokens	2.4.1
attrs	23.2.0
Babel	2.14.0
bcrypt	4.1.2
beautifulsoup4	4.12.3
black	24.4.2
blinker	1.7.0
blis	0.7.11
bokeh	3.4.0
boltons	23.1.1
boto3	1.34.51
botocore	1.34.51
branca	0.7.1
Brotli	1.1.0
cachetools	5.3.3
cartiflette	0.0.2
Cartopy	0.23.0
catalogue	2.0.10
cattrs	23.2.3
certifi	2024.2.2
cffi	1.16.0
charset-normalizer	3.3.2
click	8.1.7
click-plugins	1.1.1
cligj	0.7.2
cloudpathlib	0.16.0
cloudpickle	3.0.0
colorama	0.4.6
comm	0.2.2
commonmark	0.9.1
conda	24.3.0
conda-libmamba-solver	24.1.0
conda-package-handling	2.2.0
conda_package_streaming	0.9.0
confection	0.1.4
contextily	1.6.0
contourpy	1.2.1
cryptography	42.0.5
cycler	0.12.1
cymem	2.0.8
cytoolz	0.12.3
dask	2024.4.1
dask-expr	1.0.10
debugpy	1.8.1
decorator	5.1.1
dill	0.3.8
distributed	2024.4.1
distro	1.9.0
docker	7.0.0
duckdb	0.10.1
en-core-web-sm	3.7.1
entrypoints	0.4
et-xmlfile	1.1.0
exceptiongroup	1.2.0
executing	2.0.1
fastjsonschema	2.19.1
fiona	1.9.6
flake8	7.0.0
Flask	3.0.2
folium	0.16.0
fontawesomefree	6.5.1
fonttools	4.51.0
frozenlist	1.4.1
fsspec	2023.12.2
GDAL	3.8.4
gensim	4.3.2
geographiclib	2.0
geopandas	0.12.2
geoplot	0.5.1
geopy	2.4.1
gitdb	4.0.11
GitPython	3.1.43
google-auth	2.29.0
graphene	3.3
graphql-core	3.2.3
graphql-relay	3.2.0
graphviz	0.20.3
great-tables	0.5.0
greenlet	3.0.3
gunicorn	21.2.0
htmltools	0.5.1
hvac	2.1.0
idna	3.6
imageio	2.34.1
importlib_metadata	7.1.0
importlib_resources	6.4.0
inflate64	1.0.0
ipykernel	6.29.3
ipython	8.22.2
ipywidgets	8.1.2
isort	5.13.2
itsdangerous	2.1.2
jedi	0.19.1
Jinja2	3.1.3
jmespath	1.0.1
joblib	1.3.2
jsonpatch	1.33
jsonpointer	2.4
jsonschema	4.21.1
jsonschema-specifications	2023.12.1
jupyter-cache	1.0.0
jupyter_client	8.6.1
jupyter_core	5.7.2
jupyterlab_widgets	3.0.10
kaleido	0.2.1
kiwisolver	1.4.5
kubernetes	29.0.0
langcodes	3.4.0
language_data	1.2.0
lazy_loader	0.4
libmambapy	1.5.7
llvmlite	0.42.0
locket	1.0.0
lxml	5.2.1
lz4	4.3.3
Mako	1.3.2
mamba	1.5.7
mapclassify	2.6.1
marisa-trie	1.1.0
Markdown	3.6
MarkupSafe	2.1.5
matplotlib	3.8.3
matplotlib-inline	0.1.6
mccabe	0.7.0
menuinst	2.0.2
mercantile	1.2.1
mizani	0.11.2
mlflow	2.11.3
mlflow-skinny	2.11.3
msgpack	1.0.7
multidict	6.0.5
multivolumefile	0.2.3
munkres	1.1.4
murmurhash	1.0.10
mypy	1.9.0
mypy-extensions	1.0.0
nbclient	0.10.0
nbformat	5.10.4
nest_asyncio	1.6.0
networkx	3.3
nltk	3.8.1
numba	0.59.1
numpy	1.26.4
oauthlib	3.2.2
opencv-python-headless	4.9.0.80
openpyxl	3.1.2
OWSLib	0.28.1
packaging	23.2
pandas	2.2.1
paramiko	3.4.0
parso	0.8.4
partd	1.4.1
pathspec	0.12.1
patsy	0.5.6
Pebble	5.0.7
pexpect	4.9.0
pickleshare	0.7.5
pillow	10.3.0
pip	24.0
pkgutil_resolve_name	1.3.10
platformdirs	4.2.0
plotly	5.19.0
plotnine	0.13.5
pluggy	1.4.0
polars	0.20.18
preshed	3.0.9
prometheus_client	0.20.0
prometheus-flask-exporter	0.23.0
prompt-toolkit	3.0.42
protobuf	4.25.3
psutil	5.9.8
ptyprocess	0.7.0
pure-eval	0.2.2
py7zr	0.20.8
pyarrow	15.0.0
pyarrow-hotfix	0.6
pyasn1	0.5.1
pyasn1-modules	0.3.0
pybcj	1.0.2
pycodestyle	2.11.1
pycosat	0.6.6
pycparser	2.21
pycryptodomex	3.20.0
pydantic	2.7.1
pydantic_core	2.18.2
pyflakes	3.2.0
Pygments	2.17.2
PyJWT	2.8.0
pylint	3.1.0
PyNaCl	1.5.0
pynsee	0.1.7
pyOpenSSL	24.0.0
pyparsing	3.1.2
pyppmd	1.1.0
pyproj	3.6.1
pyshp	2.3.1
PySocks	1.7.1
python-dateutil	2.9.0
python-dotenv	1.0.1
python-magic	0.4.27
pytz	2024.1
pyu2f	0.1.5
pywaffle	1.1.0
PyYAML	6.0.1
pyzmq	25.1.2
pyzstd	0.15.10
QtPy	2.4.1
querystring-parser	1.2.4
rasterio	1.3.10
referencing	0.34.0
regex	2023.12.25
requests	2.31.0
requests-cache	1.2.0
requests-oauthlib	2.0.0
rpds-py	0.18.0
rsa	4.9
Rtree	1.2.0
ruamel.yaml	0.18.6
ruamel.yaml.clib	0.2.8
s3fs	2023.12.2
s3transfer	0.10.1
scikit-image	0.23.2
scikit-learn	1.4.1.post1
scipy	1.13.0
seaborn	0.13.2
setuptools	69.2.0
shapely	2.0.3
six	1.16.0
smart-open	6.4.0
smmap	5.0.0
snuggs	1.4.7
sortedcontainers	2.4.0
soupsieve	2.5
spacy	3.7.4
spacy-legacy	3.0.12
spacy-loggers	1.0.5
SQLAlchemy	2.0.29
sqlparse	0.4.4
srsly	2.4.8
stack-data	0.6.2
statsmodels	0.14.1
tabulate	0.9.0
tblib	3.0.0
tenacity	8.2.3
texttable	1.7.0
thinc	8.2.3
threadpoolctl	3.4.0
tifffile	2024.4.24
tomli	2.0.1
tomlkit	0.12.4
toolz	0.12.1
topojson	1.8
tornado	6.4
tqdm	4.66.2
traitlets	5.14.2
truststore	0.8.0
typer	0.9.4
typing_extensions	4.11.0
tzdata	2024.1
Unidecode	1.3.8
url-normalize	1.4.3
urllib3	1.26.18
wasabi	1.1.2
wcwidth	0.2.13
weasel	0.3.4
webcolors	1.13
webdriver-manager	4.0.1
websocket-client	1.7.0
Werkzeug	3.0.2
wheel	0.43.0
widgetsnbextension	4.0.10
wordcloud	1.9.3
wrapt	1.16.0
xgboost	2.0.3
xlrd	2.0.1
xyzservices	2024.4.0
yarl	1.9.4
yellowbrick	1.5
zict	3.0.0
zipp	3.17.0
zstandard	0.22.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
d75641d	2024-04-22 18:59:01	Lino Galiana	Editorialisation des chapitres de manipulation de données (#491)
005d89b	2023-12-20 17:23:04	Lino Galiana	Finalise l’affichage des statistiques Git (#478)
1f23de2	2023-12-01 17:25:36	Lino Galiana	Stockage des images sur S3 (#466)
a06a268	2023-11-23 18:23:28	Antoine Palazzolo	2ème relectures chapitres ML (#457)
7221e7b	2023-10-10 14:00:44	Thomas Faria	Relecture Thomas TD Pandas (#431)
9366e8d	2023-10-09 12:06:23	Lino Galiana	Retrait des box hugo sur l’exo git (#428)
a771183	2023-10-09 11:27:45	Antoine Palazzolo	Relecture TD2 par Antoine (#418)
e8d0062	2023-09-26 15:54:49	Kim A	Relecture KA 25/09/2023 (#412)
154f09e	2023-09-26 14:59:11	Antoine Palazzolo	Des typos corrigées par Antoine (#411)
6178ebe	2023-09-26 14:18:34	Lino Galiana	Change quarto project type (#409)
9a4e226	2023-08-28 17:11:52	Lino Galiana	Action to check URL still exist (#399)
3bdf3b0	2023-08-25 11:23:02	Lino Galiana	Simplification de la structure 🤓 (#393)
78ea2cb	2023-07-20 20:27:31	Lino Galiana	Change titles levels (#381)
2dbf853	2023-07-05 11:21:40	Lino Galiana	Add nice featured images (#368)
b2d4823	2022-09-21 17:36:29	Lino Galiana	Relec KA 21/09 (#273)
fd439f0	2022-09-19 09:37:50	avouacr	fix ssp cloud links
3056d41	2022-09-02 12:19:55	avouacr	fix all SSP Cloud launcher links
f10815b	2022-08-25 16:00:03	Lino Galiana	Notebooks should now look more beautiful (#260)
61922f0	2022-08-03 17:06:55	Lino Galiana	anaconda toss (#251)
d201e3c	2022-08-03 15:50:34	Lino Galiana	Pimp la homepage ✨ (#249)
5123634	2022-06-30 11:24:49	Lino Galiana	Amélioration de la première partie (#244)
12965ba	2022-05-25 15:53:27	Lino Galiana	:launch: Bascule vers quarto (#226)
9c71d6e	2022-03-08 10:34:26	Lino Galiana	Plus d’éléments sur S3 (#218)
66fc843	2021-11-08 11:19:12	Lino Galiana	Add badge open in vsode (#176)
f95b174	2021-11-03 12:08:34	Lino Galiana	Enrichi la section sur la gestion des dépendances (#175)

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')

Back to top

Footnotes

Les gains de performance peuvent être assez impressionnants. La création de l’environnement nécessaire à la construction automatisée de ce site web a ainsi été divisée par 12 en utilisant mamba plutôt que conda pour installer des packages dans un environnement.↩︎
Les gains de performance peuvent être assez impressionnants. La création de l’environnement nécessaire à la construction automatisée de ce site web a ainsi été divisée par 12 en utilisant mamba plutôt que conda pour installer des packages dans un environnement.↩︎

Citation

BibTeX citation:

@book{galiana2023,
  author = {Galiana, Lino},
  title = {Python Pour La Data Science},
  date = {2023},
  url = {https://pythonds.linogaliana.fr/},
  doi = {10.5281/zenodo.8229676},
  langid = {en}
}

For attribution, please cite this work as:

Galiana, Lino. 2023. Python Pour La Data Science. https://doi.org/10.5281/zenodo.8229676.