Trilha de aprendizado · Nível 6 · Tutorial 3

Manipular caminhos com pathlib

Construir e inspecionar caminhos pelo programa, criar pastas necessárias e reconhecer falhas comuns de acesso ao sistema de arquivos.

  • Nível: Iniciante
  • Duração: 18 min
  • 8 passos
Manipular caminhos com pathlib

O que você vai percorrer

  1. Representar um caminho com Path Crie uma representação de caminho em Python sem confundi-la com um arquivo ou diretório existente. 2 min
  2. Combinar pastas e nomes com / Use uma base Path e o operador / para representar hierarquias de pastas e arquivos sem montar separadores manualmente. 2 min
  3. Entender de onde o caminho parte Identifique a pasta de trabalho e use-a para interpretar caminhos relativos, sem confundi-la com a pasta do script. 3 min
  4. Consultar as partes de um caminho Use parent, name, stem e suffix para consultar componentes de um caminho, mesmo que o destino não exista. 2 min
  5. Verificar existência e tipo Consulte o sistema de arquivos com exists(), is_file() e is_dir(), distinguindo o estado observado da aparência do caminho. 2 min
  6. Criar diretórios com mkdir Crie uma estrutura de pastas aninhadas e configure a operação para poder ser repetida com segurança quando o diretório já existir. 2 min
  7. Tratar a falha da operação Associe falhas comuns do sistema de arquivos às exceções específicas e proteja a chamada real de mkdir(). 3 min
  8. Aplicação final: preparar uma pasta de saída Integre construção, inspeção e criação segura de diretórios em um script local, sem criar nem gravar arquivos. 3 min

O que você vai aprender

  • Construir caminhos com Path e combinar seus componentes sem concatenar separadores manualmente.
  • Identificar a pasta de trabalho e distinguir sua influência da localização do script.
  • Consultar componentes e características de um caminho e criar diretórios quando necessário.
  • Tratar falhas específicas do sistema de arquivos sem depender apenas de verificações prévias de existência.

Antes de começar

  • Executar Python no modo interativo e em scripts
  • Separar código em módulos e usar importações explícitas
  • Tratar exceções com try, except, else e finally

Passo 1 de 8

Representar um caminho com Path

Crie uma representação de caminho em Python sem confundi-la com um arquivo ou diretório existente.

Criar um valor Path

Path faz parte de pathlib, um módulo da biblioteca padrão do Python. Portanto, não é necessário instalar um pacote. Você pode criar um valor Path passando um texto que represente um caminho.

Primeiro caminho

Este código representa o caminho de um possível arquivo e o exibe. Ele não cria nem abre o arquivo.

python
from pathlib import Path

destino = Path("rascunho.txt")
print(destino)

Representação não é destino

A variável destino guarda uma representação que o programa pode manipular. Isso não significa que rascunho.txt exista no computador. Criar o Path ou passá-lo para print também não cria, abre nem modifica o destino.

Dois elementos diferentes

Diagrama separando um valor Path mantido pelo programa de um destino ainda inexistente no sistema de arquivos.

O programa pode manter a representação de um caminho mesmo quando não há nenhum arquivo correspondente no sistema de arquivos.

Dica

A exibição depende do sistema

Em caminhos com pastas, os separadores mostrados por print podem acompanhar o sistema operacional. Por isso, a mesma representação pode aparecer com barras diferentes em ambientes distintos.

Confira a distinção

Depois de executar destino = Path("rascunho.txt"), o arquivo rascunho.txt necessariamente passa a existir no computador.

Passo 2 de 8

Combinar pastas e nomes com /

Use uma base Path e o operador / para representar hierarquias de pastas e arquivos sem montar separadores manualmente.

Componentes formam uma hierarquia

Combine caminhos com /

Quando um dos valores é um Path, o operador / combina a base com o próximo componente. Assim, cada nome pode ser escrito separadamente, sem acrescentar \ ou / dentro dos textos.

from pathlib import Path

base = Path("projeto")
relatorio = base / "dados" / "relatorio.csv"

print(relatorio)

O resultado representa a hierarquia projeto → dados → relatorio.csv. Os separadores exibidos podem variar conforme o sistema operacional.

Do código à árvore de pastas

Diagrama que relaciona uma base Path e dois componentes combinados com uma árvore composta por projeto, dados e relatorio.csv.

Cada operação com / acrescenta um componente à hierarquia representada pelo caminho.

A base continua igual

Um novo Path é produzido

