Comment vérifier la taille des fichiers et des dossiers en Python ?

Dans cet article, nous allons explorer comment déterminer la taille d’un fichier ou d’un répertoire en utilisant Python.

Python est reconnu pour sa polyvalence en tant que langage de programmation. Il permet de concevoir des applications variées, allant de simples outils en ligne de commande à des plateformes web complexes.

Une fonction souvent négligée de Python est sa capacité à interagir avec le système d’exploitation. Cette interaction peut s’avérer très utile pour automatiser des tâches et gagner du temps.

Découvrons comment Python communique avec le système d’exploitation.

Comment Python dialogue-t-il avec le système d’exploitation ?

Aucun programme n’existe isolément. Pour Python, l’interaction avec le système d’exploitation est parfois essentielle pour mener à bien certaines actions.

Python propose divers modules qui facilitent cette interaction, notamment os, sys, pathlib et subprocess.

Ces modules étant intégrés, il n’est pas nécessaire de les installer via pip. On peut les importer directement comme suit :

import os
import sys
import pathlib
import subprocess

Voici un aperçu des principales fonctions de chacun de ces modules:

• os : Permet d’accéder aux fonctionnalités du système de manière portable, en tenant compte du système d’exploitation utilisé. C’est le choix habituel, sauf si vous avez besoin de fonctionnalités très spécifiques.
• sys : Offre des paramètres et fonctions propres au système. Il permet d’accéder aux variables et fonctions de l’interpréteur Python lui-même. Alors que os communique avec le système d’exploitation, sys interagit avec l’interpréteur.
• pathlib : Permet une manipulation avancée des chemins de fichiers, en les représentant sous forme d’objets avec une sémantique adaptée à chaque système d’exploitation.
• subprocess : Gère l’exécution de sous-processus directement depuis Python, permettant l’accès aux flux stdin, stdout et aux codes de retour. Pour plus d’informations, consultez notre guide sur les sous-processus en Python.

Il existe des bibliothèques de plus haut niveau, offrant des fonctionnalités encore plus spécifiques selon les besoins. Cependant, ces modules sont généralement suffisants.

Note: Les fonctions de ces modules peuvent avoir des comportements différents selon le système d’exploitation. En général, l’environnement UNIX est celui qui s’aligne le mieux avec le fonctionnement de Python.

Maintenant que nous comprenons comment Python communique avec le système d’exploitation, abordons les méthodes pour déterminer la taille des fichiers et des répertoires. Toutes les solutions mentionnées sont disponibles sur le dépôt GitHub File and folder size in Python.

Utilisation de os.stat().st_size

Cette méthode utilise la fonction stat() du module os, qui fournit de nombreuses informations sur un chemin donné.

Note: La fonction os.path.getsize() remplit également cette fonction. Cependant, os.stat().st_size présente l’avantage de ne pas suivre les liens symboliques.

Avant de commencer, créons un fichier de test nommé lorem.txt dans lequel nous allons copier du texte de remplissage. Vous pouvez en générer facilement à l’aide d’un générateur de texte Lorem Ipsum.

Dans le même répertoire, créez un fichier method1.py et copiez le code suivant :

import os
size = os.stat('lorem.txt').st_size
print(size)

Voici ce que fait ce code:

• La première ligne importe le module os.
• La variable size stocke la taille du fichier lorem.txt.
  • La fonction os.stat() retourne diverses informations sur le fichier.
  • L’attribut st_size représente la taille du fichier en octets.
• On affiche la valeur de la variable size.

Exécutez le script Python. Le résultat variera en fonction du contenu de votre fichier lorem.txt.

Exemple de résultat :

20064

La taille est exprimée en octets, ce qui n’est pas très lisible. Rendons le résultat plus intelligible.

Pour cela, installez le paquet humanize en utilisant la commande suivante dans votre terminal :

pip install humanize

La fonction naturalsize() du module humanize convertit une valeur en octets en une taille lisible, comme Ko, Mo, Go ou To.

import os
from humanize import naturalsize

size = os.stat('lorem.txt').st_size

print(size)
print(naturalsize(size))

Ce code affiche la taille du fichier en octets, puis dans un format plus lisible.

Exemple de résultat :

20064
20.1 kB

Utilisation de Pathlib

Bien que pathlib soit conçu pour la gestion des chemins, il intègre des fonctions d’autres modules, accessibles par les méthodes d’objets Path (les instances de la classe Path).

Créez un fichier method2.py et importez la classe Path.

from pathlib import Path

Créez ensuite un objet Path en passant le chemin vers le fichier lorem.txt en argument.

file_ = Path('lorem.txt')

Vous pouvez maintenant utiliser la méthode stat() de la classe Path, qui fonctionne de manière similaire à la fonction os.stat() et permet d’afficher la taille du fichier.

print(file_.stat().st_size)

Exemple de résultat :

20064

Comme vous pouvez le constater, nous avons obtenu le même résultat qu’avec la méthode précédente. La taille est toujours exprimée en octets, mais nous pouvons utiliser le module humanize pour l’afficher dans un format plus lisible.

from pathlib import Path
from humanize import naturalsize

size = Path('lorem.txt').stat().st_size

