Introduction à la cartographie avec Python

La cartographie est un excellent moyen de diffuser de la connaissance sur les données, y compris à des publics peu familiers de la statistique. Ce chapitre permet de découvrir le défi de la cartographie et la manière dont on peut utiliser Python pour construire des cartes.

Visualisation
Exercice
Auteur·rice

Lino Galiana

Date de publication

2024-11-20

Pour essayer les exemples présents dans ce tutoriel :
View on GitHub Onyxia Onyxia Open In Colab
Compétences à l’issue de ce chapitre

1 Introduction

La cartographie est l’une des plus anciennes représentations d’informations sous forme graphique. Longtemps cantonnée aux domaines militaires et administratifs ou à la synthèse d’informations pour la navigation, la cartographie est, au moins depuis le XIXe siècle, une des formes privilégiées de représentation de l’information. Il s’agit de l’époque où la carte par aplat de couleur, dite carte choroplèthe, a commencé à devenir une représentation de données géographiques traditionnelle.

D’après Chen et al. (2008), la première représentation de ce type a été proposée par Charles Dupin en 1826 Figure 1.1 pour représenter les niveaux d’instruction sur le territoire français. L’émergence des cartes choroplèthes est en effet indissociable de l’organisation du pouvoir sous forme d’entités politiques supposées unitaires. Par exemple, les cartes du monde représentent souvent des aplats de couleurs à partir des nations, les cartes nationales à partir d’échelons administratifs (régions, départements, communes, mais aussi Etats ou landers).

Figure 1.1: La première carte choroplèthes par Dupin (1826)

On peut voir l’émergence pendant le XIXe siècle de la carte choroplèthe comme un moment important de la cartographie, un glissement de l’usage militaire vers l’usage politique. Il ne s’agissait plus exclusivement de représenter le territoire physique mais aussi la réalité socioéconomique, dans des bornes administratives connues de tous.

Avec la prolifération de données géolocalisées et l’usage accru de données pour la décision, il est devenu crucial pour les data scientists de savoir faire une carte rapidement. Ce chapitre, complément de celui sur les données spatiales, propose quelques exercices pour apprendre les enjeux de la représentation de données sous forme cartographique avec Python.

Note

Produire de belles cartes demande du temps mais aussi du bon sens. Comme toute représentation graphique, il est important de réfléchir au message à faire passer et aux moyens appropriés. La sémiologie cartographique, une discipline scientifique qui s’intéresse aux messages transmis par les cartes, propose certaines règles pour éviter de transmettre des messages faussés, volontairement ou involontairement.

Certaines peuvent être retrouvées à travers des conseils pratiques dans ce guide de sémiologie cartographique de l’Insee. Celles-ci sont reprises dans ce guide.

Cette présentation de Nicolas Lambert revient, à partir de nombreux exemples, sur quelques principes de la dataviz cartographique.

Ce chapitre présentera d’abord quelques fonctionnalités basiques de Geopandas pour la construction de cartes figées. Pour contextualiser l’information présentée, nous utiliserons des contours officiels produits par l’IGN. Nous proposerons ensuite des cartes avec une contextualisation accrue et plusieurs niveaux d’information ce qui permettra d’illustrer l’intérêt de l’utilisation de librairies réactives, s’appuyant sur JavaScript, comme Folium.

1.1 Données utilisées

Au cours de ce chapitre, nous allons utiliser plusieurs jeux de données pour illustrer différents types de cartes:

  • Des comptages de population ;
  • Les limites départementales de la France métropolitaine ;
  • Les limites communales du Finistère ;
  • Le couvert forestier du département des Landes ;
  • La localisation des stations Velib ;

1.2 Installations préalables

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

# Sur colab
1!pip install pandas fiona shapely pyproj rtree geopandas
1
Ces librairies sont utiles pour l’analyse géospatiale (cf. chapitre dédié)

Nous allons principalement avoir besoin de Pandas et GeoPandas pour ce chapitre

