11.1. `pathlib` — Caminhos do Sistema de Arquivos Orientados a Objetos¶

Novo na versão 3.4.

Este módulo oferece classes que representam caminhos de sistema de arquivos com semântica apropriada para diferentes sistemas operacionais. As classes de caminho são divididas entre caminhos puros, que fornecem operações puramente computacionais sem E/S, e caminhos concretos, que herdam de caminhos puros, mas também fornecem operações de E/S.

Se você nunca usou este módulo antes ou apenas não tem certeza de qual classe é a certa para sua tarefa, provavelmente Path é o que você precisa. Ele instancia um caminho concreto para a plataforma em que o código está sendo executado.

Caminhos puros são úteis em alguns casos especiais. Por exemplo:

Se você deseja manipular os caminhos do Windows em uma máquina Unix (ou vice-versa). Você não pode instanciar uma WindowsPath quando executado no Unix, mas você pode instanciar PureWindowsPath.
Você quer ter certeza de que seu código apenas manipula caminhos, sem realmente acessar o sistema operacional. Nesse caso, instanciar uma das classes puras pode ser útil, pois elas simplesmente não têm nenhuma operação de acesso ao sistema operacional.

Ver também

PEP 428: O módulo pathlib – caminhos de sistema de arquivos orientados a objetos.

Ver também

Para manipulação de caminho de baixo nível em strings, você também pode usar o módulo os.path.

11.1.1. Utilização Básica¶

Importação da classe principal:

>>> from pathlib import Path

Listando os subdiretórios:

>>> p = Path('.')
>>> [x for x in p.iterdir() if x.is_dir()]
[PosixPath('.hg'), PosixPath('docs'), PosixPath('dist'),
 PosixPath('__pycache__'), PosixPath('build')]

Listando os arquivos fontes do Python e sua árvore de diretórios:

>>> list(p.glob('**/*.py'))
[PosixPath('test_pathlib.py'), PosixPath('setup.py'),
 PosixPath('pathlib.py'), PosixPath('docs/conf.py'),
 PosixPath('build/lib/pathlib.py')]

Navegando dentro da árvore de diretórios:

>>> p = Path('/etc')
>>> q = p / 'init.d' / 'reboot'
>>> q
PosixPath('/etc/init.d/reboot')
>>> q.resolve()
PosixPath('/etc/rc.d/init.d/halt')

Consultando as propriedades do path:

>>> q.exists()
True
>>> q.is_dir()
False

Abrindo um arquivo:

>>> with q.open() as f: f.readline()
...
'#!/bin/bash\n'

11.1.2. Caminhos puros¶

Objetos de caminho puro fornecem operações de manipulação de caminho que, na verdade, não acessam um sistema de arquivos. Existem três maneiras de acessar essas classes, que também chamamos de sabores:

class pathlib.PurePath(*pathsegments)¶

Uma classe genérica que representa o tipo de caminho do sistema (instanciando-a cria uma PurePosixPath ou uma PureWindowsPath):

>>> PurePath('setup.py')      # Running on a Unix machine
PurePosixPath('setup.py')

Cada elemento de pathsegments pode ser uma string representando um segmento de caminho, um objeto que implementa a interface os.PathLike que retorna uma string ou outro objeto caminho:

>>> PurePath('foo', 'some/path', 'bar')
PurePosixPath('foo/some/path/bar')
>>> PurePath(Path('foo'), Path('bar'))
PurePosixPath('foo/bar')

Quando pathsegments está vazio, o diretório atual é presumido:

>>> PurePath()
PurePosixPath('.')

Quando vários caminhos absolutos são fornecidos, o último é tomado como uma âncora (imitando o comportamento de os.path.join()):

>>> PurePath('/etc', '/usr', 'lib64')
PurePosixPath('/usr/lib64')
>>> PureWindowsPath('c:/Windows', 'd:bar')
PureWindowsPath('d:bar')

No entanto, em um caminho do Windows, a alteração da raiz local não descarta a configuração da unidade anterior:

>>> PureWindowsPath('c:/Windows', '/Program Files')
PureWindowsPath('c:/Program Files')

Barras espúrias e pontos únicos são recolhidos, mas os pontos duplos ('..') não, pois isso mudaria o significado de um caminho em face de links simbólicos:

>>> PurePath('foo//bar')
PurePosixPath('foo/bar')
>>> PurePath('foo/./bar')
PurePosixPath('foo/bar')
>>> PurePath('foo/../bar')
PurePosixPath('foo/../bar')

(uma abordagem ingênua seria criar PurePosixPath('foo/../bar') equivalente a PurePosixPath('bar'), o que é errado se foo for um link simbólico para outro diretório)

Objetos caminho puro implementam a interface os.PathLike, permitindo que sejam usados em qualquer lugar em que a interface seja aceita.

Alterado na versão 3.6: Adicionado suporte para a interface os.PathLike.

class pathlib.PurePosixPath(*pathsegments)¶

Uma subclasse de PurePath, este tipo de caminho representa caminhos de sistema de arquivos não Windows:

>>> PurePosixPath('/etc')
PurePosixPath('/etc')

pathsegments é especificado de forma similar para PurePath.

class pathlib.PureWindowsPath(*pathsegments)¶

Uma subclasse de PurePath, este tipo de caminho representa os caminhos do sistema de arquivos do Windows:

>>> PureWindowsPath('c:/Program Files/')
PureWindowsPath('c:/Program Files')

pathsegments é especificado de forma similar para PurePath.

Independentemente do sistema em que você está usando, você pode instanciar todas essas classes, uma vez que elas não fornecem nenhuma operação que faça chamadas de sistema.

11.1.2.1. Propriedades Gerais¶

Os caminhos são imutáveis e hasheáveis. Os caminhos do mesmo sabor são comparáveis e ordenáveis. Essas propriedades respeitam a semântica de caixa alta e baixa do sabor:

>>> PurePosixPath('foo') == PurePosixPath('FOO')
False
>>> PureWindowsPath('foo') == PureWindowsPath('FOO')
True
>>> PureWindowsPath('FOO') in { PureWindowsPath('foo') }
True
>>> PureWindowsPath('C:') < PureWindowsPath('d:')
True

Caminhos de um sabor diferente são comparados de forma desigual e não podem ser ordenados:

>>> PureWindowsPath('foo') == PurePosixPath('foo')
False
>>> PureWindowsPath('foo') < PurePosixPath('foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'PureWindowsPath' and 'PurePosixPath'

11.1.2.2. Operadores¶

O operador barra ajuda a criar caminhos filhos, de forma semelhante a os.path.join():

>>> p = PurePath('/etc')
>>> p
PurePosixPath('/etc')
>>> p / 'init.d' / 'apache2'
PurePosixPath('/etc/init.d/apache2')
>>> q = PurePath('bin')
>>> '/usr' / q
PurePosixPath('/usr/bin')

Um objeto de caminho pode ser usado em qualquer lugar em que um objeto implementando os.PathLike seja aceito:

>>> import os
>>> p = PurePath('/etc')
>>> os.fspath(p)
'/etc'

A representação de string de um caminho é o próprio caminho do sistema de arquivos bruto (na forma nativa, por exemplo, com contrabarras no Windows), que você pode passar para qualquer função usando um caminho de arquivo como uma string:

>>> p = PurePath('/etc')
>>> str(p)
'/etc'
>>> p = PureWindowsPath('c:/Program Files')
>>> str(p)
'c:\\Program Files'

Da mesma forma, chamar bytes em um caminho fornece o caminho do sistema de arquivos bruto como um objeto bytes, codificado por os.fsencode():

>>> bytes(p)
b'/etc'

Nota

A chamada de bytes só é recomendada no Unix. No Windows, a forma Unicode é a representação canônica dos caminhos do sistema de arquivos.

11.1.2.3. Acessando partes individuais¶

Para acessar as “partes” individuais (componentes) de um caminho, use a seguinte propriedade:

PurePath.parts¶

Uma tupla que dá acesso aos vários componentes do caminho:

>>> p = PurePath('/usr/bin/python3')
>>> p.parts
('/', 'usr', 'bin', 'python3')

>>> p = PureWindowsPath('c:/Program Files/PSF')
>>> p.parts
('c:\\', 'Program Files', 'PSF')

(observe como a unidade e a raiz local são reagrupadas em uma única parte)

11.1.2.4. Métodos e propriedades¶

Caminhos puros fornecem os seguintes métodos e propriedades:

PurePath.drive¶

Uma string que representa a letra ou nome da unidade, se houver:

>>> PureWindowsPath('c:/Program Files/').drive
'c:'
>>> PureWindowsPath('/Program Files/').drive
''
>>> PurePosixPath('/etc').drive
''

Os compartilhamentos UNC também são considerados unidades:

>>> PureWindowsPath('//host/share/foo.txt').drive
'\\\\host\\share'

PurePath.root¶

Uma string que representa a raiz (local ou global), se houver:

>>> PureWindowsPath('c:/Program Files/').root
'\\'
>>> PureWindowsPath('c:Program Files/').root
''
>>> PurePosixPath('/etc').root
'/'

Os compartilhamentos UNC sempre têm uma raiz:

>>> PureWindowsPath('//host/share').root
'\\'

PurePath.anchor¶

A concatenação da unidade e da raiz:

>>> PureWindowsPath('c:/Program Files/').anchor
'c:\\'
>>> PureWindowsPath('c:Program Files/').anchor
'c:'
>>> PurePosixPath('/etc').anchor
'/'
>>> PureWindowsPath('//host/share').anchor
'\\\\host\\share\\'

PurePath.parents¶

Uma sequência imutável que fornece acesso aos ancestrais lógicos do caminho:

>>> p = PureWindowsPath('c:/foo/bar/setup.py')
>>> p.parents[0]
PureWindowsPath('c:/foo/bar')
>>> p.parents[1]
PureWindowsPath('c:/foo')
>>> p.parents[2]
PureWindowsPath('c:/')

PurePath.parent¶

O pai lógico do caminho:

>>> p = PurePosixPath('/a/b/c/d')
>>> p.parent
PurePosixPath('/a/b/c')

Você não pode passar por uma âncora ou caminho vazio:

>>> p = PurePosixPath('/')
>>> p.parent
PurePosixPath('/')
>>> p = PurePosixPath('.')
>>> p.parent
PurePosixPath('.')

Nota

Esta é uma operação puramente lexical, daí o seguinte comportamento:

>>> p = PurePosixPath('foo/..')
>>> p.parent
PurePosixPath('foo')

Se você quiser percorrer um caminho de sistema de arquivos arbitrário para cima, é recomendado primeiro chamar Path.resolve() para resolver links simbólicos e eliminar componentes “..”.

PurePath.name¶

Uma string que representa o componente do caminho final, excluindo a unidade e a raiz, se houver:

>>> PurePosixPath('my/library/setup.py').name
'setup.py'

Nomes de unidades UNC não são considerados::

>>> PureWindowsPath('//some/share/setup.py').name
'setup.py'
>>> PureWindowsPath('//some/share').name
''

PurePath.suffix¶

A extensão do arquivo do componente final, se houver:

>>> PurePosixPath('my/library/setup.py').suffix
'.py'
>>> PurePosixPath('my/library.tar.gz').suffix
'.gz'
>>> PurePosixPath('my/library').suffix
''

PurePath.suffixes¶

Uma lista das extensões de arquivo do caminho:

>>> PurePosixPath('my/library.tar.gar').suffixes
['.tar', '.gar']
>>> PurePosixPath('my/library.tar.gz').suffixes
['.tar', '.gz']
>>> PurePosixPath('my/library').suffixes
[]

PurePath.stem¶

O componente final do caminho, sem seu sufixo:

>>> PurePosixPath('my/library.tar.gz').stem
'library.tar'
>>> PurePosixPath('my/library.tar').stem
'library'
>>> PurePosixPath('my/library').stem
'library'

PurePath.as_posix()¶

Retorna uma representação de string do caminho com barras (/):

>>> p = PureWindowsPath('c:\\windows')
>>> str(p)
'c:\\windows'
>>> p.as_posix()
'c:/windows'

PurePath.as_uri()¶

Representa o caminho como um URI de file. ValueError é levantada se o caminho não for absoluto.

>>> p = PurePosixPath('/etc/passwd')
>>> p.as_uri()
'file:///etc/passwd'
>>> p = PureWindowsPath('c:/Windows')
>>> p.as_uri()
'file:///c:/Windows'

PurePath.is_absolute()¶

Retorna se o caminho é absoluto ou não. Um caminho é considerado absoluto se tiver uma raiz e (se o tipo permitir) uma unidade:

>>> PurePosixPath('/a/b').is_absolute()
True
>>> PurePosixPath('a/b').is_absolute()
False

>>> PureWindowsPath('c:/a/b').is_absolute()
True
>>> PureWindowsPath('/a/b').is_absolute()
False
>>> PureWindowsPath('c:').is_absolute()
False
>>> PureWindowsPath('//some/share').is_absolute()
True

PurePath.is_reserved()¶

Com PureWindowsPath, retorna True se o caminho é considerado reservado no Windows, False caso contrário. Com PurePosixPath, False é sempre retornado.

>>> PureWindowsPath('nul').is_reserved()
True
>>> PurePosixPath('nul').is_reserved()
False

As chamadas do sistema de arquivos em caminhos reservados podem falhar misteriosamente ou ter efeitos indesejados.

PurePath.joinpath(*other)¶

Chamar este método é equivalente a combinar o caminho com cada um dos outros argumentos, representados por other:

>>> PurePosixPath('/etc').joinpath('passwd')
PurePosixPath('/etc/passwd')
>>> PurePosixPath('/etc').joinpath(PurePosixPath('passwd'))
PurePosixPath('/etc/passwd')
>>> PurePosixPath('/etc').joinpath('init.d', 'apache2')
PurePosixPath('/etc/init.d/apache2')
>>> PureWindowsPath('c:').joinpath('/Program Files')
PureWindowsPath('c:/Program Files')

PurePath.match(pattern)¶

Compara esse caminho com o padrão de estilo glob fornecido. Retorna True se a correspondência for bem-sucedida, False caso contrário.

Se pattern for relativo, o caminho pode ser relativo ou absoluto, e a correspondência é feita da direita:

>>> PurePath('a/b.py').match('*.py')
True
>>> PurePath('/a/b/c.py').match('b/*.py')
True
>>> PurePath('/a/b/c.py').match('a/*.py')
False

Se pattern for absoluto, o caminho deve ser absoluto e todo o caminho deve corresponder a:

>>> PurePath('/a.py').match('/*.py')
True
>>> PurePath('a/b.py').match('/*.py')
False

As with other methods, case-sensitivity is observed:

>>> PureWindowsPath('b.py').match('*.PY')
True

PurePath.relative_to(*other)¶

Calcula uma versão deste caminho em relação ao caminho representado por other. Se for impossível, ValueError é levantada:

>>> p = PurePosixPath('/etc/passwd')
>>> p.relative_to('/')
PurePosixPath('etc/passwd')
>>> p.relative_to('/etc')
PurePosixPath('passwd')
>>> p.relative_to('/usr')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pathlib.py", line 694, in relative_to
    .format(str(self), str(formatted)))
