Module os de Python : Guide des Opérations sur les Fichiers et Répertoires

Name

Soren Atelier

Updated on 10/02/2026

Chaque script Python qui lit un fichier de configuration, enregistre des résultats, organise des données ou automatise un déploiement doit interagir avec le système de fichiers. Mais les chemins de fichiers se comportent différemment sous Windows, macOS et Linux. Un chemin codé en dur comme /home/user/data ne fonctionne pas sous Windows. Concaténer manuellement des chaînes avec + et / entraîne des bugs de double barre oblique et des séparateurs manquants. Et sans vérifications appropriées, votre script pourrait supprimer le mauvais fichier ou planter lorsqu'un répertoire existe déjà.

Le module os de Python résout ces problèmes. Il fournit une interface portable et multiplateforme pour travailler avec le système d'exploitation -- créer des répertoires, lister des fichiers, lire des variables d'environnement, manipuler des chemins et parcourir des arborescences de répertoires. Il est livré avec chaque installation Python, ne nécessite pas de pip install et gère automatiquement les différences entre plateformes.

Ce guide couvre chaque fonction essentielle du module os, organisée par cas d'utilisation, avec des exemples pratiques que vous pouvez copier directement dans vos projets.

Obtenir le Répertoire de Travail Actuel

Avant de faire quoi que ce soit avec les fichiers, vous devez savoir où votre script s'exécute. os.getcwd() retourne le répertoire de travail actuel sous forme de chemin absolu.

import os
 
# Obtenir le répertoire de travail actuel
cwd = os.getcwd()
print(cwd)  # e.g., /home/user/projects/myapp
 
# Changer de répertoire de travail
os.chdir('/tmp')
print(os.getcwd())  # /tmp
 
# Revenir en arrière
os.chdir(cwd)

Utilisez os.getcwd() lorsque vous construisez des chemins relatifs ou lorsque vous devez restaurer le répertoire de travail après l'avoir temporairement changé.

Opérations sur les Répertoires

Créer des Répertoires

os.mkdir() crée un seul répertoire. Il lève une FileExistsError si le répertoire existe déjà et une FileNotFoundError si le répertoire parent n'existe pas.

import os
 
# Créer un seul répertoire
os.mkdir('output')
 
# Créer seulement s'il n'existe pas
if not os.path.exists('output'):
    os.mkdir('output')

os.makedirs() crée des répertoires de manière récursive -- y compris tous les répertoires parents manquants. Le paramètre exist_ok=True empêche les erreurs lorsque le répertoire existe déjà.

import os
 
# Créer des répertoires imbriqués en un seul appel
os.makedirs('data/raw/2026/january', exist_ok=True)
 
# Sans exist_ok, cela lève FileExistsError si 'data' existe déjà
# os.makedirs('data/raw/2026/january')  # peut lever une erreur

Lister le Contenu des Répertoires

os.listdir() retourne une liste de toutes les entrées (fichiers et répertoires) dans un chemin donné.

import os
 
# Lister tout dans le répertoire actuel
entries = os.listdir('.')
print(entries)  # ['main.py', 'data', 'output', 'README.md']
 
# Lister le contenu d'un répertoire spécifique
data_files = os.listdir('/var/log')
print(data_files)

os.scandir() est une alternative plus efficace qui retourne des objets DirEntry avec des attributs de fichiers mis en cache. Utilisez-le lorsque vous avez besoin de métadonnées de fichiers en plus des noms.

import os
 
with os.scandir('.') as entries:
    for entry in entries:
        info = entry.stat()
        print(f"{entry.name:30s}  {'DIR' if entry.is_dir() else 'FILE':4s}  {info.st_size} bytes")

Supprimer des Répertoires

os.rmdir() supprime un répertoire vide. Pour les répertoires non vides, utilisez shutil.rmtree() à la place.

import os
import shutil
 
# Supprimer un répertoire vide
os.rmdir('output')
 
# Supprimer un répertoire et tout son contenu (à utiliser avec précaution)
shutil.rmtree('data/raw/2026')

Opérations sur les Fichiers

Supprimer des Fichiers

os.remove() (ou son alias os.unlink()) supprime un seul fichier. Il lève une FileNotFoundError si le fichier n'existe pas.

import os
 
# Supprimer un fichier
os.remove('temp_output.csv')
 
# Suppression sécurisée avec vérification d'existence
filepath = 'temp_output.csv'
if os.path.exists(filepath):
    os.remove(filepath)
    print(f"Supprimé {filepath}")
