• Assurez la sécurité des applications de la bonne manière! Détectez, protégez, surveillez, accélérez et plus encore…
  • 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) à un 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 ?

    Python interagit avec l'OS avec les modules os, sys, path et subprocess

    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 sous-processus.

    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 :

    • Tu: 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
    • Bibliothèque de chemins : 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 : Gestion de l'exécution et des sous-processus directement depuis Python. Cela implique de travailler avec le  stdinstdout, et les codes de retour. Vous pouvez en savoir plus 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.

    A Noter: 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 le Taille des fichiers et des dossiers dans Python GitHub référentiel

    Using os.stat().st_size

    Dans cette méthode, nous allons utiliser le stat () fonction du module os. Il renvoie beaucoup d'informations sur un chemin spécifique.

    A Noter: Le os.path.getsize() la fonction fait également le travail. L'avantage d'utiliser os.stat().st_taille c'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 quelques texte stupide. Nous pouvons visiter un Générateur de texte Lorem Ipsum et collez le texte dans le lorem.txt fichier.

    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 os E/S, contrôle PID ou de communication
    • La variable size contient la taille du fichier lorem.txt
      • Le os.stat() la fonction renvoie un tas d'informations liées au fichier
      • Le st_taille l'attribut représente la taille du fichier
    • Nous imprimons le taille variable

    Tâcher de exécuter le script Python. Vous obtiendrez un résultat différent selon le contenu de votre lorem.txt fichier.

    Sortie :

    20064

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

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

    pip install humanize

    Ensuite, vous pouvez utiliser le taille naturelle() fonction 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.

    Sortie :

    20064
    20.1 kB

    Using Pathlib

    Bien que pathlib est conçu pour fonctionner exclusivement avec des chemins, il intègre quelques fonctions utiles d'autres modules en tant que méthodes d'objets Path (Instances de la classe Path).

    Créer un fichier method2.py et importez le Classe de chemin.

    from pathlib import Path

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

    file_ = Path('lorem.txt')

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

    print(file_.stat().st_size)

    Sortie :

    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

    Using Unix commands with 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.

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

    Ouvrez le 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 le 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 nous permet d'obtenir l'espace disque d'un fichier
      • capture_sortie nous donne accès à l'attribut standout (sortie standard)
      • texte 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, il 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)

    Sortie :

    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 -h drapeau (lisible par l'homme).

    A Noter: Vous pouvez obtenir un manuel de cette commande en exécutant homme duou du –aide.

    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.

    Get the Size of a Folder Recursively

    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 pour 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.

    • Importer le Chemin la classe et la taille naturelle() fonction
    • Définir la obtenir_taille() fonction avec un paramètre chemin, 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
      • Le rglob() la méthode renvoie récursivement les fichiers qui correspondent au modèle
      • rglob('*'), signifie que nous obtenons tous les fichiers dans le 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 sûr, 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.

    Sortie :

    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.

    A vous de choisir entre les pathlib ou le sous-processus approches. Si vous savez que vous utiliserez Linux à chaque fois, utilisez sous-processus, 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 humaniser module pour imprimer lisible par l'homme
    • 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 le du commander