Comment Lire et Visualiser un Fichier Shapefile (.shp) avec Python ?

Comment Lire et Visualiser un Fichier Shapefile (.shp) avec Python

Les fichiers Shapefile sont l’un des formats les plus courants pour stocker des données géographiques vectorielles — points, lignes et polygones (par exemple : frontières de pays, périmètres d’incendies ou emplacements de fermes solaires).

Un shapefile est en réalité composé de plusieurs fichiers partageant le même nom de base, mais avec des extensions différentes :

Installation des bibliothèques nécessaires

Assurez-vous d’avoir installé les bibliothèques suivantes :

1

pip install geopandas matplotlib

Lecture d’un fichier Shapefile

Supposons que votre fichier s’appelle global_solar_panels.shp et qu’il soit dans le même dossier que votre script ou notebook :

1
2
3
4
5
6
7
8

import geopandas as gpd
import matplotlib.pyplot as plt

# Lecture du fichier shapefile
gdf = gpd.read_file("global_solar_panels.shp")

# Affiche les premières lignes
print(gdf.head())

Cette commande charge automatiquement la géométrie et les attributs (provenant du fichier .dbf).

Vérifier le système de coordonnées (CRS)

Il est important de connaître le système de coordonnées utilisé (par exemple WGS84, EPSG:4326).

1

print(gdf.crs)

Si votre jeu de données n’a pas de CRS défini, ou s’il n’est pas en latitude/longitude (EPSG:4326), vous pouvez le convertir :

1
2

if gdf.crs is None or gdf.crs.to_epsg() != 4326:
    gdf = gdf.to_crs(epsg=4326)

Comment visualiser les données

La façon de visualiser un shapefile dépend de la taille du jeu de données.
Les fichiers volumineux (par ex. données mondiales) peuvent ralentir l’affichage, il est donc souvent utile d’en inspecter un sous-ensemble d’abord.

Vérifier la taille du GeoDataFrame

Avant de tracer, il est recommandé de vérifier le nombre d’entités contenues dans le shapefile :

1

print(f"Nombre de lignes (entités) dans le GeoDataFrame : {len(gdf)}")

Cela vous aide à décider s’il vaut mieux tracer tout le jeu de données ou seulement un échantillon.

Créer un échantillon pour tester

Si votre shapefile est volumineux, vous pouvez tracer un sous-échantillon aléatoire pour tester le code ou la structure des données :

1
2
3
4
5
6
7
8
9

# Échantillon de 1000 entités (à ajuster selon les besoins)
gdf_sample = gdf.sample(1000, random_state=42)

# Tracé de l’échantillon
gdf_sample.plot(figsize=(10, 8), edgecolor='black', alpha=0.6)
plt.title("Échantillon des entités du shapefile")
plt.xlabel("Longitude")
plt.ylabel("Latitude")
plt.show()

Astuce : Utiliser un échantillon accélère l’affichage et facilite l’exploration des données sans charger l’ensemble complet.

Tracer le shapefile complet

Une fois les données vérifiées, vous pouvez facilement afficher l’ensemble complet :

1
2
3
4
5

gdf.plot(figsize=(12, 10), edgecolor='gray', alpha=0.5)
plt.title("Visualisation complète du shapefile")
plt.xlabel("Longitude")
plt.ylabel("Latitude")
plt.show()

Visualiser les données sur une carte satellite avec Folium

Installation des bibliothèques

Assurez-vous d’avoir installé les packages nécessaires :

1

pip install geopandas folium

Charger et échantillonner votre GeoDataFrame

Exemple :

1
2
3
4
5
6
7

import geopandas as gpd
import folium

gdf = gpd.read_file("global_solar_panels.shp")

# Prendre un petit échantillon si le jeu de données est grand
gdf_sample = gdf.sample(1000)

Créer une carte Folium avec un fond satellite

Vous pouvez utiliser Esri World Imagery comme fond satellite :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Calcul du centroïde pour centrer la carte
center = [gdf_sample.geometry.centroid.y.mean(), gdf_sample.geometry.centroid.x.mean()]

# Création de la carte
m = folium.Map(
    location=center,
    zoom_start=5,
    tiles='https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
    attr='Esri World Imagery'
)

Ajouter le GeoDataFrame à la carte

Superposez facilement vos géométries grâce à la couche GeoJson de Folium :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Sélectionner uniquement les colonnes non géométriques
tooltip_fields = [col for col in gdf_sample.columns if col != 'geometry']

# Limiter à 5 champs pour plus de clarté
tooltip_fields = tooltip_fields[:5]

folium.GeoJson(
    gdf_sample,
    name="Échantillon du shapefile",
    style_function=lambda x: {
        "color": "yellow",
        "weight": 2,
        "fillOpacity": 0.3
    },
    tooltip=folium.features.GeoJsonTooltip(fields=tooltip_fields)
).add_to(m)

folium.LayerControl().add_to(m)
m

(Optionnel) Enregistrer la carte interactive au format HTML

Vous pouvez exporter la carte interactive pour la visualiser dans n’importe quel navigateur :

1

m.save("shapefile_sample_satellite.html")

(Optionnel) Utiliser un autre fond de carte

Folium supporte plusieurs fournisseurs de fonds via folium.TileLayer.
Vous pouvez en ajouter plusieurs pour comparer :

1
2
3
4
5
6
7

folium.TileLayer('OpenStreetMap').add_to(m)
folium.TileLayer('Stamen Terrain').add_to(m)
folium.TileLayer('Stamen Toner').add_to(m)
folium.TileLayer('CartoDB positron').add_to(m)

# Fond satellite Esri (déjà ajouté manuellement ci-dessus)
folium.LayerControl().add_to(m)

Exemple de résultat

Références