else:
    print(f"{filepath} non trouvé")

Renommer et Déplacer des Fichiers

os.rename() renomme ou déplace un fichier ou répertoire. Si la destination existe déjà, le comportement dépend de la plateforme -- il peut écraser sous Unix mais lever une erreur sous Windows. Utilisez os.replace() pour un remplacement atomique garanti.

import os
 
# Renommer un fichier
os.rename('old_report.csv', 'new_report.csv')
 
# Déplacer un fichier vers un autre répertoire
os.rename('report.csv', 'archive/report_2026.csv')
 
# Remplacement atomique (écrase la destination sur toutes les plateformes)
os.replace('new_data.csv', 'data.csv')

Obtenir les Informations d'un Fichier

os.stat() retourne des métadonnées détaillées du fichier incluant la taille, les permissions et les horodatages.

import os
from datetime import datetime
 
info = os.stat('data.csv')
print(f"Taille : {info.st_size} bytes")
print(f"Modifié : {datetime.fromtimestamp(info.st_mtime)}")
print(f"Créé : {datetime.fromtimestamp(info.st_ctime)}")
print(f"Permissions : {oct(info.st_mode)}")

Opérations sur les Chemins avec os.path

Le sous-module os.path est l'endroit où se déroule la majorité du travail quotidien avec le système de fichiers. Il gère la construction, la validation et la décomposition des chemins de manière multiplateforme.

Construire des Chemins en Toute Sécurité

Ne concaténez jamais les chemins avec +. Utilisez os.path.join() pour construire des chemins correctement quel que soit le système d'exploitation.

import os
 
# Correct : os.path.join gère les séparateurs
path = os.path.join('data', 'raw', 'sales.csv')
print(path)  # 'data/raw/sales.csv' sous Unix, 'data\\raw\\sales.csv' sous Windows
 
# Incorrect : la concaténation de chaînes peut échouer
bad_path = 'data' + '/' + 'raw' + '/' + 'sales.csv'  # échoue sous Windows

Vérifier l'Existence et le Type

import os
 
# Vérifier si un chemin existe (fichier ou répertoire)
print(os.path.exists('/etc/hosts'))      # True (sous Linux/macOS)
 
# Vérifier spécifiquement un fichier
print(os.path.isfile('main.py'))         # True
print(os.path.isfile('data'))            # False (c'est un répertoire)
 
# Vérifier spécifiquement un répertoire
print(os.path.isdir('data'))             # True
print(os.path.isdir('main.py'))          # False

Décomposer les Chemins

Extrayez les composants d'un chemin de fichier sans découpage manuel de chaînes.

import os
 
filepath = '/home/user/projects/report_final.csv'
 
# Obtenir le nom du fichier
print(os.path.basename(filepath))    # 'report_final.csv'
 
# Obtenir le répertoire
print(os.path.dirname(filepath))     # '/home/user/projects'
 
# Séparer en répertoire et nom de fichier
directory, filename = os.path.split(filepath)
print(directory)   # '/home/user/projects'
print(filename)    # 'report_final.csv'
 
# Séparer le nom de fichier et l'extension
name, ext = os.path.splitext(filepath)
print(name)  # '/home/user/projects/report_final'
print(ext)   # '.csv'
 
# Obtenir le chemin absolu à partir d'un chemin relatif
print(os.path.abspath('data.csv'))   # '/home/user/projects/data.csv'
 
# Résoudre le répertoire personnel de l'utilisateur
print(os.path.expanduser('~/Documents'))  # '/home/user/Documents'

Référence Rapide des Opérations sur les Chemins

Variables d'Environnement

Le module os fournit un accès direct aux variables d'environnement du système -- essentiel pour lire la configuration, les clés API et les paramètres de déploiement.

import os
 
# Lire une variable d'environnement (retourne None si non définie)
db_host = os.getenv('DATABASE_HOST')
print(db_host)
 
# Lire avec une valeur par défaut
db_port = os.getenv('DATABASE_PORT', '5432')
print(db_port)  # '5432' si DATABASE_PORT n'est pas défini
 
# Accès via le dictionnaire os.environ (lève KeyError si absente)
try:
    secret = os.environ['API_SECRET']
except KeyError:
    print("API_SECRET non configuré")
 
# Définir une variable d'environnement (pour les processus enfants)
os.environ['APP_MODE'] = 'production'
 
# Lister toutes les variables d'environnement
for key, value in os.environ.items():
    print(f"{key}={value}")