Execute este código para comparar a base com o caminho combinado. Ele apenas cria e exibe valores Path; não cria as pastas nem o arquivo.

python
from pathlib import Path

base = Path("projeto")
caminho = base / "dados" / "relatorio.csv"

print("Base:", base)
print("Caminho combinado:", caminho)

Dica

Comece com um Path

A composição funciona porque base é um Path. A expressão "projeto" / "dados" tenta aplicar / entre dois textos e causa TypeError. Converta a base em Path e mantenha os demais nomes como componentes separados.

Exemplo

O valor original não é alterado

Depois da composição, base ainda representa somente projeto. A variável caminho recebe outro valor, que representa projeto/dados/relatorio.csv — com a aparência do separador ajustada ao sistema.

Monte o caminho da árvore

Complete a composição

A árvore desejada é:

projeto
└── relatorios
    └── 2025
        └── resumo.csv

Complete o código sem inserir separadores manualmente:

from pathlib import Path

base = Path("projeto")
caminho = ____

Passo 3 de 8

Entender de onde o caminho parte

Identifique a pasta de trabalho e use-a para interpretar caminhos relativos, sem confundi-la com a pasta do script.

Relativo a quê?

Caminhos relativos e absolutos

Um caminho relativo não informa sozinho todo o trajeto até o destino. Seu ponto de partida é a pasta de trabalho do processo, que pode ser consultada com Path.cwd().

Um caminho absoluto inclui seu ponto de partida completo e, por isso, não depende da pasta de trabalho para ser interpretado.

Consulte o ponto de partida

Execute este código em seu computador e compare as três linhas exibidas:

python
from pathlib import Path

caminho = Path("dados") / "entrada.csv"

print("Pasta de trabalho:", Path.cwd())
print("Caminho relativo:", caminho)
print("Caminho absoluto:", caminho.resolve())

A pasta do script pode ser outra

Quem determina o destino

A pasta de trabalho normalmente depende de onde o processo foi iniciado. Ela não precisa ser a pasta em que o arquivo .py está salvo.

Assim, o mesmo script pode produzir destinos absolutos diferentes para Path("saida") quando é executado a partir de pastas de trabalho diferentes.

O mesmo script, dois destinos

Nos dois casos, o script representa saida/resultado.txt. O que muda é a pasta de trabalho usada como base.

Diagrama comparando duas execuções do mesmo script. Cada execução parte de uma pasta de trabalho diferente e leva o mesmo caminho relativo a um destino absoluto diferente.

A localização do script permanece igual; a pasta de trabalho muda e redefine o destino do caminho relativo.

Resolver sem criar

O que resolve() informa

resolve() produz a forma absoluta de um caminho. Por padrão, ele usa strict=False: o destino não precisa existir.

Portanto, o resultado não comprova existência e a chamada não cria pastas nem arquivos.

Base relativa e componente absoluto

Um componente relativo continua a hierarquia da base. Já um componente absoluto substitui a base anterior:

python
from pathlib import Path

base = Path("projeto")
relativo = Path("dados") / "itens.csv"
absoluto = Path.cwd()

print(base / relativo)
print(base / absoluto)
print(absoluto)
print(base / absoluto == absoluto)

Dica

Observe cada componente

Ao combinar com /, prefira componentes relativos depois da base. Se um componente já for absoluto, tudo o que veio antes dele deixa de determinar o resultado.

Determine o destino

Qual caminho será representado?

Um script está salvo em /home/ana/projeto/programa.py, mas sua pasta de trabalho é /home/ana. Qual é o destino absoluto correspondente a Path("saida")?

O que o resultado garante?

Se resolve() retornou um caminho absoluto, então o arquivo ou diretório correspondente existe.

Passo 4 de 8

Consultar as partes de um caminho

Use parent, name, stem e suffix para consultar componentes de um caminho, mesmo que o destino não exista.

Quatro consultas, quatro resultados

Anatomia de um caminho

Considere o caminho relatorios/2025/vendas.final.csv:

  • parent retorna o caminho que contém o componente final: relatorios/2025.
  • name retorna o nome completo do componente final: vendas.final.csv.
  • stem retorna esse nome sem o último sufixo: vendas.final.
  • suffix retorna o último sufixo, incluindo o ponto: .csv.

parent é outro valor Path. Já name, stem e suffix são textos (str). Essas propriedades apenas analisam a representação do caminho: o destino não precisa existir.

Partes do caminho

