Módulo Pathlib

Este módulo incluido en Python es para trabajar con las rutas del sistema de archivos. Las clases que contiene este módulo se dividen entre rutas puras, que proporcionan operaciones computacionales sin E/S; y rutas concretas, que heredan de las rutas puras pero también proporcionan operaciones de E/S.

graph BT
    A[PurePath]
    F[Path]
    B[PurePosixPath]
    C[PureWindowsPath]
    D[PosixPath]
    E[WindowsPath]
    B --> A
    F --> A
    C --> A
    D --> B
    E --> C
    D --> F
    E --> F

Las rutas puras son útiles en algunos casos concretamente:

1. Si deseas manipular rutas de Windows en una máquina Unix (o vicecersa). No puedes crear una instancia de WindowsPath cuando se ejecuta en Unix, pero se puede crear una instancia de PureWindowsPath.

Uso básico

from pathlib import Path

p = Path('.')

Rutas puras

Los objetos de ruta pura proporcionan operaciones de manejo de rutas que en realidad no acceden al sistema de archivos.

class pathlib.PurePath(*pathsegment)

Una clase genérica que representa la familia de rutas del sistema (al crear la instancia se crea PurePosixPath o PureWindowsPath). Cada elemento de los segmentos de rutas (pathsegment) puede ser una cadena que represente un segmento de la ruta o un objeto que implementa la interfaz os.PathLike donde el método __fspath__() devuelve una cadena, como otro obejto de ruta:

from pathlib import PurePath

p = PurePath('parent', 'child')
print(p)

Ejecutado en Unix:

parent/child

Ejecutado en Windows:

parent\child

Cuando *pathsegment está vacío, se asume el directorio actual.

En Windows, los separadores no se repiten cuando se hace lo siguiente:

from pathlib import PureWindowsPath

p = PureWindowsPath('C:/Windows', '/Program Files')

print(p)

C:\Program Files

Las rutas de diferentes familias no son iguales:

from pathlib import PureWindowsPath, PurePosixPath

print(PureWindowsPath('foo') == PurePosixPath('foo'))

Descomponer una ruta en partes

Podemos acceder a las partes (componentes) individuales de una ruta, usamos la propiedad parts.

from pathlib import PurePath

p = PurePath('/foo/bar')
print(p.parts)

En Windows:

('\\', 'foo', 'bar')

En Unix:

('/', 'foo', 'bar')

Métodos y propiedades

PurePath.drive

Retorna una cadena que representa la letra o el nombre de la unidad que corresponda:

from pathlib import PureWindowsPath

p = PureWindowsPath('c:/Program Files/')

print(p.drive)

c:

PurePath.parent

EL padre lógico de la ruta:

from pathlib import PurePosixPath

p = PurePosixPath('/a/b/c/d')

print(p.parent)

/a/b/c

PurePath.name

Retorna el componente final de la ruta:

from pathlib import PureWindowsPath

p = PureWindowsPath('C:/Program Files/Git/git-bash.exe')

print(p.name)

git-bash.exe

PurePath.suffix

La extensión del archivo del componente final (si lo hay):

from pathlib import PurePosixPath

p = PurePosixPath('/home/project/main.py')

print(p.suffix)

.py

PurePath.stem

El componente final sin su extensión:

from pathlib import PurePosixPath

p = PurePosixPath('/home/project/main.py')

print(p.stem)

main

PurePath.as_posix()

Devuelve una cadena que representa la ruta con barras invertidas /:

from pathlib import PureWindowsPath

p = PureWindowsPath("C:\\Program Files\\Git\\git-bash.exe")
print(p.as_posix())

C:/Program Files/Git/git-bash.exe

---

Rutas concretas

Las rutas concretas son subclases de las rutas puras. Además de las operaciones que proporcionan las rutas puras, también proporcionan métodos que pueden interactuar con el sistema de archivos usando los objetos de ruta.

class pathlib.Path(*pathsegments)

Una subclase de PurePath, esta clase representa rutas concretas de la familia de rutas del sistema:

from pathlib import WindowsPath

p = WindowsPath("c:\\Program Files\\Git\git-bash.exe")

c:\Program Files\Git\git-bash.exe

Solo se pueden crear instancias de la familia de clase que corresponde a su sistema operativo (permitir llamadas al sistema de archivos que no sea compatible, puede provocar errores en la aplicación)