La différence entre os.getenv() et os.environ[] est importante : getenv retourne None (ou une valeur par défaut) lorsque la variable est absente, tandis que os.environ[] lève une KeyError. Utilisez getenv pour la configuration optionnelle et os.environ pour les paramètres requis qui doivent échouer bruyamment en leur absence.

Parcourir les Arborescences de Répertoires avec os.walk

os.walk() parcourt récursivement une arborescence de répertoires, générant un triplet (dirpath, dirnames, filenames) pour chaque répertoire visité.

import os
 
# Parcourir un répertoire de projet
for dirpath, dirnames, filenames in os.walk('/home/user/project'):
    # Ignorer les répertoires cachés
    dirnames[:] = [d for d in dirnames if not d.startswith('.')]
 
    print(f"\nRépertoire : {dirpath}")
    print(f"  Sous-répertoires : {dirnames}")
    print(f"  Fichiers : {filenames}")

La modification en place de dirnames[:] contrôle dans quels sous-répertoires os.walk entre. C'est un motif puissant pour ignorer les répertoires .git, __pycache__ ou node_modules.

Calculer la Taille Totale d'un Répertoire

import os
 
def get_directory_size(path):
    total = 0
    for dirpath, dirnames, filenames in os.walk(path):
        for filename in filenames:
            filepath = os.path.join(dirpath, filename)
            # Ignorer les liens symboliques
            if not os.path.islink(filepath):
                total += os.path.getsize(filepath)
    return total
 
size_bytes = get_directory_size('/home/user/project')
size_mb = size_bytes / (1024 * 1024)
print(f"Taille totale : {size_mb:.2f} MB")

Motifs Courants

Trouver Tous les Fichiers par Extension

import os
 
def find_files(directory, extension):
    """Trouver récursivement tous les fichiers avec une extension donnée."""
    matches = []
    for dirpath, dirnames, filenames in os.walk(directory):
        for filename in filenames:
            if filename.endswith(extension):
                matches.append(os.path.join(dirpath, filename))
    return matches
 
# Trouver tous les fichiers Python
python_files = find_files('/home/user/project', '.py')
for f in python_files:
    print(f)
 
# Trouver tous les fichiers de données CSV
csv_files = find_files('data', '.csv')
print(f"{len(csv_files)} fichiers CSV trouvés")

Créer une Structure de Sortie Imbriquée

import os
 
def setup_project_dirs(base_path):
    """Créer une structure de répertoires de projet standard."""
    dirs = [
        'data/raw',
        'data/processed',
        'data/output',
        'logs',
        'config',
        'reports/figures',
    ]
    for d in dirs:
        full_path = os.path.join(base_path, d)
        os.makedirs(full_path, exist_ok=True)
        print(f"Créé : {full_path}")
 
setup_project_dirs('my_project')

Opérations Sécurisées avec des Fichiers Temporaires

import os
import tempfile
 
# Créer un fichier temporaire qui s'auto-supprime
with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp:
    tmp.write('col1,col2\n1,2\n3,4\n')
    tmp_path = tmp.name
 
print(f"Fichier temporaire : {tmp_path}")
print(f"Existe : {os.path.exists(tmp_path)}")
 
# Nettoyage
os.remove(tmp_path)

os.path vs pathlib : Lequel Utiliser ?

Python 3.4 a introduit pathlib comme alternative orientée objet à os.path. Les deux fonctionnent, mais ils ont des forces différentes.

Quand utiliser os.path : Bases de code existantes, scripts devant supporter Python 2, ou lorsque vous travaillez avec des bibliothèques qui n'acceptent que des chemins sous forme de chaînes.

Quand utiliser pathlib : Nouveaux projets, lorsque vous souhaitez une syntaxe plus propre, ou lorsque vous enchaînez plusieurs opérations sur les chemins.

# Approche os.path
import os
config_path = os.path.join(os.path.expanduser('~'), '.config', 'myapp', 'settings.json')
if os.path.isfile(config_path):
    with open(config_path) as f:
        data = f.read()
 
# Approche pathlib
from pathlib import Path
config_path = Path.home() / '.config' / 'myapp' / 'settings.json'
if config_path.is_file():
    data = config_path.read_text()

Les deux approches sont valides. Le module os n'est pas obsolète et reste le standard pour les opérations au niveau des processus, les variables d'environnement et les appels système de bas niveau. pathlib offre simplement une API plus ergonomique pour la manipulation des chemins.

Considérations Multiplateformes

