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

Dans cet article, vous apprendrez à vérifier la taille d'un fichier ou d'un dossier en Python

Python est l'un des langages de programmation les plus polyvalents. Avec lui, vous pourrez passer d'un petit programme CLI (interface de ligne de commande) à une application Web complexe.

Cependant, l'une de ses caractéristiques les plus sous-estimées est la capacité d'interagir avec les systèmes d'exploitation. La gestion des opérations du système d'exploitation avec Python peut vous faire gagner beaucoup de temps lors de la création de processus d'automatisation.

Voyons comment Python interagit avec le système d'exploitation.

Comment Python interagit avec le système d'exploitation ?

Personne ne peut vivre isolé de son environnement. Cela s'applique également à Python, où il est parfois fondamental d'interagir avec le système d'exploitation pour faire avancer les choses.

Python a plusieurs modules qui nous permettent d'interagir avec le système d'exploitation. Les plus utilisés sont os, sys, pathlib et subprocess.

Comme ce sont des modules intégrés, vous n'aurez pas besoin de les installer avec PIP. Vous pouvez tous les importer avec l'instruction suivante :

 import os import sys import pathlib import subprocess

La liste ci-dessous indique la fonctionnalité principale de chacune de ces importations :

• Os : manière portable d'utiliser les fonctionnalités spécifiques au système (en fonction de votre système d'exploitation). C'est le bon choix dans la plupart des cas, sauf si vous avez besoin de quelque chose de plus avancé
• Sys : Paramètres et fonctions spécifiques au système. Ce module donne accès aux variables et fonctions de l'interpréteur. Le module os interagit avec le système d'exploitation et sys interagit avec l'interpréteur Python
• Pathlib : utilisation avancée des chemins. Vous permet de représenter les systèmes de fichiers sous forme d'objets, avec la sémantique pertinente pour chaque système d'exploitation.
• Sous -processus : Exécution et gestion des sous-processus directement depuis Python. Cela implique de travailler avec les codes stdin , stdout et retour . Vous pouvez en savoir plus à ce sujet en lisant notre guide des sous-processus Python.

Il existe des bibliothèques de haut niveau qui incluent des fonctionnalités encore plus spécifiques en fonction de vos besoins. Cependant, la plupart du temps, vous êtes prêt à utiliser les modules ci-dessus.

Remarque : la plupart des fonctions fournies par ces modules auront une sortie différente selon votre système d'exploitation. N'oubliez pas qu'habituellement, la meilleure correspondance est UNIX et Python.

Maintenant que vous comprenez rapidement comment Python interagit avec le système d'exploitation, passons aux méthodes de vérification de la taille des fichiers et des dossiers. Toutes les solutions suivantes sont disponibles dans la taille du fichier et du dossier dans le référentiel Python GitHub

Utilisation de os.stat().st_size

Dans cette méthode, nous allons utiliser la fonction stat() du module os. Il renvoie de nombreuses informations sur un chemin spécifique.

Remarque : La fonction os.path.getsize() effectue également le travail. L'avantage d'utiliser os.stat(). st_size est qu'il ne suit pas les simlinks.

Avant de continuer, créons un fichier de test nommé lorem.txt , dans lequel nous allons coller du texte stupide . Nous pouvons visiter un générateur de texte Lorem Ipsum et coller le texte dans le fichier lorem.txt .

Dans le même répertoire, créez un fichier avec le nom method1.py et collez le code ci-dessous :

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

Décomposons ce que nous faisons avec ce code :

• Dans la première ligne, nous importons le module os
• La variable size contient la taille du fichier lorem.txt
  • La fonction os.stat() renvoie un tas d'informations liées au fichier
  • L'attribut st_size représente la taille du fichier
• Nous imprimons la variable de taille

Essayez d'exécuter le script Python. Vous obtiendrez un résultat différent selon le contenu de votre fichier lorem.txt .

Sortir:

 20064

La sortie est représentée en octets. Ce n'est pas du tout lisible, donc humanisons-le pour avoir une meilleure idée de la taille du fichier.

Tout d'abord, installez le package humanize, en exécutant la commande suivante dans votre shell :

 pip install humanize

Ensuite, vous pouvez utiliser la fonction naturalsize() qui convertit une valeur en octets en taille de fichier lisible, par exemple, Ko, Mo, Go ou To.

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

Dans un premier temps, le code ci-dessus imprime la taille du fichier en octets puis imprime le résultat dans une taille lisible.

Sortir:

 20064 20.1 kB

Utiliser Pathlib