Diagrama do caminho relatorios, 2025 e vendas.final.csv, destacando a pasta-pai, o nome completo, o stem vendas.final e o suffix .csv.

Em um nome com vários pontos, stem remove apenas o último sufixo e suffix inclui o ponto.

Consultar sem acessar o destino

Propriedades de Path

Execute o código e compare os valores e tipos exibidos. Nenhuma pasta ou arquivo é criado ou aberto.

python
from pathlib import Path

caminho = Path("relatorios") / "2025" / "vendas.final.csv"

print("parent:", caminho.parent)
print("name:", caminho.name)
print("stem:", caminho.stem)
print("suffix:", caminho.suffix)

print(type(caminho.parent))  # pathlib.Path ou classe específica do sistema
print(type(caminho.name))    # str

Atenção

Sufixo não comprova o formato

.csv é apenas parte do nome. Uma pessoa ou um programa pode atribuir esse sufixo a um conteúdo que não segue o formato CSV. Consultar suffix não inspeciona nem valida o conteúdo do arquivo.

Associe propriedade e resultado

Caminho com mais de um ponto

Associe cada propriedade ao resultado correspondente para Path("relatorios/2025/vendas.final.csv").

Toque em um item e depois no par correspondente.

O que a extensão permite concluir?

Nome ou conteúdo?

Se caminho.suffix retornar ".csv", isso comprova que o conteúdo do arquivo segue o formato CSV.

Passo 5 de 8

Verificar existência e tipo

Consulte o sistema de arquivos com exists(), is_file() e is_dir(), distinguindo o estado observado da aparência do caminho.

Três consultas diferentes

O que existe neste momento?

As propriedades como name e suffix examinam apenas a representação do caminho. Para consultar o sistema de arquivos, use métodos:

  • exists() indica se há um destino no caminho.
  • is_file() indica se o destino é um arquivo regular.
  • is_dir() indica se o destino é um diretório.

As três consultas retornam valores booleanos e não leem o conteúdo de arquivos.

Compare três tipos de destino

Salve este código como consulta_caminhos.py e execute-o a partir da pasta em que foi salvo. Se o último nome já existir no seu computador, troque-o por outro nome que não exista.

python
from pathlib import Path

pasta = Path.cwd()
script = pasta / "consulta_caminhos.py"
ausente = pasta / "destino_que_nao_existe_987654"

caminhos = (
    ("script", script),
    ("pasta", pasta),
    ("ausente", ausente),
)

for rotulo, caminho in caminhos:
    print(rotulo)
    print("  exists:", caminho.exists())
    print("  is_file:", caminho.is_file())
    print("  is_dir:", caminho.is_dir())

Dica

Resultados esperados

O script deve produzir True, True, False; a pasta, True, False, True; e o caminho ausente, False, False, False, nessa ordem para exists(), is_file() e is_dir().

Nome e estado não são a mesma coisa

Um sufixo não comprova o tipo

O caminho relatorio.csv tem aparência de arquivo, mas o nome não prova que ele exista nem que seja um arquivo. Pode não haver destino algum ou pode até existir um diretório com esse nome. suffix examina o nome; exists(), is_file() e is_dir() consultam o estado observável no sistema de arquivos.

Comparação dos resultados

Cada linha representa uma combinação típica das três consultas.

Comparação visual: um arquivo existente tem exists e is_file positivos; uma pasta existente tem exists e is_dir positivos; um caminho ausente tem as três consultas negativas.

Arquivo, diretório e caminho ausente produzem combinações diferentes de resultados.

Atenção

Uma observação, não uma garantia

Esses resultados descrevem o momento da consulta. O destino pode mudar antes da próxima operação, e um resultado positivo não garante que uma operação posterior terá permissão para acessar o destino. As consultas também não fornecem, sozinhas, um diagnóstico completo de uma falha.

Escolha a interpretação correta

O que é possível concluir?

Para caminho = Path("relatorio.csv"), a expressão caminho.is_file() retornou False. Qual conclusão é adequada?

Passo 6 de 8

Criar diretórios com mkdir

Crie uma estrutura de pastas aninhadas e configure a operação para poder ser repetida com segurança quando o diretório já existir.

Uma operação que altera o sistema

Do caminho planejado à pasta criada

Construir um Path apenas representa um caminho. Já o método mkdir() solicita a criação de um diretório no sistema de arquivos.

Para criar de uma vez todos os diretórios intermediários ausentes, use parents=True. Com exist_ok=True, a operação também pode ser repetida quando o diretório de destino já existe.