import pandas as pd
import geopandas as gpd

2 Premières cartes pour connaître l’emprise spatiale de ses données

Nous allons utiliser cartiflette qui facilite la récupération des fonds de carte administratifs de l’IGN. Ce package est un projet interministériel visant à offrir une interface simple par le biais de Python pour récupérer des découpages officiels de l’IGN.

En premier lieu, nous allons récupérer les limites des départements:

from cartiflette import carti_download

departements = carti_download(
    values="France",
    crs=4326,
    borders="DEPARTEMENT",
    vectorfile_format="geojson",
    filter_by="FRANCE_ENTIERE_DROM_RAPPROCHES",
    source="EXPRESS-COG-CARTO-TERRITOIRE",
    year=2022,
)

Ces données rapprochent les DROM de la France hexagonale comme c’est expliqué dans l’un des tutoriels de cartiflette et comme l’exercice 1 permettra de le vérifier.

L’exercice 1 vise à s’assurer que nous avons bien récupéré les contours voulus en représentant simplement. Ceci devrait être le premier réflexe de tout geodata scientist.

Exercice 1: représentation des contours avec les méthodes de GeoPandas
  1. Utiliser la méthode plot sur le jeu de données departements pour vérifier l’emprise spatiale. Les coordonnées affichées vous évoquent quelle projection ? Vérifier avec la méthode crs.
  2. Reprojeter les données en Lambert 93 (EPSG: 2154) et faire la même carte.
  3. En utilisant les options matplotlib adéquates, représenter une carte avec les contours noirs, le fond blanc et sans axes.
  4. Faire la même carte pour les communes du Finistère

La carte des départements, sans modifier aucune option, ressemble à celle-ci

Les coordonnées affichées nous suggèrent du WGS84, ce qu’on peut vérifier avec la méthode CRS:

<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich

Si on fait la conversion en Lambert 93 (système légal pour l’hexagone), on obtient une emprise différente mais qui est censée être plus véridique pour la métropole (par pour les DROM rapprochés puisque, par exemple, la Guyane est en principe beaucoup plus grande).

Et bien sûr on retrouve facilement les cartes ratées du chapitre sur GeoPandas, par exemple si on applique une transformation prévue pour l’Amérique du Nord:

departements.to_crs(5070).plot()

Si on fait une carte un petit peu plus esthétique, cela nous donne:

Et la même pour le Finistère:

Ces cartes sont simples et pourtant elles font déjà appel à des connaissances implicites. Elles demandent déjà une connaissance du territoire. Quand nous commencerons à coloriser certains départements, savoir lesquels ont des valeurs extrêmes implique de bien connaître sa géographie française. De même, cela apparaît certes évident, mais rien ne dit dans notre carte du Finistère que ce département est bordé par l’océan. Un lecteur Français le verra comme une évidence mais ce n’est pas forcément le cas d’un lecteur étranger qui, bien sûr, ne connait pas le détail de notre géographie.

Pour cela, nous avons des parades grâce aux cartes réactives qui permettent:

  • D’afficher des informations contextuelles quand on passe la souris ou clique sur un élément de la carte.
  • D’afficher un fond de carte offrant des informations contextuelles comme les axes de transport, les localités ou les frontières naturelles.

Pour ceci, nous allons garder uniquement les données correspondant à une réelle emprise spatiale, ce qui exclut notre zoom de l’Ile de France et les DROM

1departements_no_duplicates = departements.drop_duplicates(subset="INSEE_DEP")
departements_hexagone = departements_no_duplicates.loc[
    ~departements["INSEE_DEP"].str.startswith("97")
2]
1
On retire le zoom sur l’Île de France
2
On ne garde que la France hexagonale

On obtient bien l’hexagone:

departements_hexagone.plot()

Pour le prochain exerice, nous allons avoir besoin de quelques variables supplémentaires. En premier lieu le centre géométrique de la France qui nous permettra de placer le centre de notre carte.

