01 Le principe : rien d'inventé
Quand j'ai ouvert Lille, je me suis fixé une règle : chaque critère doit venir d'une donnée publique que je peux citer. Si une source manque, le critère n'est pas proposé, plutôt que d'être estimé au doigt mouillé.
Toute la ville est produite par une seule commande Django, import_ilevia, que je peux relancer à tout moment. Elle prend trois fichiers téléchargés (le GTFS, les comptages aux portillons et la liste des gares), interroge deux API, croise le tout et écrit un fichier de données, lille/stations.json, que le jeu charge en base à chaque déploiement.
make import-lille # télécharge, puis : manage.py import_ilevia ilevia-gtfs.zip ilevia-entrees-metro.csv gares-de-voyageurs.csv
make load-stations # charge le fichier dans la ville de Lille
Le résultat : 2 lignes, 60 stations, et une cinquantaine de critères jouables.
02 Les sources
| Source | Éditeur | Licence | Ce que j'y prends |
|---|---|---|---|
| GTFS du réseau Ilévia | Métropole européenne de Lille, via data.gouv.fr | Licence ouverte 2.0 | Lignes, couleurs, ordre des stations, quais et leurs coordonnées, arrêts du tramway |
| Wikipédia en français (API MediaWiki) | Wikimédia | CC BY-SA 4.0 | Nom de la station, année de mise en service, niveau |
| API Découpage administratif (geo.api.gouv.fr) | Etalab | Licence ouverte | La commune de chaque station |
| Gares de voyageurs | SNCF | ODbL | Position des gares, pour les correspondances avec le train |
| Flux des entrées et sorties des stations de métro | Ilévia, via la Métropole européenne de Lille | Licence ouverte 2.0 | Les entrées de chaque station, heure par heure, pour la fréquentation |
Le GTFS est le format que les réseaux de transport publient pour les applications d'itinéraire : une archive de fichiers CSV. routes.txt décrit les lignes, stops.txt les arrêts et leurs coordonnées, trips.txt chaque course, et stop_times.txt, le plus gros, chaque passage de chaque rame à chaque arrêt. C'est ma colonne vertébrale.
03 Le format GTFS
Voici les deux lignes de métro dans routes.txt, au milieu de centaines de lignes de bus :
route_id,agency_id,route_short_name,route_long_name,route_desc,route_type,route_url,route_color,route_text_color
ME1,ILE,M1,METRO LIGNE 1,CHU EURASANTÉ <> 4 CANTONS STADE P MAUROY,1,,FDC41F,000000
ME2,ILE,M2,METRO LIGNE 2,SAINT PHILIBERT <> C.H. DRON,1,,E30613,FFFFFF
route_type dit le mode : 0 pour le tram, 1 pour le métro, 3 pour le bus. Dans stops.txt, une station est une zone d'arrêt (location_type 1) qui regroupe ses accès et ses quais (location_type 0), reliés par parent_station :
stop_id,stop_name,stop_desc,stop_lat,stop_lon,zone_id,stop_url,location_type,parent_station,stop_timezone,wheelchair_boarding
920,Gare Lille Flandres,GARE LILLE FLANDRES 59000 LILLE,50.637779,3.070865,1,,1,,,0
LIG011,Gare Lille Flandres,59000 LILLE -,50.636405,3.071141,1,,0,920,,1
LIG115,Gare Lille Flandres,RUE DES CANONIERS 59000 LILLE - AU DROIT DE LA PL ST HUBERT,50.638408,3.070733,1,,0,920,,1
Et stop_times.txt, le plus gros fichier de l'archive, donne chaque passage : une course (trip_id), un arrêt, son rang dans la course.
trip_id,arrival_time,departure_time,stop_id,stop_sequence,stop_headsign,pickup_type,drop_off_type,shape_dist_traveled,timepoint,stop_time_desc
5440172,05:30:00,05:30:00,4CR001,1,,0,0,,,
5440172,05:32:00,05:32:00,RCT002,2,,0,0,,,
Le sens de chaque course (direction_id, 0 ou 1) et sa ligne sont dans trips.txt.
04 Du GTFS aux stations
Je lis l'archive sans la décompresser sur le disque, avec le module zipfile de Python. Les lignes de métro sont celles de route_type 1 : M1 et M2 deviennent la ligne 1 (#FDC41F, texte noir) et la ligne 2 (#E30613, texte blanc). Je ne garde que les courses de ces lignes et du tram, puis je parcours stop_times.txt une seule fois, en flux, pour reconstituer la suite d'arrêts de chaque course :
with zipfile.ZipFile(path) as archive:
routes = {r["route_id"]: r for r in _rows(archive, "routes.txt")}
metro = {
rid: r["route_short_name"].removeprefix("M")
for rid, r in routes.items()
if r["route_type"] == METRO_ROUTE_TYPE
}
tram = {rid for rid, r in routes.items() if r["route_type"] == TRAM_ROUTE_TYPE}
trips = {
t["trip_id"]: (t["route_id"], t["direction_id"])
for t in _rows(archive, "trips.txt")
if t["route_id"] in metro or t["route_id"] in tram
}
...
trip_stops: dict[str, list[tuple[int, str]]] = defaultdict(list)
for row in _rows(archive, "stop_times.txt"): # a big file: streamed once
if row["trip_id"] in trips:
trip_stops[row["trip_id"]].append((int(row["stop_sequence"]), row["stop_id"]))
Les passages d'une course ne sont pas forcément rangés dans le fichier : je les trie par stop_sequence, puis je compte combien de courses font chaque suite de noms, par ligne et par sens. La plus longue suite du sens 0 donne la ligne. Les autres doivent en être des morceaux, sinon la commande s'arrête :
def main_path(
code: str, sequences: Mapping[tuple[str, str], Counter[tuple[str, ...]]]
) -> list[str]:
ours = sequences[code, "0"]
if not ours:
raise CommandError(f"Line {code}: no trip in direction 0.")
main = max(ours, key=lambda sequence: (len(sequence), ours[sequence]))
if len(set(main)) != len(main):
raise CommandError(f"Line {code}: a station twice in its longest trip.")
for direction in ("0", "1"):
for sequence in sequences[code, direction]:
if not set(sequence) <= set(main):
extra = sorted(set(sequence) - set(main))
raise CommandError(f"Line {code}: a trip serves {extra}, off its main path.")
return list(main)
Les lignes de Lille n'ont pas de fourche, seulement des services partiels. Si un jour l'une d'elles en avait, l'import s'arrêterait au lieu de produire une ligne fausse : c'est voulu.
Une station, dans le GTFS, ce sont plusieurs quais : un par sens, parfois un par ligne. Je les regroupe par nom, et la position de la station est la moyenne de ses quais. Gare Lille-Flandres et Porte des Postes, desservies par les deux lignes, ne font ainsi qu'une station chacune : 18 + 44 − 2 = 60. Les terminus se lisent aux deux bouts de chaque chemin.
05 Wikipédia, recousue par la géographie
Le GTFS ne dit rien de l'histoire. Pour l'année d'ouverture et le niveau, j'interroge l'API MediaWiki de Wikipédia en deux temps. D'abord, la liste des articles de chaque catégorie, « Station de la ligne 1 du métro de Lille » et « … ligne 2 … » :
GET https://fr.wikipedia.org/w/api.php?action=query&list=categorymembers
&cmtitle=Catégorie:Station de la ligne 1 du métro de Lille&cmlimit=100&format=json&formatversion=2
Puis leur wikitexte, la source brute des articles, par lots de 20 titres séparés par | (prop=revisions&rvprop=content). Chaque appel s'identifie par un User-Agent, comme Wikimédia le demande, et une réponse 429 ou 5xx est retentée après une pause, celle de l'en-tête Retry-After quand le serveur en donne une.
Ce qui m'intéresse est l'infobox, en haut de l'article. Voici celle de Rihour, raccourcie :
{{Infobox Station de métro
| nom = Rihour
| ville = [[Lille]]
| latitude = 50.63551389
| longitude = 3.062902778
| position = Souterrain
| quais = 2
| mise en service = {{date|25|avril|1983}}
| exploitant = [[Ilévia]]
Le wikitexte n'a pas de structure garantie, mais les champs d'une infobox suivent toujours la forme | clé = valeur, un par ligne. Une expression régulière suffit :
def infobox_field(wikitext: str, key: str) -> str:
found = re.search(rf"^\s*\|\s*{re.escape(key)}\s*=[ \t]*(.*)$", wikitext, re.MULTILINE)
return found.group(1).strip() if found else ""
L'année est le plus petit nombre de 19xx ou 20xx trouvé dans mise en service : une station de correspondance y liste une date par ligne, et le modèle {{date|25|avril|1983}} n'a pas besoin d'être interprété.
years = [
int(y) for y in re.findall(r"\b(?:19|20)\d{2}\b", infobox_field(wikitext, "mise en service"))
]
if not years:
raise CommandError(f"{title}: no opening year in its infobox.")
Le champ position est du texte libre (« Souterrain », « Aérienne », « En surface »…), que je ramène à trois niveaux :
def level_of(position: str) -> Level:
text = normalize(position)
if text.startswith("aerien"):
return "aerienne"
if "surface" in text:
return "fleur_de_sol"
if text.startswith("souterrain") or "tranchee" in text:
# An open cut ("En tranchée ouverte": Croix-Paquet in Lyon) is below the ground.
return "souterraine"
raise ValueError(f"unknown position {position!r}")
Une valeur inconnue fait échouer l'import plutôt que de passer en silence. La même fonction sert pour Lyon.
Reste à savoir quel article parle de quelle station. Les noms ne suffisent pas : le GTFS et Wikipédia n'écrivent pas pareil. Je rapproche donc par la distance : toutes les paires (station, article) sont rangées de la plus proche à la plus lointaine, et associées dans cet ordre, une seule fois chacune, à moins de 300 m. C'est un appariement glouton : il ne cherche pas l'optimum global, mais sur un réseau où les stations sont à plusieurs centaines de mètres les unes des autres, la paire la plus proche est toujours la bonne.
pairs = sorted(
(haversine(lat, lon, article.lat, article.lon), name, article.title)
for name, (lat, lon) in centres.items()
for article in articles
if article.lat is not None and article.lon is not None
)
matched: dict[str, Article] = {}
used: set[str] = set()
for distance, name, title in pairs:
if distance <= ARTICLE_RADIUS and name not in matched and title not in used:
matched[name] = by_title[title]
used.add(title)
left_stations = sorted(set(centres) - matched.keys())
left_articles = sorted(a.title for a in articles if a.title not in used)
if len(left_stations) == len(left_articles) == 1:
matched[left_stations[0]] = by_title[left_articles[0]]
elif left_stations or left_articles:
raise CommandError(f"Unmatched stations {left_stations}, unmatched articles {left_articles}")
haversine donne la distance à vol d'oiseau sur la sphère terrestre. Un article sans coordonnées prend la dernière station restante, s'il n'en reste qu'une de chaque côté ; tout autre reste fait échouer l'import.
Le nom affiché dans le jeu est le titre de l'article sans son suffixe « (métro de Lille) », pas celui du GTFS : c'est pour ça que tu lis « Gare Lille-Flandres » ou « Cité Scientifique - Professeur Gabillard ».
Pour une station de correspondance, l'année retenue est la plus ancienne. J'ai aussi comparé avec Wikidata (propriété P1619, date d'ouverture) : les deux sources donnent les mêmes années, sauf pour Jean-Jaurès, que Wikidata date de 1989 par erreur. Elle a ouvert en 1999, avec le prolongement de la ligne 2.
| Années | Ce qui ouvre |
|---|---|
| 1982 – 1984 | La ligne 1, d'abord à Villeneuve-d'Ascq |
| 1989 | La ligne 2, jusqu'à Saint-Philibert |
| 1994 | Gare Lille-Europe, avec le TGV |
| 1995 – 2000 | Les prolongements de la ligne 2 vers Roubaix et Tourcoing |
06 La commune, à la coordonnée près
Pour la commune, j'interroge l'API Découpage administratif avec la position de chaque station, en ne demandant que les deux champs utiles :
GET https://geo.api.gouv.fr/communes?lat=50.6355&lon=3.0629&fields=nom,codeDepartement&format=json
[{"nom": "Lille", "codeDepartement": "59"}]
L'API renvoie la commune qui contient ce point. Les 60 appels partent sur 6 fils en parallèle, avec jusqu'à 5 nouvelles tentatives et une attente croissante quand l'API répond 429 (trop de requêtes) ou 5xx.
Une subtilité : Lomme et Hellemmes sont des communes associées à Lille, et l'API les range donc dans Lille. Seules Pont Supérieur et Lomme - Lambersart - Arthur-Notebart tombent du côté de Lambersart.
| Commune | Stations |
|---|---|
| Lille | 29 |
| Tourcoing | 9 |
| Villeneuve-d'Ascq | 7 |
| Roubaix | 6 |
| Mons-en-Barœul | 3 |
| Lambersart, Croix, Wasquehal | 2 chacune |
07 Le tram et le train
Une station est en correspondance avec le tramway (le Mongy, route_type 0) si l'un de ses quais partage un parent_station avec un arrêt de tram dans le GTFS, ou s'il est à moins de 150 m d'un arrêt. Cinq stations répondent, dont Eurotéléport et Wasquehal - Pavé de Lille.
Pour le train, je croise avec la liste des gares de voyageurs de la SNCF, un CSV séparé par des points-virgules dont la position tient dans une seule colonne, latitude et longitude séparées par une virgule :
nom;libellecourt;segment_drg;position_geographique;codeinsee;codes_uic;id
Lille Flandres;LLF;A;50.636577, 3.06987;59350;87286005;2df9f83c-36e9-48f3-b6a5-4bd45aeb91fe
with path.open(encoding="utf-8-sig", newline="") as f:
for row in csv.DictReader(f, delimiter=";"):
if row["position_geographique"]:
lat, lon = (float(part) for part in row["position_geographique"].split(","))
gares.append((row["nom"], lat, lon))
L'encodage utf-8-sig retire le BOM, ce caractère invisible que certains exports placent en tête de fichier et qui, sinon, se collerait au nom de la première colonne. Mais le point de la SNCF n'est pas toujours là où je l'attends : celui de Tourcoing est à 385 m de la station Gare de Tourcoing. D'où deux règles, la distance ou le nom :
connected = set()
for name, points in gtfs.platforms.items():
station = normalize(names[name])
for gare, lat, lon in gares:
near = any(haversine(p.lat, p.lon, lat, lon) <= TRAIN_CONNECTION_RADIUS for p in points)
named = station.startswith("gare ") and normalize(gare) in station
if near or named:
connected.add(name)
normalize retire accents, casse et ponctuation avant de comparer. Six stations répondent au total, de Pont de Bois à Gare Jean-Lebas Roubaix.
08 La fréquentation, aux portillons
C'est la source qui est arrivée en dernier. Ilévia publie, station par station et heure par heure, le nombre de passages comptés aux portillons, entrées et sorties à part, de septembre 2025 à octobre 2026 : plus de 560 000 lignes. Le jeu de données est servi par le WFS de la Métropole, qui rend tout en un seul CSV d'environ 45 Mo, sans clé ni pagination, en demandant seulement les colonnes utiles :
FID,objectid,date_jour,heure_debut,libelle_station,code_arret_commercial,nombre_entree_heure,code_ligne
entree_sortie_metro.3882324,3882324,2025-09-23,2025-09-23T08:00:00,Gare Lille Flandres,920,1771,ME1
Ce mardi-là, entre 8 h et 9 h, 1 771 voyageurs sont entrés à Gare Lille Flandres. Trois choix transforment ces lignes en un chiffre par station :
- Les entrées seulement. C'est la définition du trafic entrant de la RATP, celle des chiffres de Paris : un voyageur compte une fois, là où il monte.
- Pas les heures de 1 h à 5 h. Ilévia prévient que ce qui y est compté vient des opérations de maintenance, pas des voyageurs.
- Une moyenne par jour compté. Chaque station a entre 364 et 398 jours de mesures : diviser par ses propres jours évite de pénaliser celles qui ont eu des trous.
totals: Counter[str] = Counter()
days: defaultdict[str, set[str]] = defaultdict(set)
for row in csv.DictReader(f):
station, day = row["libelle_station"].strip(), row["date_jour"].strip()
days[station].add(day)
if int(row["heure_debut"][11:13]) not in MAINTENANCE_HOURS:
totals[station] += int(row["nombre_entree_heure"])
ridership = {station: round(totals[station] / len(days[station])) for station in days}
Les colonnes sont lues par leur nom, et une valeur illisible arrête l'import plutôt que de compter pour zéro.
Des noms plus courts
Ilévia nomme ses stations comme sur les quais, plus court que Wikipédia : 52 des 60 se retrouvent une fois les accents, la casse et la ponctuation retirés, les 8 autres passent par une table écrite à la main.
RIDERSHIP_ALIASES = {
"Alsace": "Alsace - Plaine Images",
"CHU - Centre O. Lambret": "CHU - Centre Oscar-Lambret",
"Canteleu": "Canteleu - Euratechnologies",
"Caulier": "Madeleine Caulier",
"Cité Scientifique": "Cité Scientifique - Professeur Gabillard",
"Lomme-Lambersart": "Lomme - Lambersart - Arthur-Notebart",
"Porte de Douai": "Porte de Douai - Jardin des Plantes",
"Quatre Cantons": "Quatre Cantons - Stade Pierre-Mauroy",
}
Comme pour la géographie, l'import refuse de deviner : un nom d'Ilévia sans station, ou une station sans chiffre, l'arrête en les nommant. Si Ilévia renomme une station, je le saurai au prochain import.
Ce que disent les chiffres
| Les plus fréquentées | Voyageurs par jour | Les moins fréquentées | Voyageurs par jour |
|---|---|---|---|
| Gare Lille-Flandres | 44 315 | Bourgogne | 992 |
| Porte des Postes | 13 702 | Mercure | 1 105 |
| République - Beaux-Arts | 12 294 | Carliers | 1 321 |
| Rihour | 10 214 | Mitterie | 1 484 |
| Porte de Douai - Jardin des Plantes | 9 878 | Wasquehal - Hôtel de Ville | 1 486 |
Gare Lille-Flandres écrase tout le reste : plus de trois fois la deuxième. Son chiffre est celui de la station entière, les deux lignes et la part du tramway comprises, car aucun portillon ne sait quelle rame le voyageur va prendre ; Ilévia estime cette part du tram à 10 %. Porte des Postes, l'autre station des deux lignes, est la deuxième. En bas du tableau, c'est la ligne 2 : 12 des 13 stations sous les 2 000 voyageurs par jour sont les siennes, dont 5 à Tourcoing, au bout de la ligne, et 4 à l'autre bout, côté Lomme et Lambersart. Square Flandres est la seule de la ligne 1. La station médiane reçoit environ 3 400 voyageurs par jour.
Deux seuils, dans des creux
Les critères de fréquentation de Lille sont plus de 8 000 voyageurs par jour (9 stations) et moins de 2 000 (13 stations). Chaque seuil tombe dans un creux de la répartition : la dernière station au-dessus de 8 000, Gambetta, en a 8 276, et la suivante, Villeneuve-d'Ascq - Hôtel de Ville, 7 769 ; sous 2 000, Pont de Neuville en a 1 914, et la suivante, Gare de Tourcoing, 2 179. Les stations les plus proches de chaque seuil en sont à 3 ou 4 % : une petite variation des comptages ne ferait pas changer une station de côté.
Les chiffres de Lille sont par jour, ceux de Paris par an : ils vivent dans deux champs séparés, et la valeur du critère nomme la ville (lille-8000), pour qu'aucune ligne de critère ne mélange les deux. La rareté des réponses, elle, ne lit que les chiffres annuels de Paris : à Lille, toutes les stations gardent le même poids, aux correspondances près.
09 Les critères qui en sortent
Un critère n'est jouable que s'il compte au moins 2 stations et au plus 70 % du réseau : au-delà, il ne départage plus rien. C'est le cas de la ligne 2, qui dessert 44 stations sur 60 : elle n'est pas un critère, ce serait un cadeau.
| Famille | Critères | Source |
|---|---|---|
| Réseau | Ligne 1, terminus, correspondance tramway, correspondance train | GTFS, SNCF |
| Lieu | Commune, station aérienne | API Découpage administratif, Wikipédia |
| Histoire | Ouverte avant 1984, 1989 ou 1999 ; depuis 1995, 1999 ou 2000 | Wikipédia |
| Histoire | Plus de 8 000 ou moins de 2 000 voyageurs par jour | Comptages d'Ilévia |
| Nom | Lettres, début et fin du nom, mots comme « Porte » ou « Mairie », longueur | Le nom lui-même |
Les critères sont partagés entre les villes en base : une ligne de critère est unique par type et par valeur. La correspondance train de Lille a la valeur vide, celle de Lyon lyon, celle de Toulouse toulouse, pour que chaque ville ait son propre texte.
10 Ce qui manque, et pourquoi
Plusieurs critères de Paris n'existent pas à Lille, faute de source :
- L'origine des noms, les lieux à proximité, les anecdotes : à Paris, ils viennent de listes établies station par station. Il n'en existe pas encore pour Lille.
- Le métro automatique. Tout le VAL est sans conducteur : le critère serait vrai partout, il ne départagerait rien.
Si tu connais une source ouverte qui comble un de ces trous, la page des idées de critères est faite pour ça.
11 Merci
Merci à Florent Berault, de la Métropole européenne de Lille, pour le fichier des fréquentations par station qu'il m'a transmis, devenu les critères de fréquentation de Lille.