Antes e depois de mkdir()

Comparação entre uma pasta inicial sem a estrutura planejada e a mesma pasta contendo pratica_pathlib, relatorios e mensais em níveis aninhados.

Com parents=True, uma única chamada pode criar toda a hierarquia ausente até o diretório final.

Prática no seu computador

Crie uma estrutura descartável

No terminal, vá até uma pasta em que você possa criar diretórios. Salve e execute o código abaixo nessa pasta. Ele usa a pasta de trabalho como base e cria somente diretórios com nomes próprios para a prática.

Execute o script duas vezes. A segunda execução deve terminar normalmente porque exist_ok=True aceita que o diretório final já exista.

Criar pastas intermediárias e permitir repetição

Você pode trocar os três nomes por outros nomes de prática.

python
from pathlib import Path

base = Path.cwd()
destino = base / "pratica_pathlib" / "relatorios" / "mensais"

destino.mkdir(parents=True, exist_ok=True)

print("Destino:", destino)
print("Existe:", destino.exists())
print("É diretório:", destino.is_dir())

Atenção

O que exist_ok=True não faz

exist_ok=True não substitui um arquivo existente por um diretório e não faz qualquer falha ser ignorada. Se algum desses nomes já pertencer a um arquivo ou se a criação não puder ser realizada, mkdir() ainda poderá falhar. Não exclua nem sobrescreva itens para concluir esta prática: escolha outros nomes ou outra pasta de trabalho.

Escolha os argumentos

Complete a chamada

Complete a chamada para criar uma pasta aninhada e permitir que ela seja executada novamente:

destino.mkdir(____)

Confira o resultado local

O que você observou?

Depois de executar o script duas vezes, descreva quais diretórios apareceram dentro da pasta de trabalho e o que aconteceu na segunda execução.

Escreva pelo menos 40 caracteres (0/40).

Passo 7 de 8

Tratar a falha da operação

Associe falhas comuns do sistema de arquivos às exceções específicas e proteja a chamada real de mkdir().

Cada falha tem um tipo

Diagnósticos mais específicos

Ao executar mkdir(), a falha informa o que impediu a criação:

  • FileNotFoundError: um diretório-pai necessário não existe quando parents=False.
  • FileExistsError: o destino já existe de forma incompatível. Pode ser um diretório com exist_ok=False ou um arquivo ocupando o caminho — mesmo com exist_ok=True.
  • PermissionError: o processo não tem permissão para realizar a operação naquele local.
  • IsADirectoryError: outra operação exigia um arquivo, mas recebeu um diretório. Por enquanto, basta reconhecer esse diagnóstico.

Esses tipos pertencem à família OSError, que reúne falhas relacionadas ao sistema operacional.

Mapa das falhas

Diagrama que relaciona uma operação no sistema de arquivos a pai ausente, destino já ocupado, acesso negado e diretório recebido no lugar de arquivo.

O tipo específico da exceção ajuda a distinguir causas que não devem receber o mesmo tratamento.

Atenção

Não transforme toda falha em sucesso

Evite capturar OSError indiscriminadamente quando cada causa exige uma resposta diferente. Trate apenas as falhas previstas e deixe problemas inesperados continuarem visíveis.

Proteja a operação efetiva

Consulta não é garantia

Uma chamada anterior a exists(), is_file() ou is_dir() descreve apenas aquele instante. Antes de mkdir() executar, o destino pode mudar, ser ocupado por um arquivo ou deixar de estar acessível. Portanto, o try deve envolver a própria operação que pode falhar.

Tratamento restrito ao mkdir

Adapte apenas os nomes dos componentes. O bloco try contém somente a criação do diretório; assim, cada except corresponde claramente à operação protegida.

python
from pathlib import Path

base = Path.cwd()
destino = base / "pratica_pathlib" / "saida"

try:
    destino.mkdir(parents=True, exist_ok=True)
except FileExistsError:
    print("O caminho está ocupado por algo que não pode ser usado como pasta.")
except PermissionError:
    print("Sem permissão para criar a pasta nesse local.")
except FileNotFoundError:
    print("Um componente necessário do caminho não foi encontrado.")
else:
    print(f"Pasta pronta: {destino}")

Associe causa e exceção

Qual exceção descreve a falha?

Relacione cada situação ao tipo mais específico.

Toque em um item e depois no par correspondente.

Escolha uma proteção confiável

Estado pode mudar

