Comment Extraire des Informations Depuis des Noms de Fichiers en Python ?

Published: 10 décembre 2025
DMCA.com Protection Status

Published: 10 décembre 2025

DMCA.com Protection Status

Introduction

Les noms de fichiers contiennent souvent bien plus qu’un simple libellé. Dans le domaine de l’informatique scientifique, que ce soit pour l’observation de la Terre (EO), les logs ou les pipelines automatisés, les noms de fichiers incluent fréquemment :: (1) Des horodatages (timestamps), (2) Des identifiants de produits ou de capteurs, (3) Des identifiants de plateforme ou de satellite, (4) Des niveaux de traitement, (5) Des versions, (6) Des codes de localisation ou identifiants uniques.

Table des matières

Python fournit un large ensemble d’outils pour cela :

  • Méthodes de base sur les chaînes (split, slicing, .removeprefix()…)
  • Utilitaires de chemin (os.path, pathlib)
  • Expressions régulières (re)
  • Le module datetime
  • Des parseurs entièrement personnalisés

Dans ce tutoriel, nous commençons par les bases puis nous arrivons à un exemple réel :
l’analyse des noms de fichiers GOES ABI Niveau 2, tels que :

1
OR_ABI-L2-FDCC-M6_G18_s20250090526174_e20250090528547_c20250090529107.nc

Extraire le nom de fichier et l’extension

La méthode la plus simple consiste à utiliser os.path :

1
2
3
4
5
6
7
8
9
import os

filename = "OR_ABI-L2-FDCC-M6_G18_s20250090526174_e20250090528547_c20250090529107.nc"

basename = os.path.basename(filename)
stem, ext = os.path.splitext(basename)

print(stem)  # nom du fichier sans extension
print(ext)   # .nc

Ou avec pathlib :

1
2
3
4
5
6
from pathlib import Path

file = Path(filename)
file.stem      # 'OR_ABI-L2-FDCC-M6_G18_s20250090526174_e20250090528547_c20250090529107'
file.suffix    # '.nc'
file.name      # nom complet

Supprimer des préfixes connus

Python 3.9+ introduit .removeprefix() :

1
2
clean = stem.removeprefix("OR_")
print(clean)

C’est plus propre que d’utiliser du slicing manuel ou replace().

Découper le nom de fichier en composants

Les noms de fichiers simples peuvent être analysés avec .split("_") :

1
2
parts = clean.split("_")
parts

Résultat :

1
['ABI-L2-FDCC-M6', 'G18', 's20250090526174', 'e20250090528547', 'c20250090529107']

Assigner des variables :

1
2
3
4
5
product = parts[0]
platform = parts[1]
start_code = parts[2]  # ex: 's20250090526174'
end_code = parts[3]
creation_code = parts[4]

Cela fonctionne très bien pour les formats stricts et prévisibles.

Convertir les dates encodées en objets Python datetime

Les timestamps GOES encodent :

1
YYYY + DDD + HHMM + SS + S

Où DDD est le jour de l'année.

D’abord, enlever l’identifiant (s, e, c) :

1
2
3
start_str = start_code[1:]
end_str = end_code[1:]
creation_str = creation_code[1:]

Puis convertir :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
from datetime import datetime

def parse_goes_timestamp(ts):
    year  = ts[0:4]
    doy   = ts[4:7]
    hour  = ts[7:9]
    minute= ts[9:11]
    second= ts[11:13]

    return datetime.strptime(
        f"{year}-{doy} {hour}:{minute}:{second}",
        "%Y-%j %H:%M:%S"
    )

start_dt = parse_goes_timestamp(start_str)
end_dt = parse_goes_timestamp(end_str)
creation_dt = parse_goes_timestamp(creation_str)

Quand les méthodes simples sur les chaînes ne suffisent pas

split() et le slicing fonctionnent lorsque :

  • Le format est fixe
  • Tout est séparé par des délimiteurs connus
  • Aucun champ optionnel, aucune longueur variable

Mais que faire si :

  • Certaines parties ont une longueur variable ?
  • Certains champs sont optionnels ?
  • Vous souhaitez valider les noms de fichiers ?
  • Vous voulez une méthode plus généralisable ?

C’est là que les expressions régulières (re) deviennent idéales.

Extraire des informations avec les expressions régulières (re)

Les expressions régulières permettent de définir un modèle décrivant la structure du nom de fichier.

