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

Uso básico¶

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'

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.

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'

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.

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)

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

Tal como acontece com outros métodos, a distinção entre maiúsculas e minúsculas segue os padrões da plataforma:

>>> PurePosixPath('b.py').match('*.PY')
False
>>> 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')

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

Métodos¶

Caminhos concretos fornecem os seguintes métodos, além dos métodos de caminhos puros. Muitos desses métodos podem levantar uma OSError se uma chamada de sistema falhar (por exemplo, porque o caminho não existe).

Alterado na versão 3.8: exists(), is_dir(), is_file(), is_mount(), is_symlink(), is_block_device(), is_char_device(), is_fifo(), is_socket() agora retornam False em vez de levantar uma exceção para caminhos que contêm caracteres não representáveis no nível do sistema operacional.

classmethod Path.cwd()¶

Retorna um novo objeto 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()¶

Retorna um objeto os.stat_result contendo informações sobre este caminho, como os.stat(). O resultado é consultado em cada chamada para este método.

>>> 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)¶

Faz o glob do pattern relativo fornecido no diretório representado por este caminho, produzindo todos os arquivos correspondentes (de qualquer tipo):

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

False também é retornado se o caminho não existir ou se for um link simbólico quebrado; outros erros (como erros de permissão) são propagados.

Path.is_file()¶

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

False também é retornado se o caminho não existir ou se for um link simbólico quebrado; outros erros (como erros de permissão) são propagados.

Path.is_mount()¶: Retorna True se o caminho for um ponto de montagem: um ponto em um sistema de arquivos onde um sistema de arquivos diferente foi montado. No POSIX, a função verifica se o pai do path, path/.., está em um dispositivo diferente de path, ou se path/.. e path apontam para o mesmo nó-i no mesmo dispositivo – isso deve detectar pontos de montagem para todas as variantes Unix e POSIX. Não implementado no Windows.

Novo na versão 3.7.

Path.is_symlink()¶

Retorna True se o caminho apontar para um link simbólico, False caso contrário.

False também é retornado se o caminho não existir; outros erros (como erros de permissão) são propagados.

Path.is_socket()¶

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

False também é retornado se o caminho não existir ou se for um link simbólico quebrado; outros erros (como erros de permissão) são propagados.

Path.is_fifo()¶

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

False também é retornado se o caminho não existir ou se for um link simbólico quebrado; outros erros (como erros de permissão) são propagados.

Path.is_block_device()¶

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

False também é retornado se o caminho não existir ou se for um link simbólico quebrado; outros erros (como erros de permissão) são propagados.

Path.is_char_device()¶

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

False também é retornado se o caminho não existir ou se for um link simbólico quebrado; outros erros (como erros de permissão) são propagados.

Path.iterdir()¶

Quando o caminho aponta para um diretório, produz objetos caminho do conteúdo do diretório:

>>> p = Path('docs')
>>> for child in p.iterdir(): child
...
PosixPath('docs/conf.py')
PosixPath('docs/_templates')
PosixPath('docs/make.bat')
PosixPath('docs/index.rst')
PosixPath('docs/_build')
PosixPath('docs/_static')
PosixPath('docs/Makefile')

Os filhos são produzidos em ordem arbitrária, e as entradas especiais '.' e '..' não são incluídas. Se um arquivo for removido ou adicionado ao diretório após a criação do iterador, não é especificado se um objeto caminho para esse arquivo deve ser incluído.

Path.lchmod(mode)¶: Como Path.chmod(), mas, se o caminho apontar para um link simbólico, o modo do link simbólico é alterado ao invés de seu alvo.

Path.lstat()¶: Como Path.stat(), mas, se o caminho apontar para um link simbólico, retorna as informações do link simbólico ao invés de seu alvo.

Path.mkdir(mode=0o777, parents=False, exist_ok=False)¶

Cria um novo diretório neste caminho fornecido. Se mode for fornecido, ele é combinado com o valor umask do processo para determinar o modo do arquivo e os sinalizadores de acesso. Se o caminho já existe, FileExistsError é levantada.

Se parents for verdadeiro, quaisquer pais ausentes neste caminho serão criados conforme necessário; eles são criados com as permissões padrão sem levar o mode em consideração (imitando o comando POSIX mkdir -p).

Se parents for falso (o padrão), um pai ausente levanta FileNotFoundError.

Se exist_ok for falso (o padrão), FileExistsError será levantada se o diretório alvo já existir.