Bien que pathlib soit conçu pour fonctionner exclusivement avec des chemins, il incorpore certaines fonctions utiles d'autres modules en tant que méthodes d'objets Path (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 du fichier lorem.txt en argument.

 file_ = Path('lorem.txt')

Maintenant, vous pouvez accéder à la méthode stat() de la classe Path. Cela fonctionne de la même manière que la fonction os.stat() , vous pourrez donc imprimer la taille du fichier.

 print(file_.stat().st_size)

Sortir:

 20064

Comme vous pouvez le voir, nous avons obtenu le même résultat qu'avec la première méthode que nous avons utilisée. Le résultat ci-dessus est également imprimé au format octet, nous pouvons donc utiliser le module humanize pour le rendre lisible.

 from pathlib import Path from humanize import naturalsize size = Path('lorem.txt').stat().st_size print(naturalsize(size))

Ce code produit la sortie suivante :

 20.1 kB

Utilisation des commandes Unix avec Subprocess :

Le module subprocess nous permet d'appeler et de gérer des sous-processus depuis Python. Par conséquent, nous pouvons exécuter n'importe quelle commande et traiter sa sortie directement en Python.

Remarque : Cette méthode ne fonctionne que si vous utilisez un système d'exploitation Unix (Linux, Mac)

Ouvrez un fichier method3.py et collez le code ci-dessous :

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) print(process.stdout)

Plongée dans ce morceau de code :

• Nous importons la fonction d'exécution du module de sous-processus
• La variable process contient le résultat de l'exécution de la commande du lorem.txt
  • du est un utilitaire Linux qui permet d'obtenir l'espace disque d'un fichier
  • capture_output nous donne accès à l'attribut standout (sortie standard)
  • text signifie que nous stockons la sortie sous forme de chaîne au lieu d'octets
• Nous imprimons la sortie standard du processus

Si vous exécutez le code ci-dessus, vous obtiendrez le résultat suivant :

 20 lorem.txt

Comme vous pouvez le voir, cela nous donne la taille et le nom du fichier. Si vous souhaitez uniquement obtenir la taille du fichier, vous devrez diviser la sortie (rappelez-vous que c'est une chaîne) et imprimer le premier élément.

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Sortir:

 20

Cette sortie n'est pas du tout lisible. On peut en déduire que l'unité de mesure utilisée est le Ko (à cause des méthodes précédentes), mais personne d'autre n'a pu deviner la taille du fichier.

Pour résoudre ce problème, nous pouvons utiliser le drapeau -h (lisible par l'homme).

Remarque : vous pouvez obtenir un manuel de cette commande en exécutant man du , ou du –help .

 from subprocess import run process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Maintenant, la sortie de ce script sera beaucoup plus lisible :

 20K

Si vous souhaitez en savoir plus sur le module de sous-processus et les applications possibles, consultez notre guide des sous-processus Python.

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

Si vous souhaitez obtenir la taille d'un dossier, vous devrez parcourir chaque fichier présent dans le répertoire et ses sous-répertoires. Nous allons le faire avec deux méthodes :

• Itérer sur un chemin avec pathlib
• Utilisation de la commande du avec sous-processus

Le code suivant utilisera un chemin vers un répertoire de test dans mon dossier personnel. Vous devrez remplacer le chemin de ce fichier par le répertoire dont vous souhaitez obtenir la taille.

Itérer sur un chemin avec pathlib

Voyons comment vous pouvez obtenir la taille d'un répertoire en itérant sur les tailles des fichiers.

 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 morceau de code semble un peu effrayant, décomposons ce que fait chaque partie.

• Importez la classe Path et la fonction naturalsize()
• Définissez la fonction get_size() avec un paramètre path , qui pointe par défaut vers le répertoire courant.
• La variable de taille est juste un espace réservé dans lequel nous ajouterons la taille de chaque fichier
• Itérer sur chaque fichier du chemin
  • La méthode rglob() renvoie récursivement les fichiers qui correspondent au modèle
  • rglob('*') , signifie que nous obtenons tous les fichiers à l'intérieur du répertoire
• Obtenez la taille de chaque fichier et ajoutez-le à la variable de taille
• Renvoie la variable de taille d'une manière lisible par l'homme

Bien entendu, je teste la fonction avec un répertoire disponible uniquement sur ma machine. N'oubliez pas de modifier le chemin d'accès à un dossier qui existe sur votre ordinateur.

Dans mon cas, j'obtiens la sortie suivante :

 403.4 MB

Utilisation de la commande du avec sous-processus

Cette approche présente certains avantages :

• Le résultat est un peu plus précis
• C'est beaucoup 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 la méthode 3, mais cette fois, nous obtenons la taille d'un répertoire au lieu d'un fichier.

Sortir:

 481M

Comme vous pouvez le voir, ces deux façons d'obtenir la taille d'un dossier renvoient un résultat légèrement différent. Plus le répertoire est grand, plus vous obtiendrez de différence.

Il est à vous de choisir entre le pathlib ou les approches sous - processus. Si vous savez que vous utiliserez Linux à chaque fois, utilisez subprocess , sinon vous pouvez utiliser la solution pathlib.

Pour résumer

Les résultats Python sont extrêmement pratiques lors de l'interaction avec le système d'exploitation. Vous pouvez automatiser les processus et gagner beaucoup de temps avec Python. Les principaux modules pour interagir avec le système d'exploitation sont os, sys, path et subprocess.

Dans ce tutoriel, vous avez appris :

• Comment Python interagit avec le système d'exploitation
• L'utilisation de modules intégrés pour effectuer des opérations du système d'exploitation
• Comment utiliser le module d' humanisation pour imprimer lisiblement
• Pour calculer la taille d'un fichier avec 3 approches
• Pour calculer la taille d'un répertoire de manière récursive ou avec la commande du