Le module re de Python prend en charge :

  • Les groupes nommés
  • Les champs optionnels
  • La validation
  • La capture de multiples séquences numériques

Exemple : extraire la plateforme, le produit, les timestamps

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import re

filename = "OR_ABI-L2-FDCC-M6_G18_s20250090526174_e20250090528547_c20250090529107.nc"

pattern = (
    r"OR_(?P<product>[^_]+)_"       # ABI-L2-FDCC-M6
    r"(?P<platform>G\d+)_"          # G18
    r"s(?P<start>\d{15})_"          # sYYYYDDDHhmmssS
    r"e(?P<end>\d{15})_"
    r"c(?P<creation>\d{15})"
)

match = re.match(pattern, Path(filename).stem)
match.groupdict()

Sortie :

1
2
3
4
5
6
7
{
 'product': 'ABI-L2-FDCC-M6',
 'platform': 'G18',
 'start': '20250090526174',
 'end': '20250090528547',
 'creation': '20250090529107'
}

Extraire uniquement les nombres

1
re.findall(r"\d+", filename)

Champs optionnels

1
pattern = r"(?P<product>.+?)_(?P<platform>G\d+)(_v(?P<version>\d+))?"

Cela correspond à des fichiers avec ou sans suffixe _vXX.

Exemple complet : analyser un nom de fichier GOES

Voici une fonction complète qui :

  • Extrait les informations du fichier
  • Supprime les préfixes
  • Utilise regex pour la validation
  • Convertit les timestamps en datetime
  • Retourne un dictionnaire structuré

Exemple

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import re
from datetime import datetime
from pathlib import Path

def parse_goes_filename(fname):
    file = Path(fname)
    stem = file.stem.removeprefix("OR_")

    pattern = (
        r"(?P<product>[^_]+)_"
        r"(?P<platform>G\d+)_"
        r"s(?P<start>\d{15})_"
        r"e(?P<end>\d{15})_"
        r"c(?P<creation>\d{15})"
    )

    match = re.match(pattern, stem)
    if not match:
        raise ValueError("Format de nom de fichier GOES invalide")

    info = match.groupdict()

    def parse_ts(ts):
        return datetime.strptime(
            f"{ts[0:4]}-{ts[4:7]} {ts[7:9]}:{ts[9:11]}:{ts[11:13]}",
            "%Y-%j %H:%M:%S"
        )

    return {
        "product": info["product"],
        "platform": info["platform"],
        "start_time": parse_ts(info["start"]),
        "end_time": parse_ts(info["end"]),
        "creation_time": parse_ts(info["creation"]),
        "extension": file.suffix,
        "filename_no_ext": stem,
        "filename_full": file.name
    }

Utilisation du parseur

1
2
3
4
5
6
info = parse_goes_filename(
    "OR_ABI-L2-FDCC-M6_G18_s20250090526174_e20250090528547_c20250090529107.nc"
)

for k, v in info.items():
    print(k, ":", v)

Quel outil utiliser selon le cas ?

Tâche Outils recommandés
Extraire extension, nom, racine pathlib, os.path
Supprimer préfixes/suffixes fixes .removeprefix(), .removesuffix()
Découper les structures prévisibles .split("_")
Extraire texte ou nombres à longueur variable slicing ou regex
Valider le format d’un nom de fichier re.match()
Extraire plusieurs champs timestamp regex + datetime
Construire des parseurs généraux regex + fonctions utilitaires

Références

Liens Site
https://docs.python.org/3/library/pathlib.html Documentation Python — module pathlib
https://docs.python.org/3/library/os.path.html Documentation Python — utilitaires os.path
https://docs.python.org/3/library/stdtypes.html#string-methods Documentation Python — Méthodes de chaîne
https://docs.python.org/3/library/re.html Documentation Python — Expressions régulières (re)
https://docs.python.org/3/library/datetime.html Documentation Python — Parsing datetime
https://docs.python.org/3/library/time.html Documentation Python — Module time
https://regex101.com/ Outil de test regex (non officiel mais très utilisé)
Creative Commons License

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.

Author profile-image

Benjamin

Développeur à mes heures perdues, je m’intéresse à la télédétection terrestre et à la détection des incendies par satellite. Passionné par Python, le machine learning et la science ouverte.

Skills
  • Remote sensing
  • Python
  • Machine Learning
  • Tensorflow 2.0