Python pour la data science

Lino Galiana

doi:10.5281/zenodo.8229676

path = window.location.pathname.replace(".html", ".qmd");
path_modified = (path.includes('en/content')) ? path.replace('en/content', 'content/en') : path
html`${printBadges({fpath: path_modified})}`

html`
<details>
<summary>
Pour ouvrir la version corrigée sous forme de <i>notebook</i>
</summary>
${printBadges({fpath: path, correction: true})}
</details>
`

function reminderBadges({
    sourceFile = "content/01_toto.Rmd",
    type = ['md', 'html'],
    split = null,
    onyxiaOnly = false,
    sspCloudService = "python",
    GPU = false,
    correction = false
} = {}) {
    if (Array.isArray(type)) {
        type = type[0];
    }

    let notebook = sourceFile.replace(/(.Rmd|.qmd)/, ".ipynb");
    if (correction) {
        notebook = notebook.replace(/content/, "corrections");
    } else {
        notebook = notebook.replace(/content/, "notebooks");
    }

    const githubRepoNotebooksSimplified = "github/linogaliana/python-datascientist-notebooks";
    const githubAlias = githubRepoNotebooksSimplified.replace("github", "github.com");
    const githubRepoNotebooks = `https://${githubAlias}`;

    let githubLink ;

    if (notebook === "") {
        githubLink = githubRepoNotebooks;
    } else {
        githubLink = `${githubRepoNotebooks}/blob/main`;
    }

    const notebookRelPath = `/${notebook}`;
    const [section, chapter] = notebook.split("/").slice(-2);

    githubLink = `<a href="${githubLink}${notebookRelPath}" class="github"><i class="fab fa-github"></i></a>`;

    let sectionLatest = section.split("/").slice(-1)[0];
    const chapterNoExtension = chapter.replace(".ipynb", "");
    
    if (sourceFile.includes('en/')) {
        sectionLatest = `en/${sectionLatest}`;
    }

    const onyxiaInitArgs = [sectionLatest, chapterNoExtension];

    if (correction) {
        onyxiaInitArgs.push("correction");
    }

    const gpuSuffix = GPU ? "-gpu" : "";

    const sspcloudJupyterLinkLauncher = `https://datalab.sspcloud.fr/launcher/ide/jupyter-${sspCloudService}${gpuSuffix}?autoLaunch=true&onyxia.friendlyName=%C2%AB${chapterNoExtension}%C2%BB&init.personalInit=%C2%ABhttps%3A%2F%2Fraw.githubusercontent.com%2Flinogaliana%2Fpython-datascientist%2Fmaster%2Fsspcloud%2Finit-jupyter.sh%C2%BB&init.personalInitArgs=%C2%AB${onyxiaInitArgs.join('%20')}%C2%BB&security.allowlist.enabled=false`;

    let sspcloudJupyterLink;
    if (type === "md") {
        sspcloudJupyterLink = `[![Onyxia](https://img.shields.io/badge/SSP%20Cloud-Tester_avec_Jupyter-orange?logo=Jupyter&logoColor=orange)](${sspcloudJupyterLinkLauncher})`;
    } else {
        sspcloudJupyterLink = `<a href="${sspcloudJupyterLinkLauncher}" target="_blank" rel="noopener"><img src="https://img.shields.io/badge/SSP%20Cloud-Tester_avec_Jupyter-orange?logo=Jupyter&logoColor=orange" alt="Onyxia"></a>`;
    }

    if (split === 4) {
        sspcloudJupyterLink += '<br>';
    }

    const sspcloudVscodeLinkLauncher = `https://datalab.sspcloud.fr/launcher/ide/vscode-${sspCloudService}${gpuSuffix}?autoLaunch=true&onyxia.friendlyName=%C2%AB${chapterNoExtension}%C2%BB&init.personalInit=%C2%ABhttps%3A%2F%2Fraw.githubusercontent.com%2Flinogaliana%2Fpython-datascientist%2Fmaster%2Fsspcloud%2Finit-vscode.sh%C2%BB&init.personalInitArgs=%C2%AB${onyxiaInitArgs.join('%20')}%C2%BB&security.allowlist.enabled=false`;

    let sspcloudVscodeLink;
    if (type === "md") {
        sspcloudVscodeLink = `[![Onyxia](https://img.shields.io/badge/SSP%20Cloud-Tester_avec_VSCode-blue?logo=visualstudiocode&logoColor=blue)](${sspcloudVscodeLinkLauncher})`;
    } else {
        sspcloudVscodeLink = `<a href="${sspcloudVscodeLinkLauncher}" target="_blank" rel="noopener"><img src="https://img.shields.io/badge/SSP%20Cloud-Tester_avec_VSCode-blue?logo=visualstudiocode&logoColor=blue" alt="Onyxia"></a>`;
    }

    if (split === 5) {
        sspcloudVscodeLink += '<br>';
    }

    let colabLink;
    if (type === "md") {
        colabLink = `[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](http://colab.research.google.com/${githubRepoNotebooksSimplified}/blob/main${notebookRelPath})`;
    } else {
        colabLink = `<a href="https://colab.research.google.com/${githubRepoNotebooksSimplified}/blob/main${notebookRelPath}" target="_blank" rel="noopener"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>`;
    }

    if (split === 7) {
        colabLink += '<br>';
    }

    let vscodeLink;
    if (type === "md") {
        vscodeLink = `[![githubdev](https://img.shields.io/static/v1?logo=visualstudiocode&label=&message=Open%20in%20Visual Studio Code&labelColor=2c2c32&color=007acc&logoColor=007acc)](https://github.dev/linogaliana/python-datascientist-notebooks${notebookRelPath})`;
    } else {
        vscodeLink = `<a href="https://github.dev/linogaliana/python-datascientist-notebooks${notebookRelPath}" target="_blank" rel="noopener"><img src="https://img.shields.io/static/v1?logo=visualstudiocode&label=&message=Open%20in%20Visual%20Studio%20Code&labelColor=2c2c32&color=007acc&logoColor=007acc" alt="githubdev"></a></p>`;
    }

    const badges = [
        githubLink,
        sspcloudVscodeLink,
        sspcloudJupyterLink
    ];

    if (!onyxiaOnly) {
        badges.push(colabLink);
    }

    let result = badges.join("\n");

    if (type === "html") {
        result = `<p class="badges">${result}</p>`;
    }

    if (onyxiaOnly) {
        result = `${sspcloudJupyterLink}${sspcloudVscodeLink}`;
    }

    return result;
}