ValueError: '/etc/passwd' does not start with '/usr'

PurePath.with_name(name)¶

Retorna um novo caminho com o name alterado. Se o caminho original não tiver um nome, ValueError é levantada:

>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.with_name('setup.py')
PureWindowsPath('c:/Downloads/setup.py')
>>> p = PureWindowsPath('c:/')
>>> p.with_name('setup.py')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/antoine/cpython/default/Lib/pathlib.py", line 751, in with_name
    raise ValueError("%r has an empty name" % (self,))
ValueError: PureWindowsPath('c:/') has an empty name

PurePath.with_suffix(suffix)¶

Retorna um novo caminho com o suffix alterado. Se o caminho original não tiver um sufixo, o novo suffixo será anexado. Se o suffix for uma string vazia, o sufixo original será removido:

>>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz')
>>> p.with_suffix('.bz2')
PureWindowsPath('c:/Downloads/pathlib.tar.bz2')
>>> p = PureWindowsPath('README')
>>> p.with_suffix('.txt')
PureWindowsPath('README.txt')
>>> p = PureWindowsPath('README.txt')
>>> p.with_suffix('')
PureWindowsPath('README')

11.1.3. Caminhos Concretos¶

Caminhos concretos são subclasses das classes de caminho puro. Além das operações fornecidas por este último, eles também fornecem métodos para fazer chamadas de sistema em objetos de caminho. Existem três maneiras de instanciar caminhos concretos:

class pathlib.Path(*pathsegments)¶

Uma subclasse de PurePath, esta classe representa caminhos concretos do tipo de caminho do sistema (instanciando-o cria uma PosixPath ou uma WindowsPath):