O programa verificou que o destino não existia. Qual abordagem continua correta para criar a pasta?

Passo 8 de 8

Aplicação final: preparar uma pasta de saída

Integre construção, inspeção e criação segura de diretórios em um script local, sem criar nem gravar arquivos.

O resultado que você vai preparar

Pasta pronta, arquivo ainda inexistente

Você vai executar um script que usa a pasta de trabalho como base, constrói saida/relatorios e representa o caminho de um futuro arquivo chamado resumo.txt. O script cria somente os diretórios. O caminho do arquivo poderá ser inspecionado, mas o arquivo não será criado.

Antes e depois de mkdir()

Comparação entre uma pasta de trabalho antes da execução e a mesma pasta contendo os diretórios saída e relatórios, com um futuro arquivo apenas contornado.

Depois da execução, os diretórios existem. O arquivo futuro continua sendo apenas um caminho representado no programa.

Execute o script completo

Prática no seu computador

Escolha uma pasta de prática em que você possa criar conteúdo e abra o terminal nela. Salve o código abaixo em um script e execute-o. Se quiser, troque apenas os nomes saida, relatorios e resumo.txt por nomes seguros de sua preferência.

preparar_saida.py

Este script constrói os caminhos, mostra seus componentes e tenta criar somente a pasta de saída.

python
from pathlib import Path

base = Path.cwd()
pasta_saida = base / "saida" / "relatorios"
futuro_arquivo = pasta_saida / "resumo.txt"

print("Pasta de trabalho:", base)
print("Destino absoluto:", futuro_arquivo.resolve())
print("Pasta do futuro arquivo:", futuro_arquivo.parent)
print("Nome:", futuro_arquivo.name)
print("Nome sem sufixo:", futuro_arquivo.stem)
print("Sufixo:", futuro_arquivo.suffix)

try:
    pasta_saida.mkdir(parents=True, exist_ok=True)
except FileExistsError as erro:
    print("Conflito: um arquivo ocupa o lugar de uma pasta necessária.")
    print(erro)
except PermissionError as erro:
    print("Sem permissão para criar a pasta nesse local.")
    print(erro)
else:
    print("Pasta de saída pronta:", pasta_saida)
    print("A pasta existe?", pasta_saida.exists())
    print("É um diretório?", pasta_saida.is_dir())
    print("O futuro arquivo existe?", futuro_arquivo.exists())

Dica

Execute duas vezes

Na primeira execução, os diretórios ausentes são criados. Execute novamente sem alterar o código: exist_ok=True permite que o diretório final já exista. Nas duas execuções, o resultado esperado para o futuro arquivo é False.

Confira e explique o resultado

Complete a construção

Complete o componente ausente: pasta_saida = base / "saida" / ____

Relate suas duas execuções

Depois de executar o script duas vezes, registre: a pasta de trabalho mostrada, o destino absoluto, o resultado das consultas sobre a pasta e o futuro arquivo, e a diferença observada entre as execuções.

Escreva pelo menos 80 caracteres (0/80).

Conflito no destino

Se já houver um arquivo comum chamado relatorios no lugar em que o script precisa criar essa pasta, qual é a resposta apropriada?

Competência consolidada

Resumo

Agora você sabe manipular caminhos com pathlib

Nesta aplicação, você integrou as operações centrais do tutorial.

  • Representar e combinar caminhos com Path e /, sem criar o destino.
  • Usar Path.cwd() como base explícita e obter uma representação absoluta com resolve().
  • Inspecionar parent, name, stem e suffix e consultar existência e tipo.
  • Criar diretórios intermediários com mkdir(parents=True, exist_ok=True).
  • Tratar falhas específicas da operação, sem presumir que uma verificação anterior garante o resultado.
  • Distinguir a criação da pasta de saída da futura criação do arquivo.

Baixe o Aplicativo agora para ter acesso a + de 5000 cursos gratuitos, exercícios, certificado e muito conteúdo sem pagar nada!

  • Cursos online 100% gratuitos do início ao fim

    Milhares de cursos online em vídeo, ebooks e áudiobooks.

  • Mais de 60 mil exercícios gratuitos

    Para testar seus conhecimentos no decorrer dos cursos online

  • Certificado Digital gratuito válido em todo o Brasil

    Gerado diretamente na galeria de fotos do seu celular e enviado ao seu e-mail

Aplicativo Cursa na tela de ebook, na tela de curso em vídeo e na tela de exercícios do curso, mais o certificado de conclusão de curso