Le module os s'adapte automatiquement au système d'exploitation actuel, mais il y a des détails qu'il vaut la peine de connaître.

import os
 
# os.sep est le séparateur de chemin de la plateforme
print(os.sep)       # '/' sous Unix, '\\' sous Windows
 
# os.linesep est la fin de ligne de la plateforme
print(repr(os.linesep))  # '\n' sous Unix, '\r\n' sous Windows
 
# os.name identifie la famille du système d'exploitation
print(os.name)      # 'posix' sous Linux/macOS, 'nt' sous Windows
 
# os.path.join gère les séparateurs automatiquement
path = os.path.join('data', 'output', 'results.csv')
# 'data/output/results.csv' sous Unix
# 'data\\output\\results.csv' sous Windows

Règles clés pour les scripts multiplateformes :

• Utilisez toujours os.path.join() au lieu de la concaténation de chaînes avec / ou \\.
• Utilisez os.path.expanduser('~') au lieu de coder en dur /home/username.
• Utilisez os.linesep ou ouvrez les fichiers en mode texte (qui gère les fins de ligne) au lieu de coder en dur \n.
• Testez votre logique de chemins sur les deux plateformes si votre script sera partagé.

Automatiser les Tâches du Système de Fichiers avec RunCell

Lorsque vous travaillez avec des opérations du système de fichiers dans des notebooks Jupyter -- organiser des jeux de données, configurer des structures de projet ou auditer des arborescences de fichiers -- RunCell (opens in a new tab) ajoute une couche d'agent IA au-dessus de votre environnement de notebook. Vous pouvez décrire ce que vous voulez ("trouve tous les fichiers CSV de plus de 100 Mo dans cette arborescence et liste-les par taille") et RunCell génère et exécute le code du module os pour vous, rendant les tâches répétitives de gestion de fichiers plus rapides.

FAQ

Qu'est-ce que le module os en Python ?

Le module os fait partie de la bibliothèque standard de Python. Il fournit des fonctions pour interagir avec le système d'exploitation, y compris la manipulation de fichiers et répertoires, la gestion des chemins, l'accès aux variables d'environnement et la gestion des processus. Vous l'importez avec import os -- aucune installation nécessaire.

Quelle est la différence entre os.path.join et la concaténation de chaînes pour les chemins ?

os.path.join() utilise automatiquement le bon séparateur de chemin pour le système d'exploitation actuel (/ sous Unix, \ sous Windows). La concaténation de chaînes avec + nécessite l'insertion manuelle de séparateurs, ce qui entraîne des bugs lorsque le code s'exécute sur une plateforme différente. Utilisez toujours os.path.join().

Comment lister récursivement tous les fichiers d'un répertoire ?

Utilisez os.walk() pour parcourir une arborescence de répertoires. Il génère des triplets (dirpath, dirnames, filenames) pour chaque répertoire. Combinez-le avec os.path.join(dirpath, filename) pour construire les chemins complets de chaque fichier.

Dois-je utiliser os.path ou pathlib ?

Pour les nouveaux projets Python 3, pathlib offre une syntaxe plus propre et plus lisible avec son API orientée objet. Cependant, os et os.path ne sont pas obsolètes et restent le bon choix pour les variables d'environnement (os.environ), les opérations sur les processus et les bases de code existantes. De nombreux projets utilisent les deux.

Comment supprimer un fichier ou un répertoire en toute sécurité en Python ?

Utilisez os.remove(path) pour supprimer un fichier et os.rmdir(path) pour supprimer un répertoire vide. Vérifiez toujours d'abord avec os.path.exists(path) ou encapsulez l'appel dans un bloc try/except pour gérer FileNotFoundError. Pour les répertoires non vides, utilisez shutil.rmtree(path).

Conclusion

Le module os de Python est la base de chaque opération du système de fichiers que vos scripts effectueront. os.path.join() construit des chemins en toute sécurité entre les plateformes. os.makedirs() crée des répertoires imbriqués en un seul appel. os.walk() parcourt des arborescences de répertoires entières. os.environ et os.getenv() gèrent la configuration sans coder en dur les secrets. Et os.stat() vous fournit des métadonnées détaillées sur les fichiers.

Pour du code utilisant beaucoup de chemins, envisagez de combiner os avec pathlib pour une syntaxe plus propre. Mais le module os reste essentiel -- c'est la manière standard d'interagir avec le système d'exploitation en Python, et chaque développeur Python devrait connaître ses fonctions principales.