function printBadges({
    fpath,
    onyxiaOnly = false,
    split = 5,
    type = "html",
    sspCloudService = "python",
    GPU = false,
    correction = false
} = {}) {
    const badges = reminderBadges({
        sourceFile: fpath,
        type: type,
        split: split,
        onyxiaOnly: onyxiaOnly,
        sspCloudService: sspCloudService,
        GPU: GPU,
        correction: correction
    });

    return badges
}

La pratique de la cartographie se fera, dans ce cours, en répliquant des cartes qu’on peut trouver sur la page de l’open-data de la ville de Paris ici.

Note

Produire de belles cartes demande du temps mais aussi du bon sens. En fonction de la structure des données, certaines représentations sont à éviter voire à exclure. Un guide disponible ici propose quelques règles et évoque les erreurs à éviter lorsqu’on désire effectuer des représentations spatiales. Celui-ci reprend un guide de sémiologie cartographique produit par l’Insee qui propose de nombreux conseils pratiques pour produire des représentations cartographiques sensées.

Ce TP vise à initier :

Au module graphique de geopandas ainsi qu’aux packages geoplot et contextily pour la construction de cartes figées. geoplot est construit sur seaborn et constitue ainsi une extension des graphiques de base.
Au package folium qui est un point d’accès vers la librairie JavaScript leaflet permettant de produire des cartes interactives

Les données utilisées sont :

Un sous-ensemble des données de paris open data a été mis à disposition sur Github pour faciliter l’import (élimination des colonnes qui ne nous servirons pas mais ralentissent l’import)
La localisation précise des stations
Arrondissements parisiens

Attention

Certaines librairies géographiques dépendent de rtree qui est parfois difficile à installer car ce package dépend de librairies compilées qui sont compliquées à installer sur Windows. Pour installer rtree sur Windows, le mieux est d’utiliser Anaconda.

Avant de pouvoir commencer, il est nécessaire d’installer quelques packages au préalable:

# Sur colab
!pip install pandas fiona shapely pyproj rtree # à faire obligatoirement en premier pour utiliser rtree ou pygeos pour les jointures spatiales
!pip install contextily
!pip install geopandas
!pip install geoplot

Dans la première partie, nous allons utiliser les packages suivants :

import pandas as pd
import geopandas as gpd
import contextily as ctx
import geoplot
import matplotlib.pyplot as plt
import folium

ERROR 1: PROJ: proj_create_from_database: Open of /opt/mamba/share/proj failed

1 Première carte avec l’API `matplotlib` de `geopandas`

Exercice 1: Importer les données

Importer les données de compteurs de vélos en deux temps.

D’abord, les comptages peuvent être trouvés à l’adresse https://minio.lab.sspcloud.fr/projet-formation/diffusion/python-datascientist/bike.csv. ⚠️ Il s’agit de données compressées au format gzip, il faut donc utiliser l’option compression. Nommer cet objet comptages.
Importer les données de localisation des compteurs à partir de l’url https://parisdata.opendatasoft.com/api/explore/v2.1/catalog/datasets/comptage-velo-compteurs/exports/geojson?lang=fr&timezone=Europe%2FBerlin. Nommer cet objet compteurs.
Faire attention à deux valeurs aberrantes. Utiliser la fonctionalité str.contains pour exclure les observations contenant “Bike IN” ou “Bike OUT” dans la variable nom_compteur
On va également utiliser les contours d’arrondissements de la ville de Paris. Nommer cet objet arrondissements. Pour le créer, utiliser la fonction carti_download du package cartiflette.
Utiliser la méthode plot pour représenter les localisations des compteurs dans l’espace. C’est, on peut l’avouer, peu informatif sans apport extérieur. Il va donc falloir travailler un peu l’esthétique

Aide pour l’utilisation de cartiflette

Le code suivant donne la structure générale, il suffit d’adapter l’argument values:

from cartiflette import carti_download

# 3. Chargement de "arrondissements"
arrondissements = carti_download(
    values=["TO_BE_COMPLETED"],
    borders="COMMUNE_ARRONDISSEMENT",
    filter_by="DEPARTEMENT",
    crs=4326,
    vectorfile_format="geojson",
    source="EXPRESS-COG-CARTO-TERRITOIRE",
    year=2022,
)

/tmp/ipykernel_4271/3102819520.py:2: UserWarning:

This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.

Warning

On serait tenté de faire un merge de la base compteurs et comptages. En l’occurrence, il s’agirait d’un produit cartésien puisqu’il s’agit de faire exploser la base spatiale. Avec des données spatiales, c’est souvent une très mauvaise idée. Cela duplique les points, créant des difficultés à représenter les données mais aussi ralentit les calculs. Sauf à utiliser la méthode dissolve (qui va agréger k fois la même géométrie…), les géométries sont perdues lorsqu’on effectue des groupby.

Maintenant, tout est prêt pour une première carte. matplotlib fonctionne selon le principe des couches. On va de la couche la plus lointaine à celle le plus en surface. L’exception est lorsqu’on ajoute un fond de carte contextily via ctx.add_basemap: on met cet appel en dernier.

Exercice 2: Première carte

Représenter une carte des compteurs avec le fonds de carte des arrondissements

Faire attention à avoir des arrondissements dont l’intérieur est transparent (argument à utiliser: facecolor).
Faire des bordures d’arrondissements noires et affichez les compteurs en rouge.
Pour obtenir un graphique plus grand, vous pouvez utiliser l’argument figsize = (10,10).
Pour les localisations, les points doivent être rouges en étant plus transparent au centre (argument à utiliser: alpha)

Vous devriez obtenir cette carte:

Exercice 3 : Ajouter un fonds de carte avec contextily

Repartir de la carte précédente.

Utiliser ctx.add_basemap pour ajouter un fonds de carte. Pour ne pas afficher les axes, vous pouvez utiliser ax.set_axis_off().

:warning: Par défaut, contextily désire un système de projection (crs) qui est le Web Mercator (epsg: 3857). Il faut changer la valeur de l’argument crs.

:warning: Avec les versions anciennes des packages, il faut utiliser .to_string sur un objet CRS pour qu’il soit reconnu par contextily. Sur des versions récentes, la valeur numérique du code EPSG est suffisante.

