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

Novo na versão 3.4.

Código-fonte: Lib/pathlib.py

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. Esta classe 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 `WindowsPath` quando está 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

Importando a classe principal:

    >>> from pathlib import Path

Listando os subdiretórios:

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

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

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

Navegando dentro da árvore de diretórios:

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

Consultando as propriedades do path:

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

Abrindo um arquivo:

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

## Caminhos puros

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

class `pathlib.``PurePath`(*pathsegments)

  Uma classe genérica que representa o tipo de caminho do sistema (ao instanciá-la, cria-se uma `PurePosixPath` ou uma `PureWindowsPath`):

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

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

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

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

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

  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')
      PurePosixPath('/etc')

  pathsegments é especificado de forma similar para `PurePath`.

class `pathlib.``PureWindowsPath`(*pathsegments)

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

      >>> PureWindowsPath('c:/Program Files/')
      PureWindowsPath('c:/Program Files')
      >>> 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.``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ê quiser percorrer um caminho de sistema de arquivos arbitrário para cima, é recomendado primeiro chamar `Path.resolve()` para resolver links simbólicos e eliminar componentes “..”.

`PurePath.``name`

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

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

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

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

`PurePath.``suffix`

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

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

`PurePath.``suffixes`

  Uma lista das extensões de arquivo do caminho:

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

`PurePath.``stem`

  O componente final do caminho, sem seu sufixo:

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

`PurePath.``as_posix`()

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

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

`PurePath.``as_uri`()

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

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

`PurePath.``is_absolute`()

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

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

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

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

  Novo na versão 3.9.

`PurePath.``is_reserved`()

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

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

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

`PurePath.``joinpath`(*other)

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

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

`PurePath.``match`(pattern)

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

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

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

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

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

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

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

`PurePath.``relative_to`(*other)

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

      >>> p = PurePosixPath('/etc/passwd')
      >>> p.relative_to('/')
      PurePosixPath('etc/passwd')
      >>> p.relative_to('/etc')
      PurePosixPath('passwd')
      >>> p.relative_to('/usr')
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "pathlib.py", line 694, in relative_to
          .format(str(self), str(formatted)))
      ValueError: '/etc/passwd' is not in the subpath of '/usr' OR one path is relative and the other absolute.

  NOTA: Esta função é parte de `PurePath` e funciona com strings. Ela não verifica nem acessa a estrutura de arquivos subjacente.

`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

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

## Caminhos concretos

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

class `pathlib.``Path`(*pathsegments)

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

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

  pathsegments é especificado de forma similar para `PurePath`.

class `pathlib.``PosixPath`(*pathsegments)

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

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

  pathsegments é especificado de forma similar para `PurePath`.

class `pathlib.``WindowsPath`(*pathsegments)

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

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

  pathsegments é especificado de forma similar para `PurePath`.

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

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

### Métodos

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

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

classmethod `Path.``cwd`()

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

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

classmethod `Path.``home`()

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

  Novo na versão 3.5.

`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.``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.``exists`()

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

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

  Nota

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

`Path.``expanduser`()

  Retorna um novo caminho com as construções `~` 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')

  Novo na versão 3.5.

`Path.``glob`(pattern)

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

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

  Os padrões são os mesmos de `fnmatch`, com a adição de “`**`” que significa “este diretório e todos os subdiretórios, recursivamente”. Em outras palavras, ele permite fazer glob recursivo:

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

  Nota

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

  Levanta um evento de auditoria `pathlib.Path.glob` com os argumentos `self`, `pattern`.

`Path.``group`()

  Retorna o nome do grupo que possui o arquivo. `KeyError` é levantada se o gid do arquivo não for encontrado no banco de dados do sistema.

`Path.``is_dir`()

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

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

`Path.``is_file`()

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

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

`Path.``is_mount`()

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

  Novo na versão 3.7.

`Path.``is_symlink`()

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

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

`Path.``is_socket`()

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

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

`Path.``is_fifo`()

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

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

`Path.``is_block_device`()

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

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

`Path.``is_char_device`()

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

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

`Path.``iterdir`()

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

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

  Os filhos são 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 será especificado se um objeto caminho para esse arquivo será incluído.

`Path.``lchmod`(mode)

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

`Path.``lstat`()

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

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

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

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

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

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

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

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

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

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

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

`Path.``owner`()

  Retorna o nome do usuário que possui o arquivo. `KeyError` é levantada se o uid do arquivo não for encontrado no banco de dados do sistema.

`Path.``read_bytes`()

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

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

  Novo na versão 3.5.

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

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

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

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

  Novo na versão 3.5.

`Path.``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')

  Novo na versão 3.9.

`Path.``rename`(target)

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

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

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

  Está implementada em termos de `os.rename()` e fornece as mesmas garantias.

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

`Path.``replace`(target)

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

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

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

`Path.``resolve`(strict=False)

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

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

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

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

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

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

`Path.``rglob`(pattern)

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

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

  Levanta um evento de auditoria `pathlib.Path.rglob` com argumentos `self`, `pattern`.

`Path.``rmdir`()

  Remove este diretório. O diretório deve estar vazio.

`Path.``samefile`(other_path)

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

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

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

  Novo na versão 3.5.

`Path.``symlink_to`(target, target_is_directory=False)

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

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

  Nota

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

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

  Novo na versão 3.10.

`Path.``link_to`(target)

  Faz do target um link físico para este caminho.

  Aviso

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

  Novo na versão 3.8.

  Obsoleto desde a versão 3.10: Este método foi descontinuado em favor de `Path.hardlink_to()`, pois a ordem de argumentos de `Path.link_to()` não corresponde àquela de `Path.symlink_to()`.

`Path.``touch`(mode=0o666, exist_ok=True)

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

`Path.``unlink`(missing_ok=False)

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

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

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

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

`Path.``write_bytes`(data)

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

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

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

  Novo na versão 3.5.

`Path.``write_text`(data, encoding=None, errors=None, 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()`.

  Novo na versão 3.5.

  Alterado na versão 3.10: O parâmetro newline foi adicionado.

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

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

Nota

Nem todos os pares de funções/métodos abaixo são equivalentes. Alguns deles, apesar de ter alguns casos de uso sobrepostos, têm semânticas diferentes. Eles incluem `os.path.abspath()` e `Path.resolve()`, `os.path.relpath()` e `PurePath.relative_to()`.

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

Notas de rodapé

1

  `os.path.abspath()` não resolve link simbólico enquanto `Path.resolve()` resolve.

2

  `PurePath.relative_to()` requer que `self` seja o subcaminho do argumento, mas `os.path.relpath()` não.