One place for hosting & domains

      pathlib

      Cómo usar el módulo pathlib para manipular las rutas de sistemas de archivos en Python 3


      El autor seleccionó el COVID-19 Relief Fund para que reciba una donación como parte del programa Write for DOnations.

      Introducción

      Python 3 incluye el módulo pathlib para manipular rutas de sistemas de archivos de forma agnóstica en cualquier sistema operativo. El módulo pathlib es similar al os.path, pero pathlib ofrece una interfaz de nivel más alto, y, a menudo, más conveniente, que os.path.

      Podemos identificar archivos en una computadora con rutas jerárquicas. Por ejemplo, podemos identificar el archivo wave.txt en una computadora con esta ruta: /Users/sammy/ocean/wave.txt. Cada sistema operativo tiene una manera ligeramente distinta de representar rutas. Windows puede representar la ruta al archivo wave.txt de la siguiente manera: C:Userssammyoceanwave.txt.

      El módulo pathlib le puede resultar útil si desea a crear o mover archivos en el sistema de archivos de su programa de Python, enumerar los archivos del sistema de archivos que coincidan con una extensión o un patrón determinado o crear rutas de archivos apropiadas para el sistema operativo basadas en colecciones de cadenas sin procesar. Si bien es posible usar otras herramientas (como el módulo os.path) para realizar muchas de estas tareas, el módulo pathlib le permite realizar estas operaciones con un alto grado de legibilidad y una cantidad de código mínima.

      En este tutorial, revisaremos algunas de las maneras de usar el módulo pathlib para representar y manipular las rutas de los sistemas de archivos.

      Requisitos previos

      Para sacar el máximo provecho de este tutorial, se recomienda tener cierta familiaridad con la programación en Python 3. Puede consultar estos tutoriales para obtener la información de fondo necesaria:

      Cómo crear instancias Path

      El módulo pathlib proporciona varias clases, pero una de las más importantes es la clase Path. Las instancias de la clase Path representan una ruta a un archivo o un directorio en el sistema de archivos de nuestra computadora.

      Por ejemplo, el siguiente código inicia una instancia Path que representa una parte de la ruta a un archivo wave.txt:

      from pathlib import Path
      
      wave = Path("ocean", "wave.txt")
      print(wave)
      

      Si ejecutamos este código, obtendremos un resultado como el siguiente:

      Output

      ocean/wave.txt

      from pathlib import Path permite que la clase Path esté disponible en nuestro programa. Luego, Path("ocean", "wave.txt") crea una instancia de Path nueva. El resultado muestra que Python ha añadido el separador / adecuado del sistema operativo entre los dos componentes de la ruta que le proporcionamos: "ocean" y "wave.txt".

      Nota: Sus resultados pueden diferir ligeramente de los que se muestran como ejemplo en este tutorial en función del sistema operativo que utilice. Si utiliza Windows, por ejemplo, su resultado para este primer ejemplo puede tener este aspecto: oceanwave.txt.

      Actualmente, el objeto Path asignado a la variable wave contiene una ruta relativa. En otras palabras, ocean/wave.txt puede existir en varias ubicaciones de nuestro sistema de archivos. Por ejemplo, puede estar presente en /Users/user_1/ocean/wave.txt o /Users/user_2/research/ocean/wave.txt, pero no especificamos exactamente a cuál nos estamos refiriendo. Por el contrario, una ruta absoluta se refiere inequívocamente a una ubicación en el sistema de archivos.

      Puede usar Path.home() para obtener la ruta absoluta al directorio principal del usuario actual:

      home = Path.home()
      wave_absolute = Path(home, "ocean", "wave.txt")
      print(home)
      print(wave_absolute)
      

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      Output

      /Users/sammy /Users/sammy/ocean/wave.txt

      Nota: Como se mencionó anteriormente, su resultado variará dependiendo de su sistema operativo. Por supuesto, su directorio principal también será distinto de /Users/sammy.

      Path.home() devuelve una instancia Path con una ruta absoluta al directorio principal del usuario actual. Luego, pasamos esta instancia de Path y las cadenas "ocean" y "wave.txt" a otro constructor de Path para crear una ruta absoluta al archivo wave.txt. El resultado indica que la primera línea es el directorio principal y la segunda, el directorio principal más ocean/wave.txt.

      Este ejemplo también ilustra una característica importante de la clase Path: el constructor Path acepta tanto cadenas como objetos preexistentes de Path.

      Analicemos con mayor detalle cómo es que el constructor Path admite tanto cadenas como de objetos de Path:

      shark = Path(Path.home(), "ocean", "animals", Path("fish", "shark.txt"))
      print(shark)
      

      Si ejecutamos este código de Python, obtendremos un resultado similar al siguiente:

      Output

      /Users/sammy/ocean/animals/fish/shark.txt

      shark es un Path a un archivo que construimos usando tanto objetos Path (Path.home() y Path("fish", "shark.txt")) como cadenas ("ocean" y "animals"). El constructor Path gestiona de forma inteligente ambos tipos de objetos y los une de forma correcta usando el separador correspondiente del sistema operativo, en este caso: /.

      Acceder a los atributos de los archivos

      Ahora que hemos aprendido a crear instancias de Path, vamos a repasar cómo puede usar esas instancias para acceder a información sobre un archivo.

      Podemos usar los atributos name y suffix para acceder a los nombres y los sufijos de archivos:

      wave = Path("ocean", "wave.txt")
      print(wave)
      print(wave.name)
      print(wave.suffix)
      

      Al ejecutar este código, obtendremos un resultado similar al siguiente:

      Output

      /Users/sammy/ocean/wave.txt wave.txt .txt

      Este resultado indica que el nombre del archivo al final de nuestra ruta es wave.txt y el sufijo de ese archivo es .txt.

      Las instancias de Path también ofrecen la función with_name, que le permite crear de forma sencilla un objeto Path nuevo con un nombre distinto:

      wave = Path("ocean", "wave.txt")
      tides = wave.with_name("tides.txt")
      print(wave)
      print(tides)
      

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      ocean/wave.txt
      ocean/tides.txt
      

      El código, primero, construye una instancia Path que apunta a un archivo llamado wave.txt. Luego, invoca el método with_name en wave para devolver una segunda instancia Path que apunta a un archivo nuevo denominado tides.txt. La parte del directorio ocean/ de la ruta permanece intacta, por lo tanto, la ruta final queda establecida como ocean/tides.txt

      Acceder a antecesores

      A veces, resulta útil acceder a directorios que contienen una ruta determinada. Consideremos un ejemplo:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent)
      

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      Output

      ocean/animals/fish/shark.txt ocean/animals/fish

      El atributo parent en una instancia de Path devuelve el antecesor más inmediato de una ruta de archivos determinada. En este caso, devuelve el directorio que contiene el archivo shark.txt: ocean/animals/fish.

      Podemos acceder al atributo parent varias veces seguidas para recorrer el árbol de ancestros de un archivo determinado:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent.parent)
      

      Si ejecutamos este código, obtendremos el siguiente resultado:

      Output

      ocean/animals/fish/shark.txt ocean/animals

      El resultado es similar al anterior, pero, ahora, hemos llegado a un nivel más alto al acceder a .parent por segunda vez. El directorio ocean/animals se encuentra dos directorios por encima de shark.txt.

      Usar Glob para enumerar archivos

      También es posible usar la clase Path para enumerar archivos usando el método glob.

      Imaginemos que tenemos una estructura de directorios similar a la siguiente:

      └── ocean
          ├── animals
          │   └── fish
          │       └── shark.txt
          ├── tides.txt
          └── wave.txt
      

      Un directorio ocean que contiene los archivos tides.txt y wave.txt. Tenemos un archivo denominado shark.txt anidado en el directorio ocean, un directorio animals y otro fish: ocean/animals/fish.

      Para enumerar todos los archivos .txt del directorio ocean, podríamos escribir lo siguiente:

      for txt_path in Path("ocean").glob("*.txt"):
          print(txt_path)
      

      Este código tendría un resultado similar al siguiente:

      Output

      ocean/wave.txt ocean/tides.txt

      El patrón glob __"*.txt" busca todos los archivos que terminan en .txt. Como el código del ejemplo ejecuta ese glob en el directorio ocean, devuelve los dos archivos .txt del directorio ocean: wave.txt y tides.txt.

      Nota: Para duplicar los resultados que se muestran en este ejemplo, copie la estructura de directorios que se ilustra aquí en su computadora.

      También podemos usar el método glob de manera recursiva. Para enumerar todos los archivos .txt del directorio ocean y todos sus subdirectorios, podemos escribir lo siguiente:

      for txt_path in Path("ocean").glob("**/*.txt"):
          print(txt_path)
      

      Al ejecutar este código, obtendríamos un resultado similar al siguiente:

      Output

      ocean/wave.txt ocean/tides.txt ocean/animals/fish/shark.txt

      La sección ** del patrón glob coincidirá con este directorio y todos sus subdirectorios de manera recursiva. Por tanto, no solo tenemos los archivos wave.txt y tides.txt en el resultado, sino que también recibimos el archivo shark.txt que estaba anidado en ocean/animals/fish.

      Calcular rutas relativas

      Podemos usar el método Path.relative_to para calcular rutas relacionadas entre sí. El método relative_to es útil cuando, por ejemplo, se desea recuperar una porción de una ruta de archivos larga.

      Analice el siguiente código:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      below_ocean = shark.relative_to(Path("ocean"))
      below_animals = shark.relative_to(Path("ocean", "animals"))
      print(shark)
      print(below_ocean)
      print(below_animals)
      

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      Output

      ocean/animals/fish/shark.txt animals/fish/shark.txt fish/shark.txt

      El método relative_to devuelve un nuevo objeto Path relacionado con el argumento determinado. En nuestro ejemplo, calculamos el Path a shark.txt en relación con el directorio ocean y, luego, en relación con los directorios ocean y animals.

      Si relative_to no puede calcular una respuesta porque le indicamos una ruta no relacionada, presenta un ValueError:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      shark.relative_to(Path("unrelated", "path"))
      

      Obtendremos una excepción ValueError generada a partir de este código que será similar a la siguiente:

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/Python3.8/pathlib.py", line 899, in relative_to raise ValueError("{!r} does not start with {!r}" ValueError: 'ocean/animals/fish/shark.txt' does not start with 'unrelated/path'

      unrelated/path no forma parte de ocean/animals/fish/shark.txt, por lo tanto, Python no puede calcular una ruta relativa.

      Conclusión

      El módulo pathlib es un componente importante de la biblioteca estándar de Python que nos permite manipular rutas de sistemas de archivos de forma rápida en cualquier sistema operativo. En este tutorial, ha aprendido a usar algunas de las herramientas clave de pathlib para acceder a los atributos de archivos, enumerar archivos con patrones glob y desplazarse por archivos y directorios principales.

      El módulo pathlib expone clases y utilidades adicionales que no abarcamos en este tutorial. Ahora que tiene una referencia, puede usar la documentación del módulo pathlib para obtener más información sobre otras clases y utilidades disponibles.

      Si está interesado en utilizar otras bibliotecas de Python, consulte los siguientes tutoriales:



      Source link

      Comment utiliser le module pathlib pour manipuler les chemins des systèmes de fichiers en Python 3


      L’auteur a choisi le COVID-19 Relief Fund pour recevoir un don dans le cadre du programme Write for DOnations.

      Introduction

      Python 3 inclut le module pathlib, qui permet de manipuler les chemins des systèmes de fichiers de manière agnostique, quel que soit le système d’exploitation. pathlib est similaire au module os.path, mais pathlib offre un niveau d’interface supérieur — et souvent plus pratique — qu’os.path.

      Nous pouvons identifier des fichiers sur un ordinateur avec des chemin hiérarchiques. Par exemple, nous pourrions identifier le fichier wave.txt sur un ordinateur avec ce chemin : /Users/sammy/ocean/wave.txt. Les systèmes d’exploitation représentent les chemins de manière légèrement différente. Windows peut représenter le chemin d’accès au fichier wave.txt comme ceci, C:Userssammyoceanwave.txt.

      Vous pouvez trouver le module pathlib utile si dans votre programme Python vous créez ou déplacez des fichiers dans le système de fichiers, listez des fichiers sur le système de fichiers qui correspondent tous à une extension ou un modèle donnés, ou créez des chemins de fichiers appropriés du système d’exploitation basés sur des collections de chaînes de caractères. Bien que vous puissiez utiliser d’autres outils (comme le module os.path) pour accomplir plusieurs de ces tâches, le module pathlib vous permet d’effectuer ces opérations avec un degré de lisibilité élevé et une quantité minimale de code.

      Dans ce tutoriel, nous aborderons certaines des façons d’utiliser le module pathlib pour représenter et manipuler les chemins du système de fichiers.

      Conditions préalables

      Pour tirer le meilleur parti de ce tutoriel, il est recommandé d’être familiarisé avec la  programmation en Python 3. Vous pouvez consulter ces tutoriels pour obtenir les informations de base nécessaires :

      Construire des instances Path

      Le module pathlib fournit plusieurs classes, mais l’une des plus importantes est la classe Path. Les instances de la classe Path représentent un chemin d’accès à un fichier ou un répertoire du système de fichiers de notre ordinateur.

      Par exemple, le code suivant instancie une instance Path qui représente une partie du chemin d’accès à un fichier wave.txt :

      from pathlib import Path
      
      wave = Path("ocean", "wave.txt")
      print(wave)
      

      Si nous exécutons ce code, nous obtiendrons le résultat suivant :

      Output

      ocean/wave.txt

      from pathlib import Path rend la classe Path disponible pour notre programme. Ensuite, Path("ocean", "wave.txt") instance une instance nouvelle Path. L’impression de la sortie montre que Python a ajouté le séparateur approprié du système d’exploitation / entre les deux composants de chemin que nous lui avons donné : "ocean"et "wave.txt".

      Remarque : En fonction de votre système d’exploitation, votre résultat peut varier légèrement par rapport aux exemples de sorties présentés dans ce tutoriel. Si vous utilisez Windows, par exemple, votre résultat pour ce premier exemple ressemblera peut-être à oceanwave.txt.

      À présent, l’objet Path assigné à la variable wave contient un chemin relatif. En d’autres termes, ocean/wave.txt pourrait exister à plusieurs emplacements de notre système de fichiers. À titre d’exemple, il peut exister dans /Users/user_1/ocean/wave.txt ou /Users/user_2/research/ocean/wave.txt, mais nous n’avons pas préciséà quel endroit exactement nous faisons référence. Un chemin absolu, en revanche, renvoie sans ambiguïté à un seul emplacement du système de fichiers.

      Vous pouvez utiliser Path.home() pour obtenir le chemin absolu du répertoire d’accueil de l’utilisateur actuel :

      home = Path.home()
      wave_absolute = Path(home, "ocean", "wave.txt")
      print(home)
      print(wave_absolute)
      

      Si nous exécutons ce code, nous obtiendrons en gros le résultat suivant :

      Output

      /Users/sammy /Users/sammy/ocean/wave.txt

      Remarque : Comme mentionné précédemment, votre sortie varie en fonction de votre #système d’exploitation. Votre répertoire d’accueil, bien sûr, sera également différent de /Users/sammy.

      Path.home() renvoie une instance Path avec un chemin absolu vers le répertoire d’accueil de l’utilisateur actuel. Nous passons ensuite dans cette instance Path et les chaînes "ocean" et "wave.txt" dans un autre constructeur Path pour créer un chemin absolu vers le fichier wave.txt. La sortie montre que la première ligne est le répertoire d’accueil, et la deuxième ligne est le répertoire d’accueil plus ocean/wave.txt.

      Cet exemple illustre également une caractéristique importante de la classe Path : le constructeur Path accepte les chaînes et les objets Path préexistants.

      Examinons de plus près le support des chaînes et des objets Path dans le constructeur Path  :

      shark = Path(Path.home(), "ocean", "animals", Path("fish", "shark.txt"))
      print(shark)
      

      Si nous exécutons ce code Python, nous obtiendrons un résultat similaire au suivant :

      Output

      /Users/sammy/ocean/animals/fish/shark.txt

      shark est un Path vers un fichier que nous avons construit en utilisant les objets Path (Path.home() et Path("fish", "shark.txt")) et les chaînes ("ocean" et "animals"). Le constructeur Path traite intelligemment les deux types d’objets et les joint de manière propre en utilisant le séparateur du système d’exploitation approprié, dans ce cas /.

      Accéder aux attributs de fichier

      Maintenant que nous avons appris comment construire des instances Path, examinons comment vous pouvez utiliser ces instances pour accéder aux informations sur un fichier.

      Nous pouvons utiliser les attributs name et suffix pour accéder aux noms de fichier et aux suffixes :

      wave = Path("ocean", "wave.txt")
      print(wave)
      print(wave.name)
      print(wave.suffix)
      

      En exécutant ce code, nous obtiendrons un résultat similaire à ce qui suit :

      Output

      /Users/sammy/ocean/wave.txt wave.txt .txt

      Cette sortie montre que le nom du fichier à la fin de notre chemin est wave.txt et le suffixe de ce fichier est .txt.

      Les instances Path offrent également la fonction with_name, qui permet de créer de manière transparente un nouvel objet Path portant un nom différent :

      wave = Path("ocean", "wave.txt")
      tides = wave.with_name("tides.txt")
      print(wave)
      print(tides)
      

      Si nous exécutons ce code, nous obtiendrons le résultat suivant :

      ocean/wave.txt
      ocean/tides.txt
      

      Le code construit d’abord une instance Path qui pointe vers un fichier nommé wave.txt. Ensuite, nous appelons la méthode with_name sur wave pour renvoyer une seconde instance Path qui pointe vers un nouveau fichier nommé tides.txt. La partie du chemin correspondant au répertoire ocean/ reste inchangée, ce qui fait que le chemin final devient ocean/tides.txt

      Accéder aux ascendants

      Il est parfois utile d’accéder à des répertoires qui contiennent un chemin d’accès donné. Prenons un exemple :

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent)
      

      Si nous exécutons ce code, nous obtiendrons un résultat qui ressemble au suivant :

      Output

      ocean/animals/fish/shark.txt ocean/animals/fish

      L’attribut parent d’une instance Path renvoie l’ascendant le plus immédiat d’un chemin de fichier donné. Dans ce cas, il renvoie le répertoire qui contient le fichier shark.txt : ocean/animals/fish.

      Nous pouvons accéder à l’attribut parent plusieurs fois de suite pour remonter l’arbre d’ascendance d’un fichier donné :

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent.parent)
      

      Si nous exécutons ce code, nous obtiendrons le résultat suivant :

      Output

      ocean/animals/fish/shark.txt ocean/animals

      La sortie est similaire à la sortie précédente, mais maintenant nous avons traversé un autre niveau plus élevé en accédant à .parent une seconde fois. Deux répertoires plus haut que shark.txt nous avons le répertoire ocean/animals.

      Utiliser Glob pour lister les fichiers

      Il est également possible d’utiliser la classe Path pour lister les fichiers à l’aide de la méthode glob.

      Supposons que nous avons une structure de répertoire qui ressemblait à ceci :

      └── ocean
          ├── animals
          │   └── fish
          │       └── shark.txt
          ├── tides.txt
          └── wave.txt
      

      Le répertoire ocean contient les fichiers tides.txt et wave.txt. Nous avons un fichier nommé shark.txt imbriqué sous le répertoire ocean, un répertoire animals et un répertoire fish : ocean/animals/fish.

      Pour lister tous les fichiers .txt du répertoire ocean, nous pourrions dire :

      for txt_path in Path("ocean").glob("*.txt"):
          print(txt_path)
      

      Ce code donnerait un résultat du type :

      Output

      ocean/wave.txt ocean/tides.txt

      Le modèle glob "*.txt" trouve tous les fichiers se terminant par .txt. Comme l’exemple de code exécute ce glob dans le répertoire ocean, il renvoie les deux fichiers .txt du répertoire ocean : wave.txt et tides.txt.

      Remarque : Si vous souhaitez dupliquer les sorties indiquées dans cet exemple, vous devrez imiter la structure de répertoire illustrée ici sur votre ordinateur.

      Nous pouvons également utiliser la méthode glob de manière récursive. Pour lister tous les fichiers .txt du répertoire ocean et tous ses sous-répertoires, nous pourrions dire :

      for txt_path in Path("ocean").glob("**/*.txt"):
          print(txt_path)
      

      Si nous exécutons ce code, nous obtiendrions le résultat suivant :

      Output

      ocean/wave.txt ocean/tides.txt ocean/animals/fish/shark.txt

      La partie ** du modèle glob correspondra à ce répertoire et tous les répertoires en dessous, de manière récursive. Donc, non seulement nous avons les fichiers wave.txt et tides.txt dans la sortie, mais nous recevons également le fichier shark.txt qui a été imbriqué sous ocean/animals/fish.

      Calculer les chemin relatifs

      Nous pouvons utiliser la méthode Path.relative_to pour calculer les chemins par rapport aux autres. La méthode relative_to est utile lorsque, par exemple, vous souhaitez récupérer une partie d’un long chemin de fichier.

      Prenons le cas du code suivant :

      shark = Path("ocean", "animals", "fish", "shark.txt")
      below_ocean = shark.relative_to(Path("ocean"))
      below_animals = shark.relative_to(Path("ocean", "animals"))
      print(shark)
      print(below_ocean)
      print(below_animals)
      

      Si nous exécutons ce code, nous obtiendrons le résultat suivant :

      Output

      ocean/animals/fish/shark.txt animals/fish/shark.txt fish/shark.txt

      La méthode relative_to renvoie un nouvel objet Path relatif à l’argument donné. Dans notre exemple, nous calculons le Path d’accès à shark.txt par rapport au répertoire ocean, puis par rapport aux répertoires ocean et animals.

      Si la fonction relative_to ne peut pas calculer de réponse parce que nous lui fournissons un chemin non relié, elle génère une ValueError :

      shark = Path("ocean", "animals", "fish", "shark.txt")
      shark.relative_to(Path("unrelated", "path"))
      

      Nous obtiendrons une exception ValueError qui a été soulevée à partir de ce code et qui ressemblera à quelque chose comme ceci :

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/Python3.8/pathlib.py", line 899, in relative_to raise ValueError("{!r} does not start with {!r}" ValueError: 'ocean/animals/fish/shark.txt' does not start with 'unrelated/path'

      unrelated/path n’est pas une partie de ocean/animals/fish/shark.txt, Python n’a donc aucun moyen pour de calculer un chemin relatif pour nous.

      Conclusion

      Le module pathlib est une partie puissante de la bibliothèque standard Python qui nous permet de manipuler rapidement les chemins du système de fichiers sur n’importe quel système d’exploitation. Dans ce tutoriel, nous avons appris à utiliser certains des utilitaires clés de pathlib pour accéder aux attributs de fichier, lister les fichiers avec des modèles glob, et parcourir les fichiers et les répertoires parents.

      Le module pathlib propose des classes et des utilitaires supplémentaires que nous n’avons pas abordés dans ce tutoriel. Maintenant que vous disposez d’une base de référence, vous pouvez utiliser la documentation du module pathlib pour en savoir plus sur d’autres classes et utilitaires disponibles.

      Si vous souhaitez utiliser d’autres bibliothèques Python, consultez les tutoriels suivants :



      Source link

      Como usar o módulo pathlib para manipular os caminhos de sistema de arquivos no Python 3


      O autor selecionou a COVID-19 Relief Fund​​​​​ para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Python 3 inclui o módulo pathlib para manipular caminhos de sistema de arquivos de maneira independente, seja qual for o sistema operacional. O pathlib é semelhante ao módulo os.path, mas o pathlib oferece um nível mais elevado — e muitas vezes mais conveniente — de interface do que o os.path.

      Podemos identificar arquivos em um computador com caminhos hierárquicos. Por exemplo, podemos identificar o arquivo wave.txt em um computador com este caminho: /Users/sammy/ocean/wave.txt. Os sistemas operacionais representam caminhos de maneira ligeiramente diferente. O Windows pode representar o caminho para o arquivo wave.txt como C:Userssammyoceanwave.txt.

      O módulo pathlib pode ser útil para você se em seu programa Python você estiver criando ou movendo arquivos no sistema de arquivos, listando arquivos no sistema de arquivos em que todos correspondam a uma dada extensão ou padrão, ou criando caminhos de arquivo apropriados ao sistema operacional baseados em coleções de strings brutas. Embora seja possível usar outras ferramentas (como o módulo os.path) para realizar muitas dessas tarefas, o módulo pathlib permite que você execute essas operações com um alto grau de legibilidade e uma quantidade mínima de código.

      Neste tutorial, vamos revisar algumas das maneiras de usar o módulo pathlib para representar e manipular os caminhos de sistema de arquivos.

      Pré-requisitos

      Para tirar o máximo proveito deste tutorial, é recomendado ter alguma familiaridade com programação em Python 3. Você pode revisar esses tutoriais para as informações básicas necessárias:

      Construindo instâncias Path

      O módulo pathlib oferece várias classes, mas uma das mais importantes é a classe Path. As instâncias da classe Path representam um caminho para um arquivo ou diretório no sistema de arquivos do nosso computador.

      Por exemplo, o código a seguir cria uma instância Path que representa parte do caminho para um arquivo wave.txt:

      from pathlib import Path
      
      wave = Path("ocean", "wave.txt")
      print(wave)
      

      Se executarmos esse código, receberemos um resultado como o seguinte:

      Output

      ocean/wave.txt

      from pathlib import Path torna a classe Path disponível para nosso programa. Em seguida, Path("ocean", "wave.txt") cria uma nova instância do Path. Imprimir o resultado mostra que o Python adicionou o separador de sistema operacional / apropriado entre os dois componentes do caminho que demos a ele: "ocean" e "wave.txt".

      Nota: dependendo do seu sistema operacional, o resultado pode variar ligeiramente dos resultados de exemplo exibidos neste tutorial. Se estiver utilizando o Windows, por exemplo, seu resultado para este primeiro exemplo se pareceria com oceanwave.txt.

      Agora, o objeto Path atribuído à variável wave contém um caminho relativo. Em outras palavras, ocean/wave.txt pode existir em vários lugares em nosso sistema de arquivos. Para exemplificar, ele pode existir em /Users/user_1/ocean/wave.txt ou /Users/user_2/research/ocean/wave.txt, mas não especificamos exatamente a qual deles estamos nos referindo. Um caminho absoluto, por outro lado, refere-se sem sombra de dúvidas a uma localização específica no sistema de arquivos.

      Use o Path.home() para obter o caminho absoluto para o diretório home do usuário atual:

      home = Path.home()
      wave_absolute = Path(home, "ocean", "wave.txt")
      print(home)
      print(wave_absolute)
      

      Se executarmos esse código, receberemos um resultado parecido com o seguinte:

      Output

      /Users/sammy /Users/sammy/ocean/wave.txt

      Nota: como mencionado anteriormente, seu resultado irá variar dependendo do seu sistema operacional. Seu diretório home, por consequência, também será diferente de /Users/sammy.

      Path.home() retorna uma instância Path com um caminho absoluto para o diretório home do usuário atual. Em seguida, passamos essa instância Path e as strings "ocean" e "wave.txt" para outro construtor Path de forma a criar um caminho absoluto para o arquivo wave.txt. O resultado mostra que a primeira linha é o diretório home, e a segunda linha é o diretório home mais ocean/wave.txt.

      Este exemplo também ilustra uma característica importante da classe Path: o construtor Path aceita tanto strings quanto objetos Path pré-existentes.

      Vamos analisar as strings e objetos Path no construtor Path um pouco mais de perto:

      shark = Path(Path.home(), "ocean", "animals", Path("fish", "shark.txt"))
      print(shark)
      

      Se executarmos esse código Python, receberemos um resultado semelhante ao seguinte:

      Output

      /Users/sammy/ocean/animals/fish/shark.txt

      shark é um Path para um arquivo que construímos usando dois objetos Path (Path.home() e Path("fish", "shark.txt")) e as strings ("ocean" e "animals"). O construtor Path lida com os dois tipos de objetos de maneira inteligente e une-os corretamente usando o separador de sistema operacional adequado, neste caso, /.

      Acessando os atributos de arquivo

      Agora que aprendemos como construir instâncias Path, vamos analisar como você pode usar essas instâncias para acessar informações sobre um arquivo.

      Podemos usar os atributos name e suffix para acessar os nomes e sufixos dos arquivos:

      wave = Path("ocean", "wave.txt")
      print(wave)
      print(wave.name)
      print(wave.suffix)
      

      Ao executar este código, receberemos um resultado semelhante ao seguinte:

      Output

      /Users/sammy/ocean/wave.txt wave.txt .txt

      Este resultado mostra que o nome do arquivo no final do nosso caminho é wave.txt e o sufixo desse arquivo é .txt.

      As instâncias Path também oferecem a função with_name que permite criar rapidamente um novo objeto Path com um nome diferente:

      wave = Path("ocean", "wave.txt")
      tides = wave.with_name("tides.txt")
      print(wave)
      print(tides)
      

      Se executarmos o código acima, receberemos um resultado como o seguinte:

      ocean/wave.txt
      ocean/tides.txt
      

      Primeiro, o código constrói uma instância Path que aponta para um arquivo chamado wave.txt. Em seguida, chamamos o método with_name em wave para retornar uma segunda instância Path que aponta para um novo arquivo chamado tides.txt. A porção de diretório ocean/ do caminho permanece inalterada, deixando o caminho final como sendo ocean/tides.txt

      Acessando diretórios ancestrais

      Às vezes, é útil acessar diretórios que contêm um dado caminho. Vamos considerar um exemplo:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent)
      

      Se executarmos esse código, receberemos um resultado parecido com o seguinte:

      Output

      ocean/animals/fish/shark.txt ocean/animals/fish

      O atributo parent em uma instância Path retorna o ancestral mais próximo de um determinado caminho de arquivo. Neste caso, ele retorna o diretório que contém o arquivo shark.txt: ocean/animals/fish.

      Podemos acessar o atributo parent várias vezes seguidas para percorrer a árvore de ancestralidade de um dado arquivo:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent.parent)
      

      Se executarmos esse código, receberemos o seguinte resultado:

      Output

      ocean/animals/fish/shark.txt ocean/animals

      O resultado é semelhante ao resultado anterior, mas agora percorremos mais um nível acessando .parent uma segunda vez. Dois diretórios acima de shark.txt, você encontrará o diretório ocean/animals.

      Usando Glob para listar arquivos

      Também é possível usar a classe Path para listar arquivos usando o método glob.

      Suponha que tivéssemos uma estrutura de diretório que se parecia com esta:

      └── ocean
          ├── animals
          │   └── fish
          │       └── shark.txt
          ├── tides.txt
          └── wave.txt
      

      Um diretório ocean contém os arquivos tides.txt e wave.txt. Temos um arquivo chamado shark.txt contido no diretório ocean, um diretório animals e um diretório fish: ocean/animals/fish.

      Para listar todos os arquivos .txt no diretório ocean, podemos utilizar:

      for txt_path in Path("ocean").glob("*.txt"):
          print(txt_path)
      

      Esse código produziria um resultado como este:

      Output

      ocean/wave.txt ocean/tides.txt

      O padrão glob "*.txt" encontra todos os arquivos terminados em .txt. Como a amostra de código executa esse glob no diretório ocean, ela retorna os dois arquivos .txt no diretório ocean: wave.txt e tides.txt.

      Nota: se você quiser replicar os resultados mostrados neste exemplo, você precisará imitar a estrutura de diretórios aqui ilustrada em seu computador.

      Também podemos usar o método glob recursivamente. Para listar todos os arquivos .txt no diretório ocean e todos os seus subdiretórios, podemos utilizar:

      for txt_path in Path("ocean").glob("**/*.txt"):
          print(txt_path)
      

      Se executarmos esse código, receberemos um resultado como o seguinte:

      Output

      ocean/wave.txt ocean/tides.txt ocean/animals/fish/shark.txt

      A parte ** do padrão glob irá corresponder a esse diretório e todos os diretórios abaixo dele, recursivamente. Dessa forma, não só temos os arquivos wave.txt e tides.txt no resultado, mas também recebemos o arquivo shark.txt que estava contido em ocean/animals/fish.

      Computando caminhos relativos

      Podemos usar o método Path.relative_to para computar caminhos em relação uns aos outros. O método relative_to é útil quando, por exemplo, você quiser recuperar parte de um caminho de arquivo longo.

      Considere o código a seguir:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      below_ocean = shark.relative_to(Path("ocean"))
      below_animals = shark.relative_to(Path("ocean", "animals"))
      print(shark)
      print(below_ocean)
      print(below_animals)
      

      Se executarmos o código acima, receberemos um resultado como o seguinte:

      Output

      ocean/animals/fish/shark.txt animals/fish/shark.txt fish/shark.txt

      O método relative_to retorna um novo objeto Path relativo ao argumento dado. Em nosso exemplo, computamos o Path para o shark.txt relativo ao diretório ocean, e então relativo tanto ao diretório ocean quanto ao diretório animals.

      Se relative_to não puder computar uma resposta porque lhe fornecemos um caminho não relacionado, ele gera um ValueError:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      shark.relative_to(Path("unrelated", "path"))
      

      Receberemos uma exceção ValueError gerada a partir deste código que será algo parecido com isto:

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/Python3.8/pathlib.py", line 899, in relative_to raise ValueError("{!r} does not start with {!r}" ValueError: 'ocean/animals/fish/shark.txt' does not start with 'unrelated/path'

      unrelated/path não faz parte de ocean/animals/fish/shark.txt, então não existe nenhuma maneira para o Python computar um caminho relativo.

      Conclusão

      O módulo pathlib é uma parte poderosa da Biblioteca Padrão do Python que nos permite manipular caminhos do sistema de arquivos rapidamente em qualquer sistema operacional. Neste tutorial, aprendemos a usar alguns utilitários chave do pathlib para acessar atributos de arquivo, listar arquivos com padrões glob e percorrer arquivos e diretórios pais.

      O módulo pathlib também oferece classes e utilitários adicionais que não abordamos neste tutorial. Agora que você tem um conhecimento base, use a documentação do módulo pathlib para aprender mais sobre outras classes e utilitários disponíveis.

      Se estiver interessado em usar outras bibliotecas do Python, confira os seguintes tutoriais:



      Source link