Pourquoi Python s'est imposé pour travailler avec l'open data
Les plateformes de données ouvertes produisent chaque année des centaines de milliers de jeux de données : registres d'entreprises, statistiques de santé publique, données climatiques, budgets municipaux. Exploiter cette masse sans outillage adapté est tout simplement impossible. Python domine cet écosystème pour une raison concrète : sa bibliothèque standard couvre l'intégralité du pipeline, de la collecte à la visualisation.
Selon l'index TIOBE de 2024, Python reste le langage le plus utilisé au monde, notamment dans les sciences des données. Sa communauté open source a produit des bibliothèques spécialisées qui répondent précisément aux besoins des praticiens : récupérer des fichiers via des API, nettoyer des données hétérogènes, calculer des agrégats statistiques.
Ce guide détaille les trois piliers d'une chaîne de traitement : Requests pour l'acquisition, Pandas pour la transformation, et les méthodes d'analyse adaptées aux jeux de données publics.
Requests : accéder aux API et portails open data
Structure d'une requête vers une API publique
La majorité des portails open data modernes exposent leurs données via des API REST. En France, data.gouv.fr propose plus de 45 000 jeux de données accessibles par endpoint HTTP. La bibliothèque requests simplifie l'interaction avec ces interfaces.
import requests
url = "https://data.gouv.fr/api/1/datasets/"
params = {"q": "population", "page_size": 20}
response = requests.get(url, params=params)
data = response.json()
Quatre éléments méritent attention dans toute requête : le code de statut HTTP (200 = succès, 404 = ressource absente, 429 = limite de taux dépassée), les en-têtes de réponse qui précisent le format, le corps JSON ou CSV, et le mécanisme de pagination. Négliger la pagination est l'erreur la plus fréquente chez les débutants.
Gérer la pagination et les limites de taux
Les API open data imposent quasi systématiquement des limites de requêtes (rate limiting). L'API Eurostat tolère environ 60 requêtes par minute. Dépasser ce seuil déclenche des blocages temporaires qui peuvent compromettre un pipeline entier.
import time
def fetch_all_pages(base_url, params):
results = []
page = 1
while True:
params["page"] = page
r = requests.get(base_url, params=params)
if r.status_code != 200:
break
batch = r.json().get("data", [])
if not batch:
break
results.extend(batch)
page += 1
time.sleep(0.5) # respect du rate limiting
return results
Un délai de 0,5 seconde entre chaque requête est un compromis raisonnable entre performance et respect des conditions d'utilisation. Certains portails comme l'INSEE ou l'OCDE fournissent des clés API gratuites qui doublent ou triplent les quotas autorisés.
Pandas : transformer des données brutes en informations exploitables
Chargement et inspection initiale
Une fois les données récupérées (fichier CSV téléchargé depuis un portail ou réponse JSON), Pandas prend le relais. La bibliothèque gère nativement les formats les plus courants dans l'open data.
import pandas as pd
# Depuis une URL directe
df = pd.read_csv("https://exemple.data.gouv.fr/ressource.csv", sep=";", encoding="utf-8")
# Depuis une réponse JSON
df = pd.DataFrame(data["records"])
print(df.shape) # dimensions du jeu
print(df.dtypes) # types de colonnes
print(df.isnull().sum()) # valeurs manquantes
Cette inspection initiale prend deux minutes et révèle systématiquement des problèmes : colonnes mal typées (dates stockées comme chaînes), encodage défaillant, valeurs aberrantes. Un jeu de données public sur dix contient des erreurs structurelles non documentées.
Nettoyage : l'étape qui consomme 80 % du temps
Les données publiques proviennent souvent de systèmes administratifs hétérogènes. Un fichier de la base SIRENE peut contenir des codes postaux à quatre chiffres au lieu de cinq, des raisons sociales en majuscules, des dates en plusieurs formats simultanément.
# Standardisation des types
df["date_creation"] = pd.to_datetime(df["date_creation"], errors="coerce")
df["code_postal"] = df["code_postal"].astype(str).str.zfill(5)
# Suppression des doublons
df = df.drop_duplicates(subset=["siret"])
# Traitement des valeurs manquantes
df["effectif"] = df["effectif"].fillna(0)
df = df.dropna(subset=["raison_sociale"])
La règle empirique dans la communauté data science le confirme : 80 % du temps d'un projet passe dans la préparation des données. Automatiser ces étapes via des fonctions réutilisables réduit ce coût sur les projets récurrents.
Analyse de jeux de données publics : méthodes et cas pratiques
Agrégation et statistiques descriptives
Pandas offre des méthodes d'agrégation qui correspondent précisément aux questions posées sur les données publiques. Combien d'entreprises par secteur ? Quelle évolution du budget municipal sur dix ans ? Quelle distribution géographique des équipements sportifs ? Ces questions ont une réponse rapide.
# Répartition par secteur d'activité (code NAF)
secteur_stats = df.groupby("code_naf").agg(
nb_entreprises=("siret", "count"),
effectif_moyen=("effectif", "mean"),
effectif_total=("effectif", "sum")
).sort_values("nb_entreprises", ascending=False)
print(secteur_stats.head(10))
La méthode groupby combinée à agg couvre 90 % des besoins analytiques sur des données ouvertes. Elle génère en quelques lignes les tableaux croisés qui auraient nécessité des heures sous Excel.
Jointures entre jeux de données distincts
La vraie puissance de l'open data apparaît quand on croise plusieurs sources. Relier les données de criminalité de l'INSEE aux équipements scolaires par commune, ou joindre les statistiques électorales aux données socio-économiques de la CAF : ces croisements produisent des analyses impossibles avec une source unique.
# Jointure entre données démographiques et données d'équipements
df_pop = pd.read_csv("population_communes.csv")
df_equip = pd.read_csv("equipements_sportifs.csv")
df_merged = df_pop.merge(
df_equip.groupby("code_commune")["nb_equipements"].sum().reset_index(),
on="code_commune",
how="left"
)
df_merged["ratio_equip_hab"] = df_merged["nb_equipements"] / df_merged["population"] * 10000
On obtient un indicateur composite, ici le nombre d'équipements pour 10 000 habitants, directement comparable entre communes quelle que soit leur taille.
Détection d'anomalies et contrôle qualité
L'analyse de données publiques exige un regard critique sur la fiabilité des sources. Les erreurs de saisie, les changements de méthodologie entre années, les valeurs extrêmes légitimes ou aberrantes : toutes ces situations réclament une détection systématique.
# Détection des outliers par méthode IQR
Q1 = df["budget_total"].quantile(0.25)
Q3 = df["budget_total"].quantile(0.75)
IQR = Q3 - Q1
outliers = df[
(df["budget_total"] < Q1 - 1.5 * IQR) |
(df["budget_total"] > Q3 + 1.5 * IQR)
]
print(f"{len(outliers)} anomalies détectées sur {len(df)} lignes")
La méthode de l'écart interquartile (IQR) identifie les valeurs statistiquement éloignées de la médiane sans supposer de distribution normale. Elle convient particulièrement aux données administratives, rarement gaussiennes.
Structurer un pipeline reproductible
Du notebook au script de production
Jupyter Notebook convient à l'exploration et au prototypage. Pour un usage en production (une ingestion quotidienne de données ouvertes ou une mise à jour automatique d'indicateurs), la transformation en scripts Python structurés s'impose.
Un pipeline open data solide suit quatre étapes : extraction (Requests), transformation (Pandas), validation (assertions sur les volumes et types), chargement (CSV, base de données, ou Parquet pour les gros volumes). Chaque étape doit être isolée dans une fonction avec journalisation des erreurs.
Formats de sortie adaptés aux données ouvertes
Le format de sortie conditionne la réutilisabilité des analyses. Le CSV reste universel mais peu performant au-delà de 500 Mo. Parquet, format colonnaire open source créé par Apache, réduit la taille des fichiers de 60 à 80 % et accélère les lectures sélectives.
# Sauvegarde en Parquet
df_final.to_parquet("analyse_communes.parquet", index=False, compression="snappy")
# Lecture sélective de colonnes spécifiques
df_light = pd.read_parquet("analyse_communes.parquet", columns=["code_commune", "ratio_equip_hab"])
Publier ses résultats dans un format ouvert et documenté alimente directement l'écosystème open data. Les analyses reproductibles, accompagnées de leur code source, sont les plus utiles pour cet écosystème.
Les bibliothèques complémentaires à connaître
Trois bibliothèques étendent les capacités de Pandas sur des cas spécifiques à l'open data :
- GeoPandas : extension géospatiale de Pandas, utile pour les données cartographiques (fichiers GeoJSON, shapefiles) des collectivités territoriales
- OpenDataSoft SDK : client Python officiel pour les plateformes fondées sur la technologie Opendatasoft, utilisée par de nombreuses métropoles françaises
- SDMX-Python : bibliothèque dédiée au format SDMX, standard de diffusion statistique utilisé par Eurostat, la Banque mondiale et l'OCDE
Maîtriser ces outils en complément de Pandas couvre la quasi-totalité des formats rencontrés dans l'open data institutionnel européen.
