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:

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

2. 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 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 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 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/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 ou ntpath.

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.

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
[]

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, will be 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, retorna True se o caminho é considerado reservado no Windows, False caso contrário. Com PurePosixPath, 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 ou False 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; chame resolve() 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, will be 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')

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 e relative_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 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/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 e PureWindowsPath, 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 com file: 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 de os.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 por os.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 for False, 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 se os.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.

Path.stat(*, follow_symlinks=True)

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.

Este método normalmente segue links simbólicos; para obter estado de um link simbólico, adicione o argumento follow_symlinks=False, ou use lstat().

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

Retorna True se o caminho aponta para um arquivo ou diretório existente.

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)

Retorna True se o caminho aponta para um arquivo regular, False se aponta 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.

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)

Retorna True se o caminho aponta para um diretório, False se aponta 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.

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

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_junction()

Retorna True se o caminho apontar para uma junção, e False 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 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. 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()

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

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.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 como True ou False 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 como True para sempre seguir links simbólicos.

Levanta um evento de auditoria pathlib.Path.glob com os argumentos self, 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 argumentos self, 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ça dirpath / 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), and Path.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 inform Path.walk() about directories the caller creates or renames before it resumes Path.walk() again. Modifying dirnames when top_down is false has no effect on the behavior of Path.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, an OSError 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 the filename 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 as rmdir() 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), otherwise FileExistsError is raised.

Ver também

The open(), write_text() and write_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 POSIX mkdir -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 if os.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 if os.link() is not available. In previous versions, NotImplementedError was raised.

Renaming and deleting

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.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.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 the pwd 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 the grp 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 use lchmod().

>>> 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.
“**/*.py”	Any path with a final segment ending “.py”.
“assets/**”	Any path starting with “assets/”.
“assets/**/*”	Any path starting with “assets/”, excluding “assets/” itself.

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.

Alterado na versão 3.11: Globbing with a pattern that ends with a pathname components separator (sep or altsep) returns 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:

1. Files beginning with a dot are not special in pathlib. This is like passing include_hidden=True to glob.glob().

2. “**” pattern components are always recursive in pathlib. This is like passing recursive=True to glob.glob().

3. “**” pattern components do not follow symlinks by default in pathlib. This behaviour has no equivalent in glob.glob(), but you can pass recurse_symlinks=True to Path.glob() for compatible behaviour.

4. Like all PurePath and Path objects, the values returned from Path.glob() and Path.rglob() don’t include trailing slashes.

5. The values returned from pathlib’s path.glob() and path.rglob() include the path as a prefix, unlike the results of glob.glob(root_dir=path).

6. The values returned from pathlib’s path.glob() and path.rglob() may include path itself, for example when globbing “**”, whereas the results of glob.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:

1. pathlib normalizes Path("my_folder/") to Path("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.

2. pathlib normalizes Path("./my_program") to Path("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 in PATH 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.

os e os.path	pathlib
os.path.dirname()	PurePath.parent
os.path.basename()	PurePath.name
os.path.splitext()	PurePath.stem, PurePath.suffix
os.path.join()	PurePath.joinpath()
os.path.isabs()	PurePath.is_absolute()
os.path.relpath()	PurePath.relative_to() [1]
os.path.expanduser()	Path.expanduser() [2]
os.path.realpath()	Path.resolve()
os.path.abspath()	Path.absolute() [3]
os.path.exists()	Path.exists()
os.path.isfile()	Path.is_file()
os.path.isdir()	Path.is_dir()
os.path.islink()	Path.is_symlink()
os.path.isjunction()	Path.is_junction()
os.path.ismount()	Path.is_mount()
os.path.samefile()	Path.samefile()
os.getcwd()	Path.cwd()
os.stat()	Path.stat()
os.lstat()	Path.lstat()
os.listdir()	Path.iterdir()
os.walk()	Path.walk() [4]
os.mkdir(), os.makedirs()	Path.mkdir()
os.link()	Path.hardlink_to()
os.symlink()	Path.symlink_to()
os.readlink()	Path.readlink()
os.rename()	Path.rename()
os.replace()	Path.replace()
os.remove(), os.unlink()	Path.unlink()
os.rmdir()	Path.rmdir()
os.chmod()	Path.chmod()
os.lchmod()	Path.lchmod()

Notas de rodapé

[1]

os.path.relpath() calls abspath() to make paths absolute and remove “..” parts, whereas PurePath.relative_to() is a lexical operation that raises ValueError when its inputs’ anchors differ (e.g. if one path is absolute and the other relative.)

[2]

os.path.expanduser() returns the path unchanged if the home directory can’t be resolved, whereas Path.expanduser() raises RuntimeError.

[3]

os.path.abspath() removes “..” components without resolving symlinks, which may change the meaning of the path, whereas Path.absolute() leaves any “..” components in the path.

[4]

os.walk() always follows symlinks when categorizing paths into dirnames and filenames, whereas Path.walk() categorizes all symlinks into filenames when follow_symlinks is false (the default.)