Se exist_ok for verdadeiro, as exceções FileExistsError serão ignoradas (mesmo comportamento que o comando POSIX mkdir -p), mas apenas se o último componente do caminho não for um arquivo existente não pertencente ao diretório.

Alterado na versão 3.5: O parâmetro exist_ok foi adicionado.

Path.open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)¶

Abre o arquivo apontado pelo caminho, como a função embutida open() faz:

>>> p = Path('setup.py')
>>> with p.open() as f:
...     f.readline()
...
'#!/usr/bin/env python3\n'

Path.owner()¶: Retorna o nome do usuário que possui o arquivo. KeyError é levantada se o uid do arquivo não for encontrado no banco de dados do sistema.

Path.read_bytes()¶

Retorna o conteúdo binário do arquivo apontado como um objeto bytes:

>>> p = Path('my_binary_file')
>>> p.write_bytes(b'Binary file contents')
20
>>> p.read_bytes()
b'Binary file contents'

Novo na versão 3.5.

Path.read_text(encoding=None, errors=None)¶

Retorna o conteúdo decodificado do arquivo apontado como uma string:

>>> p = Path('my_text_file')
>>> p.write_text('Text file contents')
18
>>> p.read_text()
'Text file contents'

O arquivo é aberto e, então, fechado. Os parâmetros opcionais têm o mesmo significado que em open().

Novo na versão 3.5.

Path.rename(target)¶

Renomeia este arquivo ou diretório para o target fornecido e retorna uma nova instância de Path apontando para target. No Unix, se target existir e for um arquivo, ele será substituído silenciosamente se o usuário tiver permissão. target pode ser uma string ou outro objeto de caminho:

>>> p = Path('foo')
>>> p.open('w').write('some text')
9
>>> target = Path('bar')
>>> p.rename(target)
PosixPath('bar')
>>> target.open().read()
'some text'

O caminho de destino pode ser absoluto ou relativo. Caminhos relativos são interpretados em relação ao diretório de trabalho atual, não ao diretório do objeto Path.

Alterado na versão 3.8: Adicionado valor de retorno, returna a nova instância de Path.

Path.replace(target)¶

Renomeia este arquivo ou diretório para o target fornecido e retorna uma nova instância de Path apontando para target. Se target apontar para um arquivo ou diretório existente, ele será substituído incondicionalmente.

O caminho de destino pode ser absoluto ou relativo. Caminhos relativos são interpretados em relação ao diretório de trabalho atual, não ao diretório do objeto Path.

Alterado na versão 3.8: Adicionado valor de retorno, returna a nova instância de Path.

Path.resolve(strict=False)¶

Faça o caminho absoluto, resolvendo quaisquer links simbólicos. Um novo objeto de caminho é retornado:

>>> p = Path()
>>> p
PosixPath('.')
>>> p.resolve()
PosixPath('/home/antoine/pathlib')

Componentes “..” também são eliminados (este é o único método para fazer isso):

>>> p = Path('docs/../setup.py')
>>> p.resolve()
PosixPath('/home/antoine/pathlib/setup.py')

Se o caminho não existe e strict é True, FileNotFoundError é levantada. Se strict for False, o caminho será resolvido tanto quanto possível e qualquer resto é anexado sem verificar se existe. Se um laço infinito for encontrado ao longo do caminho de resolução, RuntimeError é levantada.

Novo na versão 3.6: O argumento strict (comportamento pré-3.6 é estrito).

Path.rglob(pattern)¶

É como chamar Path.glob() com “**/” adicionado na frente do pattern relativo fornecido:

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

Path.rmdir()¶: Remove este diretório. O diretório deve estar vazio.

Path.samefile(other_path)¶

Retorna se este path apontar para o mesmo arquivo como other_path, que pode ser um objeto PATH ou uma String. A semântica é semelhante a função os.path.samefile() e a função os.path.samestat().

Um OSError poderá ser levantado caso algum arquivo não puder ser acessado por alguma razão.

>>> p = Path('spam')
>>> q = Path('eggs')
>>> p.samefile(q)
False
>>> p.samefile('spam')
True

Novo na versão 3.5.

Path.symlink_to(target, target_is_directory=False)¶

Faz deste path um link simbólico para target. No Windows, target_is_directory deverá ser verdadeiro (padrão False) se o local do link for um diretório. Num sistema POSIX, o valor target_is_directory será ignorado.

>>> p = Path('mylink')
>>> p.symlink_to('setup.py')
>>> p.resolve()
PosixPath('/home/antoine/pathlib/setup.py')
>>> p.stat().st_size
956
>>> p.lstat().st_size
8

Nota