print(naturalsize(size))

Ce code produit l’affichage suivant :

20.1 kB

Utilisation des commandes Unix avec Subprocess

Le module subprocess permet d’exécuter et de gérer des sous-processus directement depuis Python. Ainsi, nous pouvons exécuter n’importe quelle commande et manipuler le résultat en Python.

Note: Cette méthode fonctionne uniquement sous un système d’exploitation de type UNIX (Linux, macOS).

Ouvrez un fichier method3.py et collez le code suivant :

from subprocess import run

process = run(['du', 'lorem.txt'], capture_output=True, text=True)

print(process.stdout)

Analysons ce code :

• Nous importons la fonction run du module subprocess.
• La variable process stocke le résultat de l’exécution de la commande du lorem.txt.
  • du est un utilitaire Linux permettant d’obtenir l’espace disque utilisé par un fichier.
  • capture_output=True permet d’accéder à l’attribut stdout (sortie standard).
  • text=True indique que la sortie doit être stockée sous forme de chaîne de caractères, et non d’octets.
• On affiche la sortie standard du processus.

Si vous exécutez ce code, vous obtiendrez un résultat similaire à celui-ci :

20      lorem.txt

On obtient la taille du fichier et son nom. Pour n’afficher que la taille, il faut extraire la première partie de la chaîne (en utilisant split()).

from subprocess import run

process = run(['du', 'lorem.txt'], capture_output=True, text=True)

size = process.stdout.split()[0]

print(size)

Résultat :

20

Cette sortie n’est pas très lisible. On peut deviner qu’il s’agit de Ko (puisque nous avons vu cela avec les méthodes précédentes), mais ce n’est pas intuitif.

Pour améliorer la lisibilité, nous pouvons utiliser l’option -h (human-readable) de la commande du.

Note : Pour obtenir un manuel de la commande du, utilisez man du ou du --help dans votre terminal.

from subprocess import run

process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True)

size = process.stdout.split()[0]

print(size)

L’affichage devient alors plus clair :

20K

Pour en savoir plus sur le module subprocess, vous pouvez consulter notre guide dédié.

Obtenir la taille d’un dossier de manière récursive

Pour connaître la taille d’un dossier, il faut parcourir récursivement chaque fichier et sous-dossier qu’il contient. Nous allons aborder cela avec deux méthodes :

• Parcourir le chemin avec pathlib.
• Utiliser la commande du avec subprocess.

Le code suivant utilisera un chemin vers un répertoire de test dans mon dossier personnel. Remplacez-le par le chemin du répertoire que vous voulez analyser.

Parcourir le chemin avec pathlib

Découvrons comment obtenir la taille d’un répertoire en parcourant chaque fichier qu’il contient.

from pathlib import Path
from humanize import naturalsize

def get_size(path="."):
    size = 0

    for file_ in Path(path).rglob('*'):

        size += file_.stat().st_size
    
    return naturalsize(size)

test_path = Path.home() / 'Documents/tests/'

print(get_size(test_path))

Ce code peut paraître complexe, décortiquons-le :

• Importation de la classe Path et de la fonction naturalsize().
• Définition de la fonction get_size() qui prend en argument un chemin (par défaut, le répertoire courant).
• La variable size sert à accumuler la taille de chaque fichier.
• Parcours de tous les fichiers et sous-dossiers dans le chemin.
• Ajout de la taille de chaque fichier à la variable size.
• Retour de la taille totale dans un format lisible.

Je teste cette fonction avec un répertoire spécifique de ma machine. Pensez à remplacer ce chemin par un dossier qui existe sur votre ordinateur.

Dans mon cas, voici le résultat obtenu :

403.4 MB

Utilisation de la commande du avec subprocess

Cette approche présente certains avantages :

• Le résultat est généralement plus précis.
• Le calcul est plus rapide.

from subprocess import run
from pathlib import Path

test_path = Path.home() / 'Documents/tests/'

process = run(['du', '-sh', test_path], capture_output=True, text=True)

size = process.stdout.split()[0]

print(size)

Nous utilisons la même approche que pour la méthode 3, mais cette fois avec le chemin d’un répertoire.

Résultat :

481M

Comme vous pouvez le constater, les deux méthodes donnent des résultats légèrement différents. La différence tend à augmenter avec la taille du répertoire.

Le choix entre pathlib et subprocess dépend de votre contexte. Si vous travaillez toujours sous Linux, l’utilisation de subprocess peut être une solution efficace, sinon, privilégiez pathlib.

Pour résumer

Python s’avère extrêmement utile pour interagir avec le système d’exploitation. Vous pouvez automatiser de nombreux processus et gagner du temps grâce à ses fonctionnalités. Les principaux modules à utiliser pour cela sont os, sys, pathlib et subprocess.

Dans ce tutoriel, nous avons appris :

• Comment Python interagit avec le système d’exploitation.
• Comment utiliser les modules intégrés pour effectuer des opérations sur le système d’exploitation.
• Comment utiliser le module humanize pour afficher les tailles dans un format lisible.
• Trois méthodes différentes pour déterminer la taille d’un fichier.
• Comment calculer récursivement la taille d’un répertoire ou en utilisant la commande du.