minx, miny, maxx, maxy = departements_hexagone.total_bounds
center = [(miny + maxy) / 2, (minx + maxx) / 2]

Nous allons aussi avoir besoin d’un dictionnaire pour renseigner à Folium des informations sur les paramètres de notre carte:

style_function = lambda x: {
1    "fillColor": "white",
    "color": "black",
    "weight": 1.5,
    "fillOpacity": 0.0,
}
1
En fait cela permettra d’avoir une couche transparente en combinant avec le paramètre fillOpacity à 0%.

style_function est une fonction anonyme qui sera utilisée dans l’exercice.

Une information qui s’affiche lorsqu’on passe la souris s’appelle un tooltip en langage de développement web.

import folium

tooltip = folium.GeoJsonTooltip(
    fields=["LIBELLE_DEPARTEMENT", "INSEE_DEP", "POPULATION"],
    aliases=["Département:", "Numéro:", "Population:"],
    localize=True,
)

Pour le prochain exercice, il faudra utiliser le GeoDataFrame dans la projection Mercator. En effet, Folium attend des données dans cette projection car cette librairie se base sur les fonds de carte de navigation, qui sont adaptés à cette représentation. En principe, on utilise plutôt Folium pour des représentations locales, où la déformation des surfaces induite par la projection Mercator n’est pas problématique. Pour le prochain exercice, où nous représenterons la France dans son ensemble, nous faisons donc un usage quelque peu détourné de la librairie. Mais la France étant encore assez lointaine du pôle nord, la déformation reste un prix à payer faible par rapport aux gains de l’interactivité.

Exercice 2: faire une première carte réactive avec Folium
  1. Créer la couche de fond en utilisant l’objet center et le niveau zoom_start égal à 5
  2. Mettre à jour celle-ci en utilisant notre departements_hexagone et les paramètres style_function et tooltip

Voici la couche de fond de la question 1:

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

Et une fois mise en forme, cela nous donne la carte:

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

Lorsqu’on passe sa souris sur la carte ci-dessus, on obtient quelques informations contextuelles. On peut donc jouer sur différents niveaux d’information : un premier coup d’oeil permet de se représenter les données dans l’espace, une recherche approfondie permet d’avoir des informations secondaires, utiles à la compréhension, mais pas indispensables.

Ces premiers exercices illustraient une situation où on ne désire représenter que les limites des polygones. C’est une carte utile pour rapidement placer son jeu de données dans l’espace mais ça n’apporte pas d’information supplémentaire. Pour cela, il va être nécessaire d’utiliser les données tabulaires associées à la dimension spatiale.

3 Représenter des données : un premier exemple avec une carte de couverture forestière

Pour cette partie, nous allons faire une carte du couvert forestier landais à partir de la BD Forêt produite par l’IGN. L’objectif n’est plus seulement de placer des limites du territoire d’intérêt mais de représenter de l’information sur celui-ci à partir des données présentes dans un GeoDataFrame.

La BD Forêt étant un petit peu volumineuse dans le format shapefile, nous proposons de la récupérer dans un format plus compressé: le geopackage.

foret = gpd.read_file(
    "https://minio.lab.sspcloud.fr/projet-formation/diffusion/r-geographie/landes.gpkg"
)

Nous allons aussi créer un masque pour les contours du département:

landes = departements.loc[departements["INSEE_DEP"] == "40"].to_crs(2154)
Exercice 3: première carte par aplat de couleur

Créer une carte du couvert forestier des Landes à partir des données importées précédemment depuis la BD Forêt. Vous pouvez ajouter les limites du département pour contextualiser cette carte.

Cette carte peut être créée via Geopandas et matplotlib ou via plotnine (cf. chapitre précédent).

Comme on peut le voir sur la carte (Figure 3.1), le département des Landes est très forestier. Ceci est logique puisque les deux tiers du département sont couverts, ce qu’on peut vérifier avec le calcul suivant1:

f"Part du couvert forestier dans les Landes: {float(foret.area.sum()/landes.area):.0%}"
/tmp/ipykernel_2146/849176039.py:1: FutureWarning:

Calling float on a single element Series is deprecated and will raise a TypeError in the future. Use float(ser.iloc[0]) instead

'Part du couvert forestier dans les Landes: 65%'
Figure 3.1: Couvert forestier des Landes

Ici la carte est assez claire et donne un message relativement lisible. Bien sûr on ne dispose pas de détails qui pourraient intéresser les curieux (par exemple quelles localités sont particulièrement couvertes) mais on dispose d’une vision synthétique du phénomène étudié.

4 Découverte des cartes choroplèthes

L’exercice précédent nous a permis de créer une carte par aplat de couleur. Ceci nous amène naturellement vers la carte choroplèthe, où l’aplat de couleur vise à représenter une information socioéconomique.

Nous allons utiliser les données de population présentes dans les données récupérées par le biais de cartiflette2. Nous allons nous amuser à créer la carte choroplèthe en lui donnant le style vintage des premières cartes de Dupin (1826).

Exercice 4: une première carte de population

L’objectif de cet exercice va être d’enrichir les informations présentées sur la carte des départements.

  1. Représenter rapidement la carte des départements en colorant en fonction de la variable POPULATION.

Cette carte présente plusieurs problèmes:

  • Si vous connaissez la géographie française, vous devriez noter une forme anormale, comme si l’axe est-ouest avait été agrandi par excès. C’est parce qu’il faut reprojeter la carte en Lambert 93.
  • Elle est peu lisible à cause de plusieurs facteurs: gradient continu, distribution non normale de la variable, légende perfectible, etc.

Les prochaines questions visent à améliorer ceci progressivement.

  1. Refaire cette carte dans la projection Lambert 93.
  2. Discrétiser la variable POPULATION en utilisant 4 classes par le biais d’une discrétisation par quantile. Refaire la carte.
  3. Diviser votre population par la taille de chaque département (en km2) en créant une variable à partir de .area.div(1e6)3.
  4. Choisir une palette de couleur vintage type échelle de gris.

La première question donne une carte ayant cet aspect:

Elle est déjà améliorée par l’utilisation d’une projection adaptée pour le territoire, le Lambert 93 (question 2):

La carte ci-dessous, après discrétisation (question 3), donne déjà une représentation plus véridique des inégalités de population. On remarque que la diagonale du vide commence à se dessiner ce qui est logique pour une carte de population.

Cependant, l’un des problèmes des choroplèthes est qu’elles donnent un poids exagéré aux grands espaces. Ceci avait été particulièrement mis en avant dans le cas des cartes électorales avec le visuel “Land doesn’t vote, people do” (version élections européennes de 2024). Sans pouvoir totalement s’abstraire de ce problème, pour cela il faudrait changer de type de représentation graphique, par exemple avec des ronds proportionnels, on peut déjà réduire l’effet de la surface sur notre variable d’intérêt en représentant la densité (population au km² plutôt que la population).

On obtient donc la carte suivante lorsqu’on représente la densité plutôt que la population totale:

Cela nous donne déjà une image plus véridique de la distribution de la population sur le territoire français. Néanmoins, la palette de couleur desigual utilisée par défaut n’aide pas trop à saisir les nuances. Avec une palette de couleur en nuancier, qui tient compte de l’aspect ordinal de nos données, on obtient une carte plus lisible (question 5):

C’est déjà mieux. Néanmoins, pour avoir une meilleure carte, il faudrait choisir une discrétisation plus adéquate. C’est un travail itératif important, qui mobilise plusieurs domaines de compétences: statistique, sociologie ou économie selon le type d’information représentée, informatique, etc. Bref, la palette normale de compétences d’un data scientist.

5 Représenter des données infracommunales