A ordem dos argumentos (link, target) é o inverso da função os.symlink()’s.

Path.link_to(target)¶: Faz do target um link físico para este caminho.

Aviso

Esta função não faz deste caminho um link físico para target, apesar da implicação dos nomes da função e do argumento. A ordem do argumento (target, link) é o reverso de Path.symlink_to(), mas corresponde ao de os.link().

Novo na versão 3.8.

Path.touch(mode=0o666, exist_ok=True)¶: Cria um arquivo neste caminho especifico. Caso o modo for dado, ele será combinado com o valor do processo umask para determinar o modo de arquivo e as flags de acesso. Se o arquivo já existir, a função será bem-sucedida se exist_ok for verdadeiro (e o tempo de modificação for atualizado para a hora atual), caso contrário a exceção FileExistsError será levantada.

Path.unlink(missing_ok=False)¶

Remova esse arquivo ou link simbólico. Caso o caminho aponte para um diretório, use a função Path.rmdir() em vez disso.

Se missing_ok for falso (o padrão), FileNotFoundError é levantada se o caminho não existir.

Se missing_ok for verdadeiro, exceções de FileNotFoundError serão ignoradas (mesmo comportamento que o comando POSIX rm -f).

Alterado na versão 3.8: O parâmetro missing_ok foi adicionado.

Path.write_bytes(data)¶

Abre o arquivo apontado no modo bytes, escreve dados e fecha o arquivo:

>>> p = Path('my_binary_file')
>>> p.write_bytes(b'Binary file contents')
20
>>> p.read_bytes()
b'Binary file contents'

Um arquivo existente de mesmo nome será substituído.

Novo na versão 3.5.

Path.write_text(data, encoding=None, errors=None)¶

Abre o arquivo apontado no modo de texto, escreve data e fecha o arquivo:

>>> p = Path('my_text_file')
>>> p.write_text('Text file contents')
18
>>> p.read_text()
'Text file contents'

Um arquivo existente com o mesmo nome é sobrescrito. Os parâmetros opcionais têm o mesmo significado que em open().

Novo na versão 3.5.

Correspondência a ferramentas no módulo `os`¶

Abaixo está uma tabela mapeando várias funções os a sua PurePath/Path equivalente.

Nota

Embora os.path.relpath() e PurePath.relative_to() tenham alguns casos de uso sobrepostos, sua semântica difere o suficiente para garantir não considerá-los equivalentes.

os e os.path	pathlib
`os.path.abspath()`	`Path.resolve()`
`os.chmod()`	`Path.chmod()`
`os.mkdir()`	`Path.mkdir()`
`os.rename()`	`Path.rename()`
`os.replace()`	`Path.replace()`
`os.rmdir()`	`Path.rmdir()`
`os.remove()`, `os.unlink()`	`Path.unlink()`
`os.getcwd()`	`Path.cwd()`
`os.path.exists()`	`Path.exists()`
`os.path.expanduser()`	`Path.expanduser()` and `Path.home()`
`os.listdir()`	`Path.iterdir()`
`os.path.isdir()`	`Path.is_dir()`
`os.path.isfile()`	`Path.is_file()`
`os.path.islink()`	`Path.is_symlink()`
`os.link()`	`Path.link_to()`
`os.symlink()`	`Path.symlink_to()`
`os.stat()`	`Path.stat()`, `Path.owner()`, `Path.group()`
`os.path.isabs()`	`PurePath.is_absolute()`
`os.path.join()`	`PurePath.joinpath()`
`os.path.basename()`	`PurePath.name`
`os.path.dirname()`	`PurePath.parent`
`os.path.samefile()`	`Path.samefile()`
`os.path.splitext()`	`PurePath.suffix`

`pathlib` — Caminhos do sistema de arquivos orientados a objetos¶

Uso básico¶

Caminhos puros¶

Propriedades gerais¶

Operadores¶

Acessando partes individuais¶

Métodos e propriedades¶

Caminhos concretos¶

Métodos¶

Correspondência a ferramentas no módulo `os`¶

Tabela de Conteúdo

Tópico anterior

Próximo tópico

Essa Página

pathlib — Caminhos do sistema de arquivos orientados a objetos¶

Uso básico¶

Caminhos puros¶

Propriedades gerais¶

Operadores¶

Acessando partes individuais¶

Métodos e propriedades¶

Caminhos concretos¶

Métodos¶

Correspondência a ferramentas no módulo os¶

`pathlib` — Caminhos do sistema de arquivos orientados a objetos¶

Correspondência a ferramentas no módulo `os`¶