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

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

  Alterado na versão 3.14: The URL authority is discarded if it matches the local hostname. Otherwise, if the authority isn’t empty or `localhost`, then on Windows a UNC path is returned (as before), and on other platforms a `ValueError` is raised.

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'

  Deprecated since version 3.14, will be removed in version 3.19: Calling this method from `PurePath` rather than `Path` is possible but deprecated. The method’s use of `os.fsencode()` makes it strictly impure.

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

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

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

  Return `True` if the path points to an existing file or directory. `False` will be returned if the path is invalid, inaccessible or missing. Use `Path.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. Use `Path.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. Use `Path.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. Use `Path.stat()` to distinguish between these cases.

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

  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. Use `Path.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. Use `Path.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. Use `Path.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. Use `Path.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çã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.

Path.info

  A `PathInfo` object that supports querying file type information. The object exposes methods that cache their results, which can help reduce the number of system calls needed when switching on file type. For example:

      >>> p = Path('src')
      >>> if p.info.is_symlink():
      ...     print('symlink')
      ... elif p.info.is_dir():
      ...     print('directory')
      ... elif p.info.exists():
      ...     print('something else')
      ... else:
      ...     print('not found')
      ...
      directory

  If the path was generated from `Path.iterdir()` then this attribute is initialized with some information about the file type gleaned from scanning the parent directory. Merely accessing `Path.info` does not perform any filesystem queries.

  To fetch up-to-date information, it’s best to call `Path.is_dir()`, `is_file()` and `is_symlink()` rather than methods of this attribute. There is no way to reset the cache; instead you can create a new path object with an empty info cache via `p = Path(p)`.

  Adicionado na versão 3.14.

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

### Copying, moving and deleting

Path.copy(target, *, follow_symlinks=True, 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 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, 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 new `Path` 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 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, where seq is a sequence of characters. Range expressions are supported; for example, `[a-z]` matches any lowercase ASCII letter. Multiple ranges can be combined: `[a-zA-Z0-9_]` matches any ASCII letter, digit, or underscore.

`[!seq]`

  Matches one character not in seq, where seq follows the same rules as above.

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

## Protocolos

The `pathlib.types` module provides types for static type checking.

Adicionado na versão 3.14.

class pathlib.types.PathInfo

  A `typing.Protocol` describing the `Path.info` attribute. Implementations may return cached results from their methods.

  exists(*, follow_symlinks=True)

    Return `True` if the path is an existing file or directory, or any other kind of file; return `False` if the path doesn’t exist.

    If follow_symlinks is `False`, return `True` for symlinks without checking if their targets exist.

  is_dir(*, follow_symlinks=True)

    Return `True` if the path is a directory, or a symbolic link pointing to a directory; return `False` if the path is (or points to) any other kind of file, or if it doesn’t exist.

    If follow_symlinks is `False`, return `True` only if the path is a directory (without following symlinks); return `False` if the path is any other kind of file, or if it doesn’t exist.

  is_file(*, follow_symlinks=True)

    Return `True` if the path is a file, or a symbolic link pointing to a file; return `False` if the path is (or points to) a directory or other non-file, or if it doesn’t exist.

    If follow_symlinks is `False`, return `True` only if the path is a file (without following symlinks); return `False` if the path is a directory or other other non-file, or if it doesn’t exist.

  is_symlink()

    Return `True` if the path is a symbolic link (even if broken); return `False` if the path is a directory or any kind of file, or if it doesn’t exist.