Trouver un fonds de carte plus esthétique, qui permette de visualiser les grands axes, parmi ceux possibles. Pour tester l’esthétique, vous pouvez utiliser cet url. La documentation de référence sur les tuiles disponibles est ici

Le principe de la heatmap est de construire, à partir d’un nuage de point bidimensionnel, une distribution 2D lissée. La méthode repose sur les estimateurs à noyaux qui sont des méthodes de lissage local.

Exercice 3 : Ajouter un fonds de carte avec contextily

Pour le moment, la fonction geoplot.kdeplot n’incorpore pas toutes les fonctionalités de seaborn.kdeplot. Pour être en mesure de construire une heatmap avec des données pondérées (cf. cette issue dans le dépôt seaborn), il y a une astuce. Il faut simuler k points de valeur 1 autour de la localisation observée. La fonction ci-dessous, qui m’a été bien utile, est pratique et est donnée pour vous aider.

import numpy as np


def expand_points(
    shapefile, index_var="grid_id", weight_var="prop", radius_sd=100, crs=2154
):
    """
    Multiply number of points to be able to have a weighted heatmap
    :param shapefile: Shapefile to consider
    :param index_var: Variable name to set index
    :param weight_var: Variable that should be used
    :param radius_sd: Standard deviation for the radius of the jitter
    :param crs: Projection system that should be used. Recommended option
      is Lambert 93 because points will be jitterized using meters
    :return:
      A geopandas point object with as many points by index as weight
    """

    shpcopy = shapefile
    shpcopy = shpcopy.set_index(index_var)
    shpcopy["npoints"] = np.ceil(shpcopy[weight_var])
    shpcopy["geometry"] = shpcopy["geometry"].centroid
    shpcopy["x"] = shpcopy.geometry.x
    shpcopy["y"] = shpcopy.geometry.y
    shpcopy = shpcopy.to_crs(crs)
    shpcopy = shpcopy.loc[np.repeat(shpcopy.index.values, shpcopy.npoints)]
    shpcopy["x"] = shpcopy["x"] + np.random.normal(0, radius_sd, shpcopy.shape[0])
    shpcopy["y"] = shpcopy["y"] + np.random.normal(0, radius_sd, shpcopy.shape[0])

    gdf = gpd.GeoDataFrame(
        shpcopy, geometry=gpd.points_from_xy(shpcopy.x, shpcopy.y), crs=crs
    )

    return gdf

Exercice 4 : Data cleaning avant de pouvoir faire une heatmap

Calculer le trafic moyen, pour chaque station, entre 7 heures et 10 heures (bornes incluses) et nommer cet objet df1. Faire la même chose, en nommant df2, pour le trafic entre 17 et 20 heures (bornes incluses)
Nous allons désormais préparer les données de manière à faire une heatmap. Après avoir compris ce que permet de faire la fonction expand_points ci-dessus, créer une fonction explode_data qui suive les étapes suivantes.

Convertir un DataFrame dans le système de projection Lambert 93 (epsg: 2154)
Appliquer expand_points aux noms de variable adéquats. Vous pouvez fixer la valeur de radius_sd à 100.
Reconvertir l’output au format WGS84 (epsg: 4326)

Appliquer cette fonction à df1 et df2

2 Des cartes réactives grâce à `folium`

De plus en plus d’applications de visualisation reposent sur la cartographie réactive. Que ce soit dans l’exploration des données ou dans la représentation finale de résultats, la cartographie réactive est très appréciable.

folium offre une interface très flexible et très facile à prendre à main. Les cartes sont construites grâce à la librairie JavaScript Leaflet.js mais, sauf si on désire aller loin dans la customisation du résultat, il n’est pas nécessaire d’avoir des notions dans le domaine.

Un objet folium se construit par couche. La première est l’initialisation de la carte. Les couches suivantes sont les éléments à mettre en valeur. L’initialisation de la carte nécessite la définition d’un point central (paramètre location) et d’un zoom de départ (zoom_start). Plutôt que de fournir manuellement le point central et le zoom on peut :

Déterminer le point central en construisant des colonnes longitudes et latitudes et en prenant la moyenne de celles-ci ;
Utiliser la méthode fit_bounds qui cale la carte sur les coins sud-ouest et nord-est. En supposant que la carte s’appelle m, on fera m.fit_bounds([sw, ne])