>>> Path('setup.py')
PosixPath('setup.py')

pathsegments é especificado de forma similar para PurePath.

class pathlib.PosixPath(*pathsegments)¶

Uma subclasse de Path e PurePosixPath, esta classe representa caminhos concretos de sistemas de arquivos não Windows:

>>> PosixPath('/etc')
PosixPath('/etc')

pathsegments é especificado de forma similar para PurePath.

class pathlib.WindowsPath(*pathsegments)¶

Uma subclasse de Path e PureWindowsPath, esta classe representa caminhos concretos de sistemas de arquivos do Windows:

>>> WindowsPath('c:/Program Files/')
WindowsPath('c:/Program Files')

pathsegments é especificado de forma similar para PurePath.

Você só pode instanciar o tipo de classe que corresponde ao seu sistema (permitir chamadas de sistema em tipos de caminho não compatíveis pode levar a bugs ou falhas em sua aplicação):

>>> import os
>>> os.name
'posix'
>>> Path('setup.py')
PosixPath('setup.py')
>>> PosixPath('setup.py')
PosixPath('setup.py')
>>> WindowsPath('setup.py')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pathlib.py", line 798, in __new__
    % (cls.__name__,))
NotImplementedError: cannot instantiate 'WindowsPath' on your system

11.1.3.1. Métodos¶

Concrete paths provide the following methods in addition to pure paths methods. Many of these methods can raise an OSError if a system call fails (for example because the path doesn’t exist):

classmethod Path.cwd()¶

Retorna um novo objeto de caminho que representa o diretório atual (conforme retornado por os.getcwd()):

>>> Path.cwd()
PosixPath('/home/antoine/pathlib')

classmethod Path.home()¶

Retorna um novo objeto de caminho representando o diretório inicial do usuário (conforme retornado por os.path.expanduser() com a construção ~):

>>> Path.home()
PosixPath('/home/antoine')

Novo na versão 3.5.

Path.stat()¶

Return information about this path (similarly to os.stat()). The result is looked up at each call to this method.

>>> p = Path('setup.py')
>>> p.stat().st_size
956
>>> p.stat().st_mtime
1327883547.852554

Path.chmod(mode)¶

Altera o modo de arquivo e as permissões, como os.chmod():

>>> p = Path('setup.py')
>>> p.stat().st_mode
33277
>>> p.chmod(0o444)
>>> p.stat().st_mode
33060

Path.exists()¶

Se o caminho aponta para um arquivo ou diretório existente:

>>> Path('.').exists()
True
>>> Path('setup.py').exists()
True
>>> Path('/etc').exists()
True
>>> Path('nonexistentfile').exists()
False

Nota

Se o caminho aponta para um link simbólico, exists() retorna se o link simbólico aponta para um arquivo ou diretório existente.

Path.expanduser()¶

Retorna um novo caminho com as construções expandidas ~ e ~user, conforme retornado por os.path.expanduser():

>>> p = PosixPath('~/films/Monty Python')
>>> p.expanduser()
PosixPath('/home/eric/films/Monty Python')

Novo na versão 3.5.

Path.glob(pattern)¶

Glob the given pattern in the directory represented by this path, yielding all matching files (of any kind):

>>> sorted(Path('.').glob('*.py'))
[PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib.py')]
>>> sorted(Path('.').glob('*/*.py'))
[PosixPath('docs/conf.py')]

O padrão “**” significa “este diretório e todos os subdiretórios, recursivamente”. Em outras palavras, ele permite fazer glob recursivo:

>>> sorted(Path('.').glob('**/*.py'))
[PosixPath('build/lib/pathlib.py'),
 PosixPath('docs/conf.py'),
 PosixPath('pathlib.py'),
 PosixPath('setup.py'),
 PosixPath('test_pathlib.py')]

Nota

Usar o padrão “**” em grandes árvores de diretório pode consumir uma quantidade excessiva de tempo.

Path.group()¶: Retorna o nome do grupo que possui o arquivo. KeyError é levantada se o gid do arquivo não for encontrado no banco de dados do sistema.

Path.is_dir()¶

Retorna True se o caminho apontar para um diretório (ou um link simbólico apontando para um diretório), False se apontar para outro tipo de arquivo.