Jusqu’à présent, nous avons travaillé sur des données où, en soi, représenter des frontières administratives suffisait pour contextualiser. Penchons maintenant sur le cas où avoir un fonds de carte contextuel va devenir crucial: les cartes infracommunales.

Pour cela nous allons représenter la localisation des stations Velib. Celles-ci sont disponibles en open data sur le site de la Mairie de Paris.

import geopandas as gpd

velib_data = "https://opendata.paris.fr/explore/dataset/velib-emplacement-des-stations/download/?format=geojson&timezone=Europe/Berlin&lang=fr"
stations = gpd.read_file(velib_data)
Skipping field coordonnees_geo: unsupported OGR type: 3

Si on représente directement celles-ci avec la méthode plot, on manque de contexte:

stations.plot()

Il est même impossible de savoir si on se trouve réellement dans Paris. On peut essayer d’associer à nos découpages administratifs pour vérifier qu’on se situe bien dans la région parisienne.

La première étape est de récupérer les découpages des arrondissements parisiens et des communes limitrophes, ce qui se fait facilement avec cartiflette:

from cartiflette import carti_download

# 1. Fonds communaux
contours_villes_arrt = carti_download(
    values=["75", "92", "93", "94"],
    crs=4326,
    borders="COMMUNE_ARRONDISSEMENT",
    filter_by="DEPARTEMENT",
    source="EXPRESS-COG-CARTO-TERRITOIRE",
    year=2022,
)

# 2. Départements
departements = contours_villes_arrt.dissolve("INSEE_DEP")

Si maintenant on utilise ce masque pour contextualiser les données, on est rasurré sur la nature des données

ax = stations.sample(200).plot(color="red")
contours_villes_arrt.boundary.plot(ax=ax, edgecolor="k", linewidth=0.5)
departements.boundary.plot(ax=ax, edgecolor="blue", linewidth=1)
ax.set_axis_off()

Les Parisiens reconnaîtront facilement leur bourgade car ils connaissent bien l’organisation de l’espace de cette agglomération. Cependant pour des lecteurs ne connaissant pas celle-ci, cette carte sera de peu de secours. L’idéal est plutôt d’utiliser le fonds de carte contextuel de Folium pour cela.

Afin de ne pas surcharger la carte, il est utile d’utiliser la dimension réactive de Folium en laissant l’utilisateur.trice naviguer dans la carte et afficher un volume d’information adapté à la fenêtre visible. Pour cela, Folium embarque une fonctionnalité MarkerCluster très pratique.

On peut ainsi produire la carte désirée de cette manière:

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

Références supplémentaires

Informations additionnelles

environment files have been tested on.

Latest built version: 2024-11-20

Python version used:

'3.12.6 | packaged by conda-forge | (main, Sep 30 2024, 18:08:52) [GCC 13.3.0]'
Package Version
affine 2.4.0
aiobotocore 2.15.1
aiohappyeyeballs 2.4.3
aiohttp 3.10.8
aioitertools 0.12.0
aiosignal 1.3.1
alembic 1.13.3
altair 5.4.1
aniso8601 9.0.1
annotated-types 0.7.0
appdirs 1.4.4
archspec 0.2.3
asttokens 2.4.1
attrs 24.2.0
babel 2.16.0
bcrypt 4.2.0
beautifulsoup4 4.12.3
black 24.8.0
blinker 1.8.2
blis 0.7.11
bokeh 3.5.2
boltons 24.0.0
boto3 1.35.23
botocore 1.35.23
branca 0.7.2
Brotli 1.1.0
cachetools 5.5.0
cartiflette 0.0.2
Cartopy 0.24.1
catalogue 2.0.10
cattrs 24.1.2
certifi 2024.8.30
cffi 1.17.1
charset-normalizer 3.3.2
click 8.1.7
click-plugins 1.1.1
cligj 0.7.2
cloudpathlib 0.20.0
cloudpickle 3.0.0
colorama 0.4.6
comm 0.2.2
commonmark 0.9.1
conda 24.9.1
conda-libmamba-solver 24.7.0
conda-package-handling 2.3.0
conda_package_streaming 0.10.0
confection 0.1.5
contextily 1.6.2
contourpy 1.3.0
cryptography 43.0.1
cycler 0.12.1
cymem 2.0.8
cytoolz 1.0.0
dask 2024.9.1
dask-expr 1.1.15
databricks-sdk 0.33.0
debugpy 1.8.6
decorator 5.1.1
Deprecated 1.2.14
diskcache 5.6.3
distributed 2024.9.1
distro 1.9.0
docker 7.1.0
duckdb 0.10.1
en-core-web-sm 3.7.1
entrypoints 0.4
et_xmlfile 2.0.0
exceptiongroup 1.2.2
executing 2.1.0
fastexcel 0.11.6
fastjsonschema 2.20.0
fiona 1.10.1
Flask 3.0.3
folium 0.17.0
fontawesomefree 6.6.0
fonttools 4.54.1
frozendict 2.4.4
frozenlist 1.4.1
fsspec 2023.12.2
funcy 2.0
gensim 4.3.2
geographiclib 2.0
geopandas 1.0.1
geoplot 0.5.1
geopy 2.4.1
gitdb 4.0.11
GitPython 3.1.43
google-auth 2.35.0
graphene 3.3
graphql-core 3.2.4
graphql-relay 3.2.0
graphviz 0.20.3
great-tables 0.12.0
greenlet 3.1.1
gunicorn 22.0.0
h2 4.1.0
hpack 4.0.0
htmltools 0.6.0
hyperframe 6.0.1
idna 3.10
imageio 2.36.0
importlib_metadata 8.5.0
importlib_resources 6.4.5
inflate64 1.0.0
ipykernel 6.29.5
ipython 8.28.0
itsdangerous 2.2.0
jedi 0.19.1
Jinja2 3.1.4
jmespath 1.0.1
joblib 1.4.2
jsonpatch 1.33
jsonpointer 3.0.0
jsonschema 4.23.0
jsonschema-specifications 2024.10.1
jupyter-cache 1.0.0
jupyter_client 8.6.3
jupyter_core 5.7.2
kaleido 0.2.1
kiwisolver 1.4.7
langcodes 3.5.0
language_data 1.3.0
lazy_loader 0.4
libmambapy 1.5.9
locket 1.0.0
lxml 5.3.0
lz4 4.3.3
Mako 1.3.5
mamba 1.5.9
mapclassify 2.8.1
marisa-trie 1.2.1
Markdown 3.6
markdown-it-py 3.0.0
MarkupSafe 2.1.5
matplotlib 3.9.2
matplotlib-inline 0.1.7
mdurl 0.1.2
menuinst 2.1.2
mercantile 1.2.1
mizani 0.11.4
mlflow 2.16.2
mlflow-skinny 2.16.2
msgpack 1.1.0
multidict 6.1.0
multivolumefile 0.2.3
munkres 1.1.4
murmurhash 1.0.10
mypy-extensions 1.0.0
narwhals 1.14.1
nbclient 0.10.0
nbformat 5.10.4
nest_asyncio 1.6.0
networkx 3.3
nltk 3.9.1
numexpr 2.10.1
numpy 1.26.4
opencv-python-headless 4.10.0.84
openpyxl 3.1.5
opentelemetry-api 1.16.0
opentelemetry-sdk 1.16.0
opentelemetry-semantic-conventions 0.37b0
OWSLib 0.28.1
packaging 24.1
pandas 2.2.3
paramiko 3.5.0
parso 0.8.4
partd 1.4.2
pathspec 0.12.1
patsy 0.5.6
Pebble 5.0.7
pexpect 4.9.0
pickleshare 0.7.5
pillow 10.4.0
pip 24.2
platformdirs 4.3.6
plotly 5.24.1
plotnine 0.13.6
pluggy 1.5.0
polars 1.8.2
preshed 3.0.9
prometheus_client 0.21.0
prometheus_flask_exporter 0.23.1
prompt_toolkit 3.0.48
protobuf 4.25.3
psutil 6.0.0
ptyprocess 0.7.0
pure_eval 0.2.3
py7zr 0.20.8
pyarrow 17.0.0
pyarrow-hotfix 0.6
pyasn1 0.6.1
pyasn1_modules 0.4.1
pybcj 1.0.2
pycosat 0.6.6
pycparser 2.22
pycryptodomex 3.21.0
pydantic 2.9.2
pydantic_core 2.23.4
Pygments 2.18.0
pyLDAvis 3.4.1
PyNaCl 1.5.0
pynsee 0.1.8
pyogrio 0.10.0
pyOpenSSL 24.2.1
pyparsing 3.1.4
pyppmd 1.1.0
pyproj 3.7.0
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.2
pyzmq 26.2.0
pyzstd 0.16.2
querystring_parser 1.2.4
rasterio 1.4.2
referencing 0.35.1
regex 2024.9.11
requests 2.32.3
requests-cache 1.2.1
retrying 1.3.4
rich 13.9.4
rpds-py 0.21.0
rsa 4.9
Rtree 1.3.0
ruamel.yaml 0.18.6
ruamel.yaml.clib 0.2.8
s3fs 2023.12.2
s3transfer 0.10.2
scikit-image 0.24.0
scikit-learn 1.5.2
scipy 1.13.0
seaborn 0.13.2
setuptools 74.1.2
shapely 2.0.6
shellingham 1.5.4
six 1.16.0
smart-open 7.0.5
smmap 5.0.0
sortedcontainers 2.4.0
soupsieve 2.5
spacy 3.7.5
spacy-legacy 3.0.12
spacy-loggers 1.0.5
SQLAlchemy 2.0.35
sqlparse 0.5.1
srsly 2.4.8
stack-data 0.6.2
statsmodels 0.14.4
tabulate 0.9.0
tblib 3.0.0
tenacity 9.0.0
texttable 1.7.0
thinc 8.2.5
threadpoolctl 3.5.0
tifffile 2024.9.20
toolz 1.0.0
topojson 1.9
tornado 6.4.1
tqdm 4.66.5
traitlets 5.14.3
truststore 0.9.2
typer 0.13.1
typing_extensions 4.12.2
tzdata 2024.2
Unidecode 1.3.8
url-normalize 1.4.3
urllib3 1.26.20
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.4
wheel 0.44.0
wordcloud 1.9.3
wrapt 1.16.0
xgboost 2.1.1
xlrd 2.0.1
xyzservices 2024.9.0
yarl 1.13.1
yellowbrick 1.5
zict 3.0.0
zipp 3.20.2
zstandard 0.23.0

View file history

SHA Date Author Description
cbe6459 2024-11-12 07:24:15 lgaliana Revoir quelques abstracts
886389c 2024-10-21 08:59:14 lgaliana rappel mercator folium
9cf2bde 2024-10-18 15:49:47 lgaliana Reconstruction complète du chapitre de cartographie
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)
Retour au sommet

Les références

Chen, Chun-houh, Wolfgang Härdle, Antony Unwin, et Michael Friendly. 2008. « A brief history of data visualization ». Handbook of data visualization, 15‑56.

Notes de bas de page

  1. Ce calcul est possible car les deux bases sont en projection Lambert 93 pour lequel les opérations géométriques (dont les calculs de surface) sont autorisés.↩︎

  2. Stricto sensu, il faudrait vérifier que ces colonnes correspondent bien aux populations légales définies par l’Insee. Cette variable est fournie nativement par l’IGN dans ses fonds de carte. Nous laissons les lecteurs intéressés faire ce travail, qui permet de réviser les compétences Pandas.↩︎

  3. Le Lambert 93 donne une aire en mètres carrés. Pour la transformer en km², il faut faire div(1e6).↩︎

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.