Le bout de code suivant permet de calculer le centre de la carte

compteurs = gpd.read_file(
    "https://parisdata.opendatasoft.com/api/explore/v2.1/catalog/datasets/comptage-velo-compteurs/exports/geojson?lang=fr&timezone=Europe%2FBerlin"
)
compteurs["lon"] = compteurs.geometry.x
compteurs["lat"] = compteurs.geometry.y
center = compteurs[["lat", "lon"]].mean().values.tolist()
print(center)

[48.855656572463765, 2.3476786666666665]

Alors que le code suivant permet de calculer les coins:

sw = compteurs[["lat", "lon"]].min().values.tolist()
ne = compteurs[["lat", "lon"]].max().values.tolist()
print(sw, ne)

[48.81964, 2.26526] [48.898728, 2.41143]

Hint

Si un fond gris s’affiche, c’est qu’il y a un problème de localisation ou d’accès à internet. Pour le premier cas, cela provient généralement d’un problème de projection ou d’une inversion des longitudes et latitudes.

Les longitudes représentent les x (axe ouest-est) et les latitudes y (axe sud-nord). De manière contrintuitive, folium attend qu’on lui fournisse les données sous la forme [latitude, longitude] donc [y,x]

Exercice 6 : Visualiser la localisation des stations

Calculer le centre centerde la carte des données compteurs. Il s’obtient en agrègeant l’ensemble des géométries, calculant le centroid et récupèrant la valeur sous forme de liste. Avec une logique similaire, calculez les bornes du sud-ouest sw et du nord-est ne de la carte.
Représenter la localisation des stations en utilisant un zoom optimal.

Make this Notebook Trusted to load map: File -> Trust Notebook

Exercice 7: Représenter les stations

Faire la même carte, avec des ronds proportionnels au nombre de comptages :

Pour le rayon de chaque cercle, vous pouvez appliquer la règle 500*x/max(x) (règle au doigt mouillé)
Vous pouvez réduire la taille des bordures de cercle avec l’option weight = 1 et fixer la couleur avec color = 'grey'
(Optionnel) Colorer en rouge les 10 plus grosses stations. L’opacité étant, par défaut, un peu faible, le paramètre fill_opacity = 0.4 améliore le rendu.
(Optionnel) Afficher, en supplément du nom du compteur lorsqu’on clique, la valeur du comptage en revenant à la ligne

La carte obtenue doit ressembler à la suivante :

Make this Notebook Trusted to load map: File -> Trust Notebook

3 Exercices supplémentaires

3.1 Densité de population dans la petite couronne parisienne

Pour cet exercice, le package cartiflette va être pratique pour récupérer un fonds de carte mélangeant arrondissements parisiens et communes dans les autres villes.

Nous allons privilégier une carte à ronds proportionnels (bubble map) aux cartes chorolèpthes qui trompent l’oeil.

Exercice: bubble map de densité des populations

Récupérer le fond de carte des départements 75, 92, 93 et 94 avec cartiflette. Pour cela, utiliser carti_download depuis cartiflette en fixant l’option borders à COMMUNE_ARRONDISSEMENT. Nommer cet objet df.
Afin que les calculs ultérieurs de surface ne soient pas faussés, assurez-vous que les données sont en Lambert 93 en reprojetant nos contours (code EPSG: 2154).
Créer un objet departements avec dissolve pour également disposer d’un fond de carte des départements
Créer une variable surface et utilisant la méthode area. L’unité doit être le km², il faut donc diviser par \(10^6\)
Créer une variable densite
Utiliser pd.cut avec les seuils 5000, 15000 et 30000 personnes par km². Vous pouvez utiliser l’option label pour dénommer les tranches
Créer un GeoDataFrame de points en utilisant la méthode centroid. Celui-ci nous servira à localiser le centre de nos ronds.
Représenter la densité communale sous forme de carte avec ronds proportionnels. Vous pouvez utiliser la variable créée à la question 5 pour les couleurs.

La carte obtenue devrait ressembler à celle-ci :

Text(0.3, 0.15, 'Source: IGN - AdminExpress')

Références supplémentaires

Geocomputation with Python

Informations additionnelles

environment files have been tested on.

