pathlib
— Caminhos do sistema de arquivos orientados a objetos¶
Adicionado na versão 3.4.
Código-fonte: Lib/pathlib/
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 instanciarPureWindowsPath
.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'
Exceções¶
- exception pathlib.UnsupportedOperation¶
Uma exceção herdada de
NotImplementedError
que é levantada quando uma operação não suportada é chamada em um objeto caminho.Adicionado na versão 3.13.
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 umaPureWindowsPath
):>>> 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 que retorna uma string ou um objeto implementando a interface
os.PathLike
, onde o método__fspath__()
retorna uma string, como 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('.')
Se um segmento for um caminho absoluto, todos os segmentos anteriores serão ignorados (como
os.path.join()
):>>> PurePath('/etc', '/usr', 'lib64') PurePosixPath('/usr/lib64') >>> PureWindowsPath('c:/Windows', 'd:bar') PureWindowsPath('d:bar')
No Windows, a unidade não é redefinida quando um segmento de caminho relativo enraizado (por exemplo,
r'\foo'
) é encontrado:>>> PureWindowsPath('c:/Windows', '/Program Files') PureWindowsPath('c:/Program Files')
Barras espúrias e pontos simples são recolhidos, mas pontos duplos (
'..'
) e barras duplas iniciais ('//'
) não são, pois isso mudaria o significado de um caminho por vários motivos (por exemplo, links simbólicos, caminhos UNC):>>> PurePath('foo//bar') PurePosixPath('foo/bar') >>> 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 aPurePosixPath('bar')
, o que é errado sefoo
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/hosts') PurePosixPath('/etc/hosts')
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, incluindo Caminhos UNC:>>> PureWindowsPath('c:/', 'Users', 'Ximénez') PureWindowsPath('c:/Users/Ximénez') >>> PureWindowsPath('//server/share/file') PureWindowsPath('//server/share/file')
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, como os.path.join()
. Se o argumento for um caminho absoluto, o caminho anterior será ignorado. No Windows, a unidade não é redefinida quando o argumento é um caminho relativo enraizado (por exemplo, r'\foo'
):
>>> p = PurePath('/etc')
>>> p
PurePosixPath('/etc')
>>> p / 'init.d' / 'apache2'
PurePosixPath('/etc/init.d/apache2')
>>> q = PurePath('bin')
>>> '/usr' / q
PurePosixPath('/usr/bin')
>>> p / '/an_absolute_path'
PurePosixPath('/an_absolute_path')
>>> PureWindowsPath('c:/Windows', '/Program Files')
PureWindowsPath('c:/Program Files')
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.parser¶
A implementação do módulo
os.path
usado para análise e junção de caminhos de baixo nível:posixpath
ountpath
.Adicionado na versão 3.13.
- 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 '\\'
Se o caminho começa com mais de duas barras sucessivas,
PurePosixPath
as recolhe:>>> PurePosixPath('//etc').root '//' >>> PurePosixPath('///etc').root '/' >>> PurePosixPath('////etc').root '/'
Nota
Este comportamento está em conformidade com o parágrafo 4.11 Pathname Resolution do The Open Group Base Specifications Issue 6:
“Um nome de caminho que começa com duas barras sucessivas pode ser interpretado de maneira definida pela implementação, embora mais de duas barras iniciais devam ser tratadas como uma única barra.”
- 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:/')
Alterado na versão 3.10: A sequência pai agora tem suporte fatias e valores de índice negativos.
- 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ê deseja percorrer um caminho arbitrário do sistema de arquivos para cima, é recomendável primeiro chamar
Path.resolve()
para resolver os links simbólicos e eliminar os 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 última parte separada por pontos do componente final, se houver:
>>> PurePosixPath('my/library/setup.py').suffix '.py' >>> PurePosixPath('my/library.tar.gz').suffix '.gz' >>> PurePosixPath('my/library').suffix ''
Isso é comumente chamado de extensão de arquivo.
Alterado na versão 3.14: A single dot (”
.
”) is considered a valid suffix.
- PurePath.suffixes¶
Uma lista dos sufixos do caminho, com frequência chamados de extensões de arquivo:
>>> PurePosixPath('my/library.tar.gar').suffixes ['.tar', '.gar'] >>> PurePosixPath('my/library.tar.gz').suffixes ['.tar', '.gz'] >>> PurePosixPath('my/library').suffixes []
Alterado na versão 3.14: A single dot (”
.
”) is considered a valid suffix.
- 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.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_relative_to(other)¶
Retorna se este caminho é ou não relativo a outro caminho, representado por other.
>>> p = PurePath('/etc/passwd') >>> p.is_relative_to('/etc') True >>> p.is_relative_to('/usr') False
Este método é baseado em string; ele não acessa o sistema de arquivos nem trata segmentos “
..
” especialmente. O código a seguir é equivalente:>>> u = PurePath('/usr') >>> u == p or u in p.parents False
Adicionado na versão 3.9.
Deprecated since version 3.12, removed in version 3.14: A passagem de argumentos adicionais está descontinuada; se fornecidos, eles são unidos com other.
- PurePath.is_reserved()¶
Com
PureWindowsPath
, retornaTrue
se o caminho é considerado reservado no Windows,False
caso contrário. ComPurePosixPath
,False
é sempre retornado.Alterado na versão 3.13: Nomes de caminho do Windows que contêm dois pontos, ou terminam com um ponto ou um espaço, são considerados reservados. Caminhos UNC podem ser reservados.
Deprecated since version 3.13, will be removed in version 3.15: Este método está descontinuado; use
os.path.isreserved()
para detectar caminhos reservados no Windows.
- PurePath.joinpath(*pathsegments)¶
Chamar este método é equivalente a combinar o caminho com cada um dos pathsegments por vez:
>>> 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.full_match(pattern, *, case_sensitive=None)¶
Compara esse caminho com o padrão de estilo glob fornecido. Retorna
True
se a correspondência for bem-sucedida,False
caso contrário. Por exemplo:>>> PurePath('a/b.py').full_match('a/*.py') True >>> PurePath('a/b.py').full_match('*.py') False >>> PurePath('/a/b/c.py').full_match('/a/**') True >>> PurePath('/a/b/c.py').full_match('**/*.py') True
Ver também
Documentação de Pattern language.
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').full_match('*.PY') False >>> PureWindowsPath('b.py').full_match('*.PY') True
Defina case_sensitive como
True
ouFalse
para substituir esse comportamento.Adicionado na versão 3.13.
- PurePath.match(pattern, *, case_sensitive=None)¶
Compara esse caminho com o padrão no recursivo de estilo glob fornecido. Retorna
True
se a correspondência for bem-sucedida,False
caso contrário.Este método é semelhante a
full_match()
, mas padrões vazios não são permitidos (ValueError
é levantada), o curinga recursivo “**
” não é suportado (ele age como o “*
” não recursivo) e, se um padrão relativo for fornecido, a correspondência será 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
Alterado na versão 3.12: O parâmetro pattern aceita um objeto caminho ou similar.
Alterado na versão 3.12: O parâmetro case_sensitive foi adicionado.
- PurePath.relative_to(other, walk_up=False)¶
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 941, in relative_to raise ValueError(error_message.format(str(self), str(formatted))) ValueError: '/etc/passwd' is not in the subpath of '/usr' OR one path is relative and the other is absolute.
Quando walk_up é falso (o padrão), o caminho deve começar com other. Quando o argumento é verdadeiro, entradas
..
podem ser adicionadas para formar o caminho relativo. Em todos os outros casos, como os caminhos que fazem referência a unidades diferentes,ValueError
é levantada.:>>> p.relative_to('/usr', walk_up=True) PurePosixPath('../etc/passwd') >>> p.relative_to('foo', walk_up=True) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "pathlib.py", line 941, in relative_to raise ValueError(error_message.format(str(self), str(formatted))) ValueError: '/etc/passwd' is not on the same drive as 'foo' OR one path is relative and the other is absolute.
Aviso
Esta função faz parte de
PurePath
e funciona com strings. Ela não verifica ou acessa a estrutura do arquivo subjacente. Isso pode impactar a opção walk_up, pois ela presume que não há links simbólicos presentes no caminho; chameresolve()
primeiro se necessário para resolver links simbólicos.Alterado na versão 3.12: O parâmetro walk_up foi adicionado (o comportamento antigo é o mesmo de
walk_up=False
).Deprecated since version 3.12, removed in version 3.14: A passagem de argumentos posicionais adicionais está descontinuada; se fornecidos, eles são unidos com other.
- 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_stem(stem)¶
Retorna um novo caminho com o
stem
alterado. Se o caminho original não tiver um nome, ValueError é levantada:>>> p = PureWindowsPath('c:/Downloads/draft.txt') >>> p.with_stem('final') PureWindowsPath('c:/Downloads/final.txt') >>> p = PureWindowsPath('c:/Downloads/pathlib.tar.gz') >>> p.with_stem('lib') PureWindowsPath('c:/Downloads/lib.gz') >>> p = PureWindowsPath('c:/') >>> p.with_stem('') Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/home/antoine/cpython/default/Lib/pathlib.py", line 861, in with_stem return self.with_name(stem + self.suffix) File "/home/antoine/cpython/default/Lib/pathlib.py", line 851, in with_name raise ValueError("%r has an empty name" % (self,)) ValueError: PureWindowsPath('c:/') has an empty name
Adicionado na versão 3.9.
- 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')
Alterado na versão 3.14: A single dot (”
.
”) is considered a valid suffix. In previous versions,ValueError
is raised if a single dot is supplied.
- PurePath.with_segments(*pathsegments)¶
Cria um novo objeto caminho do mesmo tipo combinando os pathsegments fornecidos. Este método é chamado sempre que um caminho derivado é criado, como de
parent
erelative_to()
. Subclasses podem substituir este método para passar informações para caminhos derivados, por exemplo:from pathlib import PurePosixPath class MyPath(PurePosixPath): def __init__(self, *pathsegments, session_id): super().__init__(*pathsegments) self.session_id = session_id def with_segments(self, *pathsegments): return type(self)(*pathsegments, session_id=self.session_id) etc = MyPath('/etc', session_id=42) hosts = etc / 'hosts' print(hosts.session_id) # 42
Adicionado na versão 3.12.
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 umaPosixPath
ou umaWindowsPath
):>>> Path('setup.py') PosixPath('setup.py')
pathsegments é especificado de forma similar para
PurePath
.
- class pathlib.PosixPath(*pathsegments)¶
Uma subclasse de
Path
ePurePosixPath
, esta classe representa caminhos concretos de sistemas de arquivos não Windows:>>> PosixPath('/etc/hosts') PosixPath('/etc/hosts')
pathsegments é especificado de forma similar para
PurePath
.Alterado na versão 3.13: Levanta
UnsupportedOperation
no Windows. Em versões anteriores,NotImplementedError
era levantada em vez disso.
- class pathlib.WindowsPath(*pathsegments)¶
Uma subclasse de
Path
ePureWindowsPath
, esta classe representa caminhos concretos de sistemas de arquivos do Windows:>>> WindowsPath('c:/', 'Users', 'Ximénez') WindowsPath('c:/Users/Ximénez')
pathsegments é especificado de forma similar para
PurePath
.Alterado na versão 3.13: Levanta
UnsupportedOperation
em plataformas não-Windows. Em versões anteriores,NotImplementedError
era levantada em vez disso.
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__,))
UnsupportedOperation: cannot instantiate 'WindowsPath' on your system
Alguns métodos de caminho concretos podem levantar um OSError
se uma chamada de sistema falhar (por exemplo, porque o caminho não existe).
Analisando e gerando URIs¶
Objetos caminho concretos podem ser criados e representados como URIs de ‘file’ em conformidade com RFC 8089.
Nota
URIs de arquivos não são portáteis entre máquinas com diferentes codificações de sistema de arquivos.
- classmethod Path.from_uri(uri)¶
Retorna um novo objeto de caminho a partir da análise sintática de um URI ‘file’. Por exemplo:
>>> p = Path.from_uri('file:///etc/hosts') PosixPath('/etc/hosts')
No Windows, os caminhos do dispositivo DOS e UNC podem ser analisados a partir de URIs:
>>> p = Path.from_uri('file:///c:/windows') WindowsPath('c:/windows') >>> p = Path.from_uri('file://server/share') WindowsPath('//server/share')
Várias formas variantes são suportadas:
>>> p = Path.from_uri('file:////server/share') WindowsPath('//server/share') >>> p = Path.from_uri('file://///server/share') WindowsPath('//server/share') >>> p = Path.from_uri('file:c:/windows') WindowsPath('c:/windows') >>> p = Path.from_uri('file:/c|/windows') WindowsPath('c:/windows')
ValueError
é levantada se o URI não começar comfile:
ou se o caminho analisado não for absoluto.Adicionado na versão 3.13.
- Path.as_uri()¶
Representa o caminho como um URI ‘file’.
ValueError
é levantada se o caminho não for absoluto.>>> p = PosixPath('/etc/passwd') >>> p.as_uri() 'file:///etc/passwd' >>> p = WindowsPath('c:/Windows') >>> p.as_uri() 'file:///c:/Windows'
Por razões históricas, esse método também está disponível em objetos
PurePath
. No entanto, seu uso deos.fsencode()
o torna estritamente impuro.
Expandindo e resolvendo caminhos¶
- classmethod Path.home()¶
Retorna um novo objeto caminho representando o diretório pessoal do usuário (conforme retornado por
os.path.expanduser()
com a construção~
). Se o diretório pessoal não puder ser resolvido,RuntimeError
é levantada.>>> Path.home() PosixPath('/home/antoine')
Adicionado na versão 3.5.
- Path.expanduser()¶
Retorna um novo caminho com as construções
~
e~user
expandidas, como retornado poros.path.expanduser()
. Se um diretório pessoal não puder ser resolvido,RuntimeError
é levantada.>>> p = PosixPath('~/films/Monty Python') >>> p.expanduser() PosixPath('/home/eric/films/Monty Python')
Adicionado na versão 3.5.
- 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')
- Path.absolute()¶
Torna o caminho absoluto, sem normalização ou resolução de links simbólicos. Retorna um novo objeto de caminho:
>>> p = Path('tests') >>> p PosixPath('tests') >>> p.absolute() PosixPath('/home/antoine/pathlib/tests')
- 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 um caminho não existe ou um laço de link simbólico é encontrado, e strict é
True
,OSError
é levantada. Se strict forFalse
, o caminho será resolvido tanto quanto possível e qualquer resto é anexado sem verificar se existe.Alterado na versão 3.6: O parâmetro strict foi adicionado (comportamento pré-3.6 é estrito).
Alterado na versão 3.13: Os laços em link simbólico são tratados como outros erros:
OSError
é levantada no modo estrito, e nenhuma exceção é levantada no modo não estrito. Em versões anteriores,RuntimeError
é levantada não importando o valor de strict.
- Path.readlink()¶
Retorna o caminho para o qual o link simbólico aponta (conforme retornado por
os.readlink()
):>>> p = Path('mylink') >>> p.symlink_to('setup.py') >>> p.readlink() PosixPath('setup.py')
Adicionado na versão 3.9.
Alterado na versão 3.13: Levanta
UnsupportedOperation
seos.readlink()
não estiver disponível. Em versões anteriores,NotImplementedError
era levantada.
Consultando tipo de arquivo e status¶
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()
now return False
instead of raising an exception for paths that contain characters
unrepresentable at the OS level.
Alterado na versão 3.14: The methods given above now return False
instead of raising any
OSError
exception from the operating system. In previous versions,
some kinds of OSError
exception are raised, and others suppressed.
The new behaviour is consistent with os.path.exists()
,
os.path.isdir()
, etc. Use stat()
to retrieve the file
status without suppressing exceptions.
- Path.stat(*, follow_symlinks=True)¶
Retorna um objeto
os.stat_result
contendo informações sobre este caminho, comoos.stat()
. O resultado é consultado em cada chamada para este método.Este método normalmente segue links simbólicos; para obter estado de um link simbólico, adicione o argumento
follow_symlinks=False
, ou uselstat()
.>>> p = Path('setup.py') >>> p.stat().st_size 956 >>> p.stat().st_mtime 1327883547.852554
Alterado na versão 3.10: O parâmetro follow_symlinks foi adicionado.
- 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.exists(*, follow_symlinks=True)¶
Return
True
if the path points to an existing file or directory.False
will be returned if the path is invalid, inaccessible or missing. UsePath.stat()
to distinguish between these cases.Este método normalmente segue links simbólicos; para verificar se um link simbólico existe, adicione o argumento
follow_symlinks=False
.>>> Path('.').exists() True >>> Path('setup.py').exists() True >>> Path('/etc').exists() True >>> Path('nonexistentfile').exists() False
Alterado na versão 3.12: O parâmetro follow_symlinks foi adicionado.
- Path.is_file(*, follow_symlinks=True)¶
Return
True
if the path points to a regular file.False
will be returned if the path is invalid, inaccessible or missing, or if it points to something other than a regular file. UsePath.stat()
to distinguish between these cases.Este método normalmente segue links simbólicos; para excluir links simbólicos, adicione o argumento
follow_symlinks=False
.Alterado na versão 3.13: O parâmetro follow_symlinks foi adicionado.
- Path.is_dir(*, follow_symlinks=True)¶
Return
True
if the path points to a directory.False
will be returned if the path is invalid, inaccessible or missing, or if it points to something other than a directory. UsePath.stat()
to distinguish between these cases.Este método normalmente segue links simbólicos; para excluir links simbólicos para diretórios, adicione o argumento
follow_symlinks=False
.Alterado na versão 3.13: O parâmetro follow_symlinks foi adicionado.
- Path.is_symlink()¶
Return
True
if the path points to a symbolic link, even if that symlink is broken.False
will be returned if the path is invalid, inaccessible or missing, or if it points to something other than a symbolic link. UsePath.stat()
to distinguish between these cases.
- Path.is_junction()¶
Retorna
True
se o caminho apontar para uma junção, eFalse
para qualquer outro tipo de arquivo. Atualmente, apenas o Windows dá suporte a junções.Adicionado na versão 3.12.
- 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 sepath/..
e path apontam para o mesmo nó-i no mesmo dispositivo – isso deve detectar pontos de montagem para todas as variantes Unix e POSIX. No Windows, um ponto de montagem é considerado uma raiz de letra de unidade (por exemplo,c:\
), um compartilhamento UNC (por exemplo,\\server\share
) ou um diretório de sistema de arquivos montado.Adicionado na versão 3.7.
Alterado na versão 3.12: Suporte ao Windows foi adicionado.
- Path.is_socket()¶
Return
True
if the path points to a Unix socket.False
will be returned if the path is invalid, inaccessible or missing, or if it points to something other than a Unix socket. UsePath.stat()
to distinguish between these cases.
- Path.is_fifo()¶
Return
True
if the path points to a FIFO.False
will be returned if the path is invalid, inaccessible or missing, or if it points to something other than a FIFO. UsePath.stat()
to distinguish between these cases.
- Path.is_block_device()¶
Return
True
if the path points to a block device.False
will be returned if the path is invalid, inaccessible or missing, or if it points to something other than a block device. UsePath.stat()
to distinguish between these cases.
- Path.is_char_device()¶
Return
True
if the path points to a character device.False
will be returned if the path is invalid, inaccessible or missing, or if it points to something other than a character device. UsePath.stat()
to distinguish between these cases.
- 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çãoos.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
Adicionado na versão 3.5.
Lendo e escrevendo arquivos¶
- 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.read_text(encoding=None, errors=None, newline=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()
.Adicionado na versão 3.5.
Alterado na versão 3.13: O parâmetro newline foi adicionado.
- 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'
Adicionado na versão 3.5.
- Path.write_text(data, encoding=None, errors=None, newline=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()
.Adicionado na versão 3.5.
Alterado na versão 3.10: O parâmetro newline 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.
Adicionado na versão 3.5.
Lendo diretórios¶
- 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 gerados 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 está especificado se um objeto caminho para esse arquivo é incluído.Se o caminho não for um diretório ou estiver inacessível,
OSError
será levantada.
- Path.scandir()¶
When the path points to a directory, return an iterator of
os.DirEntry
objects corresponding to entries in the directory. The returned iterator supports the context manager protocol. It is implemented usingos.scandir()
and gives the same guarantees.Using
scandir()
instead ofiterdir()
can significantly increase the performance of code that also needs file type or file attribute information, becauseos.DirEntry
objects expose this information if the operating system provides it when scanning a directory.The following example displays the names of subdirectories. The
entry.is_dir()
check will generally not make an additional system call:>>> p = Path('docs') >>> with p.scandir() as entries: ... for entry in entries: ... if entry.is_dir(): ... entry.name ... '_templates' '_build' '_static'
Adicionado na versão 3.14.
- Path.glob(pattern, *, case_sensitive=None, recurse_symlinks=False)¶
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')] >>> sorted(Path('.').glob('**/*.py')) [PosixPath('build/lib/pathlib.py'), PosixPath('docs/conf.py'), PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib.py')]
Ver também
Documentação de Pattern language.
Por padrão, ou quando o argumento somente-nomeado case_sensitive é definido como
None
, esse método corresponde a caminhos usando regras de capitalização específicas da plataforma: normalmente, diferencia maiúsculas de minúsculas no POSIX e não diferencia maiúsculas de minúsculas no Windows. Defina case_sensitive comoTrue
ouFalse
para substituir esse comportamento.Por padrão, ou quando o argumento somente-nomeado recurse_symlinks é definido como
False
, este método segue links simbólicos, exceto ao expandir curingas “**
”. Defina recurse_symlinks comoTrue
para sempre seguir links simbólicos.Levanta um evento de auditoria
pathlib.Path.glob
com os argumentosself
,pattern
.Alterado na versão 3.12: O parâmetro case_sensitive foi adicionado.
Alterado na versão 3.13: O parâmetro recurse_symlinks foi adicionado.
Alterado na versão 3.13: O parâmetro pattern aceita um objeto caminho ou similar.
Alterado na versão 3.13: Quaisquer exceções
OSError
levantadas pela varredura do sistema de arquivos são suprimidas. Em versões anteriores, tais exceções são suprimidas em muitos casos, mas não em todos.
- Path.rglob(pattern, *, case_sensitive=None, recurse_symlinks=False)¶
Faz um glob no pattern relativo dado recursivamente. Isso é como chamar
Path.glob()
com “**/
” adicionado na frente do pattern.Ver também
Documentação de Pattern language e
Path.glob()
.Levanta um evento de auditoria
pathlib.Path.rglob
com argumentosself
,pattern
.Alterado na versão 3.12: O parâmetro case_sensitive foi adicionado.
Alterado na versão 3.13: O parâmetro recurse_symlinks foi adicionado.
Alterado na versão 3.13: O parâmetro pattern aceita um objeto caminho ou similar.
- Path.walk(top_down=True, on_error=None, follow_symlinks=False)¶
Gera os nomes de arquivos em uma árvore de diretórios percorrendo a árvore de cima para baixo ou de baixo para cima.
Para cada diretório na árvore de diretórios com raiz em self (incluindo self, mas excluindo ‘.’ e ‘..’), o método produz uma tupla de 3 elementos de
(dirpath, dirnames, filenames)
.dirpath é um
Path
para o diretório que está sendo percorrido no momento, dirnames é uma lista de strings para os nomes dos subdiretórios em dirpath (excluindo'.'
e'..'
), e filenames é uma lista de strings para os nomes dos arquivos não diretório em dirpath. Para obter um caminho completo (que começa com self) para um arquivo ou diretório em dirpath, façadirpath / name
. Se as listas são ou não classificadas depende do sistema de arquivos.Se o argumento opcional top_down for verdadeiro (que é o padrão), o trio para um diretório é gerado antes dos trios para qualquer um de seus subdiretórios (os diretórios são percorridos de cima para baixo). Se top_down for falso, o trio para um diretório é gerado após os trios para todos os seus subdiretórios (os diretórios são percorridos de baixo para cima). Não importa o valor de top_down, a lista de subdiretórios é recuperada antes que os trios para o diretório e seus subdiretórios sejam percorridos.
When top_down is true, the caller can modify the dirnames list in-place (for example, using
del
or slice assignment), andPath.walk()
will only recurse into the subdirectories whose names remain in dirnames. This can be used to prune the search, or to impose a specific order of visiting, or even to informPath.walk()
about directories the caller creates or renames before it resumesPath.walk()
again. Modifying dirnames when top_down is false has no effect on the behavior ofPath.walk()
since the directories in dirnames have already been generated by the time dirnames is yielded to the caller.By default, errors from
os.scandir()
are ignored. If the optional argument on_error is specified, it should be a callable; it will be called with one argument, anOSError
instance. The callable can handle the error to continue the walk or re-raise it to stop the walk. Note that the filename is available as thefilename
attribute of the exception object.By default,
Path.walk()
does not follow symbolic links, and instead adds them to the filenames list. Set follow_symlinks to true to resolve symlinks and place them in dirnames and filenames as appropriate for their targets, and consequently visit directories pointed to by symlinks (where supported).Nota
Be aware that setting follow_symlinks to true can lead to infinite recursion if a link points to a parent directory of itself.
Path.walk()
does not keep track of the directories it has already visited.Nota
Path.walk()
assumes the directories it walks are not modified during execution. For example, if a directory from dirnames has been replaced with a symlink and follow_symlinks is false,Path.walk()
will still try to descend into it. To prevent such behavior, remove directories from dirnames as appropriate.Nota
Unlike
os.walk()
,Path.walk()
lists symlinks to directories in filenames if follow_symlinks is false.Esse exemplo mostra o número de bytes usados por todos os arquivos em cada diretório, ignorando diretórios
__pycache__
:from pathlib import Path for root, dirs, files in Path("cpython/Lib/concurrent").walk(on_error=print): print( root, "consumes", sum((root / file).stat().st_size for file in files), "bytes in", len(files), "non-directory files" ) if '__pycache__' in dirs: dirs.remove('__pycache__')
This next example is a simple implementation of
shutil.rmtree()
. Walking the tree bottom-up is essential asrmdir()
doesn’t allow deleting a directory before it is empty:# Delete everything reachable from the directory "top". # CAUTION: This is dangerous! For example, if top == Path('/'), # it could delete all of your files. for root, dirs, files in top.walk(top_down=False): for name in files: (root / name).unlink() for name in dirs: (root / name).rmdir()
Adicionado na versão 3.12.
Criando arquivos e diretórios¶
- Path.touch(mode=0o666, exist_ok=True)¶
Create a file at this given path. If mode is given, it is combined with the process’s
umask
value to determine the file mode and access flags. If the file already exists, the function succeeds when exist_ok is true (and its modification time is updated to the current time), otherwiseFileExistsError
is raised.Ver também
The
open()
,write_text()
andwrite_bytes()
methods are often used to create files.
- Path.mkdir(mode=0o777, parents=False, exist_ok=False)¶
Create a new directory at this given path. If mode is given, it is combined with the process’s
umask
value to determine the file mode and access flags. If the path already exists,FileExistsError
is raised.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.If exist_ok is true,
FileExistsError
will not be raised unless the given path already exists in the file system and is not a directory (same behavior as the POSIXmkdir -p
command).Alterado na versão 3.5: O parâmetro exist_ok foi adicionado.
- Path.symlink_to(target, target_is_directory=False)¶
Faça desse path um symbolic link apontando para um target
On Windows, a symlink represents either a file or a directory, and does not morph to the target dynamically. If the target is present, the type of the symlink will be created to match. Otherwise, the symlink will be created as a directory if target_is_directory is true or a file symlink (the default) otherwise. On non-Windows platforms, target_is_directory is ignored.
>>> 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.Alterado na versão 3.13: Raises
UnsupportedOperation
ifos.symlink()
is not available. In previous versions,NotImplementedError
was raised.
- Path.hardlink_to(target)¶
Faz deste caminho um link físico para o mesmo arquivo que target.
Nota
A ordem dos argumentos (link, target) é o inverso da função
os.link()
’s.Adicionado na versão 3.10.
Alterado na versão 3.13: Raises
UnsupportedOperation
ifos.link()
is not available. In previous versions,NotImplementedError
was raised.
Copying, moving and deleting¶
- Path.copy(target, *, follow_symlinks=True, dirs_exist_ok=False, preserve_metadata=False)¶
Copy this file or directory tree to the given target, and return a new
Path
instance pointing to target.If the source is a file, the target will be replaced if it is an existing file. If the source is a symlink and follow_symlinks is true (the default), the symlink’s target is copied. Otherwise, the symlink is recreated at the destination.
If the source is a directory and dirs_exist_ok is false (the default), a
FileExistsError
is raised if the target is an existing directory. If dirs_exists_ok is true, the copying operation will overwrite existing files within the destination tree with corresponding files from the source tree.If preserve_metadata is false (the default), only directory structures and file data are guaranteed to be copied. Set preserve_metadata to true to ensure that file and directory permissions, flags, last access and modification times, and extended attributes are copied where supported. This argument has no effect when copying files on Windows (where metadata is always preserved).
Nota
Where supported by the operating system and file system, this method performs a lightweight copy, where data blocks are only copied when modified. This is known as copy-on-write.
Adicionado na versão 3.14.
- Path.copy_into(target_dir, *, follow_symlinks=True, dirs_exist_ok=False, preserve_metadata=False)¶
Copy this file or directory tree into the given target_dir, which should be an existing directory. Other arguments are handled identically to
Path.copy()
. Returns a newPath
instance pointing to the copy.Adicionado na versão 3.14.
- Path.rename(target)¶
Rename this file or directory to the given target, and return a new
Path
instance pointing to target. On Unix, if target exists and is a file, it will be replaced silently if the user has permission. On Windows, if target exists,FileExistsError
will be raised. target can be either a string or another path object:>>> p = Path('foo') >>> p.open('w').write('some text') 9 >>> target = Path('bar') >>> p.rename(target) PosixPath('bar') >>> target.open().read() 'some text'
The target path may be absolute or relative. Relative paths are interpreted relative to the current working directory, not the directory of the
Path
object.Está implementada em termos de
os.rename()
e fornece as mesmas garantias.Alterado na versão 3.8: Added return value, return the new
Path
instance.
- Path.replace(target)¶
Rename this file or directory to the given target, and return a new
Path
instance pointing to target. If target points to an existing file or empty directory, it will be unconditionally replaced.The target path may be absolute or relative. Relative paths are interpreted relative to the current working directory, not the directory of the
Path
object.Alterado na versão 3.8: Added return value, return the new
Path
instance.
- Path.move(target)¶
Move this file or directory tree to the given target, and return a new
Path
instance pointing to target.If the target doesn’t exist it will be created. If both this path and the target are existing files, then the target is overwritten. If both paths point to the same file or directory, or the target is a non-empty directory, then
OSError
is raised.If both paths are on the same filesystem, the move is performed with
os.replace()
. Otherwise, this path is copied (preserving metadata and symlinks) and then deleted.Adicionado na versão 3.14.
- Path.move_into(target_dir)¶
Move this file or directory tree into the given target_dir, which should be an existing directory. Returns a new
Path
instance pointing to the moved path.Adicionado na versão 3.14.
- 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 POSIXrm -f
).Alterado na versão 3.8: O parâmetro missing_ok foi adicionado.
- Path.rmdir()¶
Remove este diretório. O diretório deve estar vazio.
Permissions and ownership¶
- Path.owner(*, follow_symlinks=True)¶
Retorna o nome do usuário que possui o arquivo.
KeyError
é levantado caso o identificador de usuário (UID) não for encontrado no banco de dados do sistema.Esse método normalmente segue symlinks; para retornar o dono do symlink, adcione o argumento
follow_symlinks=False
.Alterado na versão 3.13: Raises
UnsupportedOperation
if thepwd
module is not available. In earlier versions,NotImplementedError
was raised.Alterado na versão 3.13: O parâmetro follow_symlinks foi adicionado.
- Path.group(*, follow_symlinks=True)¶
Return the name of the group owning the file.
KeyError
is raised if the file’s group identifier (GID) isn’t found in the system database.This method normally follows symlinks; to get the group of the symlink, add the argument
follow_symlinks=False
.Alterado na versão 3.13: Raises
UnsupportedOperation
if thegrp
module is not available. In earlier versions,NotImplementedError
was raised.Alterado na versão 3.13: O parâmetro follow_symlinks foi adicionado.
- Path.chmod(mode, *, follow_symlinks=True)¶
Altera o modo de arquivo e as permissões, como
os.chmod()
.This method normally follows symlinks. Some Unix flavours support changing permissions on the symlink itself; on these platforms you may add the argument
follow_symlinks=False
, or uselchmod()
.>>> p = Path('setup.py') >>> p.stat().st_mode 33277 >>> p.chmod(0o444) >>> p.stat().st_mode 33060
Alterado na versão 3.10: O parâmetro follow_symlinks foi adicionado.
- 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.
Pattern language¶
The following wildcards are supported in patterns for
full_match()
, glob()
and rglob()
:
**
(entire segment)Matches any number of file or directory segments, including zero.
*
(entire segment)Matches one file or directory segment.
*
(part of a segment)Matches any number of non-separator characters, including zero.
?
Matches one non-separator character.
[seq]
Matches one character in seq.
[!seq]
Matches one character not in seq.
For a literal match, wrap the meta-characters in brackets.
For example, "[?]"
matches the character "?"
.
The “**
” wildcard enables recursive globbing. A few examples:
Padrão |
Significado |
---|---|
“ |
Any path with at least one segment. |
“ |
Any path with a final segment ending “ |
“ |
Any path starting with “ |
“ |
Any path starting with “ |
Nota
Globbing with the “**
” wildcard visits every directory in the tree.
Large directory trees may take a long time to search.
Alterado na versão 3.13: Globbing with a pattern that ends with “**
” returns both files and
directories. In previous versions, only directories were returned.
In Path.glob()
and rglob()
, a trailing slash may be added to
the pattern to match only directories.
Comparison to the glob
module¶
The patterns accepted and results generated by Path.glob()
and
Path.rglob()
differ slightly from those by the glob
module:
Files beginning with a dot are not special in pathlib. This is like passing
include_hidden=True
toglob.glob()
.“
**
” pattern components are always recursive in pathlib. This is like passingrecursive=True
toglob.glob()
.“
**
” pattern components do not follow symlinks by default in pathlib. This behaviour has no equivalent inglob.glob()
, but you can passrecurse_symlinks=True
toPath.glob()
for compatible behaviour.Like all
PurePath
andPath
objects, the values returned fromPath.glob()
andPath.rglob()
don’t include trailing slashes.The values returned from pathlib’s
path.glob()
andpath.rglob()
include the path as a prefix, unlike the results ofglob.glob(root_dir=path)
.The values returned from pathlib’s
path.glob()
andpath.rglob()
may include path itself, for example when globbing “**
”, whereas the results ofglob.glob(root_dir=path)
never include an empty string that would correspond to path.
Comparison to the os
and os.path
modules¶
pathlib implements path operations using PurePath
and Path
objects, and so it’s said to be object-oriented. On the other hand, the
os
and os.path
modules supply functions that work with low-level
str
and bytes
objects, which is a more procedural approach. Some
users consider the object-oriented style to be more readable.
Many functions in os
and os.path
support bytes
paths and
paths relative to directory descriptors. These features aren’t
available in pathlib.
Python’s str
and bytes
types, and portions of the os
and
os.path
modules, are written in C and are very speedy. pathlib is
written in pure Python and is often slower, but rarely slow enough to matter.
pathlib’s path normalization is slightly more opinionated and consistent than
os.path
. For example, whereas os.path.abspath()
eliminates
“..
” segments from a path, which may change its meaning if symlinks are
involved, Path.absolute()
preserves these segments for greater safety.
pathlib’s path normalization may render it unsuitable for some applications:
pathlib normalizes
Path("my_folder/")
toPath("my_folder")
, which changes a path’s meaning when supplied to various operating system APIs and command-line utilities. Specifically, the absence of a trailing separator may allow the path to be resolved as either a file or directory, rather than a directory only.pathlib normalizes
Path("./my_program")
toPath("my_program")
, which changes a path’s meaning when used as an executable search path, such as in a shell or when spawning a child process. Specifically, the absence of a separator in the path may force it to be looked up inPATH
rather than the current directory.
As a consequence of these differences, pathlib is not a drop-in replacement
for os.path
.
Corresponding tools¶
Abaixo está uma tabela mapeando várias funções os
a sua PurePath
/Path
equivalente.
Notas de rodapé