Latest built version: 2024-08-29

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.7.0
appdirs	1.4.4
archspec	0.2.3
astroid	3.1.0
asttokens	2.4.1
attrs	23.2.0
babel	2.16.0
bcrypt	4.1.2
beautifulsoup4	4.12.3
black	24.8.0
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
bs4	0.0.2
cachetools	5.3.3
cartiflette	0.0.2
Cartopy	0.23.0
catalogue	2.0.10
cattrs	24.1.0
certifi	2024.2.2
cffi	1.16.0
charset-normalizer	3.3.2
chromedriver-autoinstaller	0.6.4
click	8.1.7
click-plugins	1.1.1
cligj	0.7.2
cloudpathlib	0.18.1
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.5
contextily	1.6.1
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.6.0
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.10.0
greenlet	3.0.3
gunicorn	21.2.0
h11	0.14.0
htmltools	0.5.3
hvac	2.1.0
idna	3.6
imageio	2.35.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.3.0
lz4	4.3.3
Mako	1.3.2
mamba	1.5.7
mapclassify	2.6.1
marisa-trie	1.2.0
Markdown	3.6
markdown-it-py	3.0.0
MarkupSafe	2.1.5
matplotlib	3.8.3
matplotlib-inline	0.1.6
mccabe	0.7.0
mdurl	0.1.2
menuinst	2.0.2
mercantile	1.2.1
mizani	0.11.4
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.5
outcome	1.3.0.post0
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.6
pluggy	1.4.0
polars	0.20.31
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.8.2
pydantic_core	2.20.1
pyflakes	3.2.0
Pygments	2.17.2
PyJWT	2.8.0
pylint	3.1.0
PyNaCl	1.5.0
pynsee	0.1.8
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.1
PyYAML	6.0.1
pyzmq	25.1.2
pyzstd	0.16.1
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.1
requests-oauthlib	2.0.0
rich	13.8.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.24.0
scikit-learn	1.4.1.post1
scipy	1.13.0
seaborn	0.13.2
selenium	4.24.0
setuptools	69.2.0
shapely	2.0.3
shellingham	1.5.4
six	1.16.0
smart_open	7.0.4
smmap	5.0.0
sniffio	1.3.1
snuggs	1.4.7
sortedcontainers	2.4.0
soupsieve	2.5
spacy	3.7.6
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.5
threadpoolctl	3.4.0
tifffile	2024.8.28
tomli	2.0.1
tomlkit	0.12.4
toolz	0.12.1
topojson	1.9
tornado	6.4
tqdm	4.66.2
traitlets	5.14.2
trio	0.26.2
trio-websocket	0.11.1
truststore	0.8.0
typer	0.12.5
typing_extensions	4.11.0
tzdata	2024.1
Unidecode	1.3.8
url-normalize	1.4.3
urllib3	1.26.18
wasabi	1.1.3
wcwidth	0.2.13
weasel	0.4.1
webdriver-manager	4.0.2
websocket-client	1.8.0
Werkzeug	3.0.2
wheel	0.43.0
widgetsnbextension	4.0.10
wordcloud	1.9.3
wrapt	1.16.0
wsproto	1.2.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
d242257	2024-08-22 18:51:51	Lino Galiana	At this point, notebooks should now all be functional ! (#547)
06d003a	2024-04-23 10:09:22	Lino Galiana	Continue la restructuration des sous-parties (#492)
8c316d0	2024-04-05 19:00:59	Lino Galiana	Fix cartiflette deprecated snippets (#487)
ce33d5d	2024-01-16 15:47:22	Lino Galiana	Adapte les exemples de code de cartiflette (#482)
005d89b	2023-12-20 17:23:04	Lino Galiana	Finalise l’affichage des statistiques Git (#478)
3fba612	2023-12-17 18:16:42	Lino Galiana	Remove some badges from python (#476)
4cd44f3	2023-12-11 17:37:50	Antoine Palazzolo	Relecture NLP (#474)
1f23de2	2023-12-01 17:25:36	Lino Galiana	Stockage des images sur S3 (#466)
b68369d	2023-11-18 18:21:13	Lino Galiana	Reprise du chapitre sur la classification (#455)
09654c7	2023-11-14 15:16:44	Antoine Palazzolo	Suggestions Git & Visualisation (#449)
889a71b	2023-11-10 11:40:51	Antoine Palazzolo	Modification TP 3 (#443)
ad654c5	2023-10-10 14:23:05	linogaliana	CQuick fix gzip csv
1c64660	2023-10-04 15:52:52	Lino Galiana	Quick fix remove contextily (#420)
154f09e	2023-09-26 14:59:11	Antoine Palazzolo	Des typos corrigées par Antoine (#411)
c7f8c94	2023-09-01 09:27:43	Lino Galiana	Ajoute un champ citation (#403)
17a238f	2023-08-30 15:06:18	Lino Galiana	Nouvelles données compteurs (#402)
0035b74	2023-08-29 14:51:26	Lino Galiana	Temporary fix for cartography pipeline (#401)
a8f90c2	2023-08-28 09:26:12	Lino Galiana	Update featured paths (#396)
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)
8df7cb2	2023-07-20 17:16:03	linogaliana	Change link
f0c583c	2023-07-07 14:12:22	Lino Galiana	Images viz (#371)
f21a24d	2023-07-02 10:58:15	Lino Galiana	Pipeline Quarto & Pages 🚀 (#365)
38693f6	2023-04-19 17:22:36	Lino Galiana	Rebuild visualisation part (#357)
3248633	2023-02-18 13:11:52	Lino Galiana	Shortcode rawhtml (#354)
b0abd02	2022-12-12 07:57:22	Lino Galiana	Fix cartiflette in additional exercise (#334)
e56f6fd	2022-12-03 17:00:55	Lino Galiana	Corrige typos exo compteurs (#329)
f10815b	2022-08-25 16:00:03	Lino Galiana	Notebooks should now look more beautiful (#260)
494a85a	2022-08-05 14:49:56	Lino Galiana	Images featured ✨ (#252)
d201e3c	2022-08-03 15:50:34	Lino Galiana	Pimp la homepage ✨ (#249)
5698e30	2022-06-03 18:28:37	Lino Galiana	Finalise widget (#232)
7b9f27b	2022-06-03 17:05:15	Lino Galiana	Essaie régler les problèmes widgets JS (#231)
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)
66a5276	2021-11-23 16:13:20	Lino Galiana	Relecture partie visualisation (#181)
2a8809f	2021-10-27 12:05:34	Lino Galiana	Simplification des hooks pour gagner en flexibilité et clarté (#166)
2f4d390	2021-09-02 15:12:29	Lino Galiana	Utilise un shortcode github (#131)
2e4d586	2021-09-02 12:03:39	Lino Galiana	Simplify badges generation (#130)
4cdb759	2021-05-12 10:37:23	Lino Galiana	:sparkles: :star2: Nouveau thème hugo :snake: :fire: (#105)
7f9f97b	2021-04-30 21:44:04	Lino Galiana	🐳 + 🐍 New workflow (docker 🐳) and new dataset for modelization (2020 🇺🇸 elections) (#99)
2924215	2020-10-08 13:35:18	Lino Galiana	modif slug cartographie
6477687	2020-10-08 13:31:00	Lino Galiana	Visualisation cartographique (#68)

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

Retour au sommet

Citation

BibTeX

@book{galiana2023,
  author = {Galiana, Lino},
  title = {Python pour la data science},
  date = {2023},
  url = {https://pythonds.linogaliana.fr/},
  doi = {10.5281/zenodo.8229676},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

Galiana, Lino. 2023. Python pour la data science. https://doi.org/10.5281/zenodo.8229676.

Note

Attention

1 Première carte avec l’API matplotlib de geopandas

Exercice 1: Importer les données

Warning

Exercice 2: Première carte

Exercice 3 : Ajouter un fonds de carte avec contextily

Exercice 3 : Ajouter un fonds de carte avec contextily

Exercice 4 : Data cleaning avant de pouvoir faire une heatmap

2 Des cartes réactives grâce à folium

Hint

Exercice 6 : Visualiser la localisation des stations

Exercice 7: Représenter les stations

3 Exercices supplémentaires

3.1 Densité de population dans la petite couronne parisienne

Exercice: bubble map de densité des populations

Références supplémentaires

Informations additionnelles

Citation

1 Première carte avec l’API `matplotlib` de `geopandas`

2 Des cartes réactives grâce à `folium`