7 maneiras de verificar se um arquivo ou pasta existe no Python

A biblioteca padrão do Python contém a maior parte das funcionalidades de que um desenvolvedor precisa para resolver um problema. Neste tutorial, você aprenderá diferentes maneiras de verificar a existência de um arquivo ou diretório usando apenas módulos integrados.

Verificar se um arquivo ou script está no local correto é crucial para qualquer programa CLI. Seu programa pode se tornar inútil se um arquivo específico não estiver instalado no momento da execução.

No tutorial de hoje, você aprenderá algumas maneiras rápidas de verificar se um arquivo ou pasta existe no Python.

Antes de começar

Antes de executar qualquer comando abaixo, certifique-se de ter o Python 3 instalado em seu sistema. Abra seu terminal e digite o seguinte comando:

 python --version # Python 3.9.5, my result

Se você tem uma versão 2.x, você precisará usar o comando “python3”. Confira nosso guia de instalação do Python se você não tiver o Python 3 instalado.

Estaremos usando alguns arquivos de teste junto com este tutorial, portanto, certifique-se de criar os seguintes arquivos:

 touch testfile.txt mkdir testdirectory/ touch testdirectory/otherfile.txt

Os comandos acima criam um arquivo para brincar, um diretório de teste e outro arquivo dentro do diretório de teste . Os arquivos podem estar vazios, pois não precisamos ler seu conteúdo,

Nota: Se você estiver usando o Windows, configure essa estrutura de arquivo simples com um gerenciador de arquivos gráfico.

Por fim, usaremos o Ipython como nosso shell Python interativo, que oferece uma interface bonita para trabalhar. Esta é apenas uma mercadoria, portanto não estritamente necessária.

 pip install ipython

Depois de fazer isso, você terá acesso a um belo shell Python apenas digitando ipython .

Agora que está tudo pronto, vamos mergulhar nas maneiras de verificar se existe uma pasta ou arquivo no Python.

Experimente, abra e exceto

Esta é a opção mais direta. Se você tentar abrir um arquivo que não existe, o Python gerará um FileNotFoundError.

 In [1]: open('im-not-here.txt') --------------------------------------------------------------------------- FileNotFoundError: [Errno 2] No such file or directory: 'im-not-here.txt'

Podemos tirar proveito disso e lidar com a exceção caso o arquivo que estamos procurando não exista.

 In [2]: try: ...: file = open('im-not-here.txt') ...: print(file) # File handler ...: file.close() ...: except FileNotFoundError: ...: print('Sorry the file we\'re looking for doesn\' exist') ...: exit() ...: Sorry the file we're looking for doesn't exist

No código acima, estamos imprimindo uma mensagem personalizada e interrompendo a execução do programa se o arquivo não existir.

Observe como a função exit () só será executada se uma exceção for levantada. Vamos ver o que acontece quando o arquivo que procuramos realmente existe.

 In [2]: try: ...: file = open('testfile.txt') ...: print(file) # File handler ...: file.close() ...: except FileNotFoundError: ...: print('Sorry the file we\'re looking for doesn\'t exist') ...: exit() ...: <_io.TextIOWrapper name='testfile.txt' mode='r' encoding='UTF-8'>

Observe como estamos fechando o arquivo logo após abri-lo. É considerada uma boa prática de acordo com a documentação do Python.

Chamar <span class="pre">file.write()</span> sem usar a palavra-chave <span class="pre">with</span> ou chamar <span class="pre">file.close()</span> pode resultar nos argumentos de <span class="pre">file.write()</span> não sendo completamente gravados no disco, mesmo se o programa for encerrado com sucesso.

Mesmo que não estejamos gravando no arquivo, é extremamente recomendável fechá-lo, pois isso pode causar vários problemas de desempenho.

Se não quisermos fechar o arquivo por nós mesmos, podemos usar o gerenciador de contexto with . Ele aloca e libera recursos com precisão, portanto, não precisaremos fechar o arquivo.

 In [3]: try: ...: with open('testfile.txt') as file: ...: print(file) ...: # No need to close the file ...: except FileNotFoundError: ...: print('Sorry the file we\'re looking for doesn\'t exist') ...: exit() ...: ...: <_io.TextIOWrapper name='testfile.txt' mode='r' encoding='UTF-8'>

Este método é extremamente útil ao escrever em arquivos, mas resulta ineficiente se desejarmos apenas verificar se um arquivo existe. Vamos mergulhar em outras opções para conseguir isso.

os.path.exists ()

O módulo OS fornece várias funções para interagir com o sistema operacional. Para verificar se existe um arquivo ou pasta, podemos usar o caminho. Existe () função que aceita o caminho para o arquivo ou diretório como um argumento. Ele retorna um booleano com base na existência do caminho.

Nota: Um caminho é a localização única de um arquivo ou diretório em um sistema de arquivos

Em Python, o submódulo os.path contém funções projetadas exclusivamente para operar com caminhos de arquivo. Todas essas funções aceitam o argumento de caminho como strings ou bytes, e você pode decidir trabalhar com caminhos absolutos, por exemplo:

 /home/daniel/.bashrc

Ou com caminhos relativos, dependendo do diretório em que você está executando o script:

 .bashrc # Running the script in my home folder

Aqui estão vários exemplos usando a função os.path.exists () , em execução no diretório em que meus arquivos de teste estão localizados:

 In [1]: import os In [2]: os.path.exists('testfile.txt') Out[2]: True In [3]: os.path.exists('testdirectory') Out[3]: True In [4]: os.path.exists('hey-i-dont-exist') Out[4]: False

Como você pode ver, retorna True ao testar com o arquivo testfile.txt e a pasta testdirectory , e False quando o arquivo não existe.

os.path.isfile ()

Se você só quisesse provar a existência de um arquivo (não de um diretório), chamaria a função os.path.isfile () .

 In [1]: import os In [2]: os.path.isfile('testfile.txt') Out[2]: True In [3]: os.path.isfile('testdirectory/') Out[3]: False In [4]: os.path.isfile('i-dont-even-exist') Out[4]: False In [5]: os.path.isfile('testdirectory/otherfile.txt') Out[5]: True

Nota: No UNIX, todos os diretórios terminam com uma barra (/), enquanto no Windows usamos uma barra invertida (\).

No código acima, a função isfile () retorna False em duas ocasiões, vamos ver por quê:

• testdirectory/ é um diretório, portanto não é considerado um arquivo. Isso não é absolutamente verdade, pois no Linux tudo é um descritor de arquivo, mas o Python trata os diretórios de maneira diferente apenas por conveniência (se você tentar abrir um diretório, obterá um IsADirectoryError )
• i-dont-even-exist está apontando para um arquivo que ironicamente não existe

os.path.isdir ()

Se você quiser verificar se um diretório está no local correto, você precisará usar a função os.path.isdir () , que só retorna True se o caminho fornecido apontar para um diretório.

 In [1]: import os In [2]: os.path.isdir('testfile.txt') Out[2]: False In [3]: os.path.isdir('testdirectory') Out[3]: True In [4]: os.path.isdir('anotherfile.txt') Out[4]: False

Observe como os exemplos acima retornam False mesmo quando o caminho está apontando para um arquivo existente.

Glob

O módulo glob fornece funções para trabalhar com padrões do tipo shell Unix (portanto, não funciona corretamente no Windows). Para verificar se um arquivo corresponde a um padrão dentro do diretório atual, você pode usar a função glob.glob ().

 In [1]: import glob In [2]: glob.glob('testfile.txt') Out[2]: ['testfile.txt'] In [3]: glob.glob('testdirectory') Out[3]: ['testdirectory']

No código acima, o padrão passado para a função glob é uma string normal que representa o caminho para o arquivo e diretório de teste. Como os dois caminhos existem, a função retorna uma lista com os nomes dos caminhos correspondentes dentro dela.

Nota: Se o padrão não corresponder, você obterá uma lista vazia.

Considerando que podemos passar padrões para a função glob, por que não testar algumas das principais vantagens dela?

O código a seguir obtém todos os caminhos de arquivo com uma extensão .txt e .py respectivamente:

 In [4]: glob.glob('*.txt') Out[4]: ['testfile.txt'] In [5]: glob.glob('*.py') Out[5]: ['pathlib-exists.py', 'list-dir.py', 'glob-file.py', 'open-except.py', 'subprocess-test.py', 'isfile.py', 'exists.py', 'isdir.py']

Usando a classe Path

A classe Path é uma das melhores maneiras de trabalhar com caminhos, pois nos fornece uma interface limpa para trabalhar com caminhos de arquivos como objetos.

A cereja do bolo é que as instâncias de Path têm todos os métodos de que você precisa para obter informações sobre um determinado caminho. Isso inclui funcionalidades semelhantes às opções anteriores.

Observação: você precisará do Python 3.4 ou superior para usar a biblioteca pathlib

Os métodos de caminho que você usará:

• Caminho (). Existe ()
• Path (). Is_file ()
• Path (). Is_dir ()

Verifique se existe um caminho

 In [1]: from pathlib import Path In [2]: Path('testfile.txt').exists() Out[2]: True In [3]: Path('im-not-here.txt').exists() Out[3]: False In [4]: Path('testdirectory').exists() Out[4]: True

Funciona da mesma forma que os.path.exists () .

Verifique se o caminho aponta para um arquivo

 In [5]: Path('testfile.txt').is_file() Out[5]: True In [6]: Path('testdirectory').is_file() Out[6]: False

Equivalente a os.path.isfile () .

Verifique se o caminho aponta para um diretório

 In [7]: Path('testfile.txt').is_dir() Out[7]: False In [8]: Path('testdirectory').is_dir() Out[8]: True

Corresponde a os.path.isdir ().

subprocesso

Se você for um amante do módulo de subprocesso, precisará saber sobre essa opção. Você pode determinar se um arquivo ou pasta existe usando o comando test.

Nota: O comando test só funciona em Unix.

Os seguintes sinalizadores de teste farão o trabalho:

• test -e: Verifique se existe um caminho
• test -f: Verifique se existe um arquivo
• test-d: Verifique se existe uma pasta

Caso queira mergulhar em mais sinalizadores de teste, você pode ler o manual executando:

 man test

Verificando um caminho com subprocesso:

O código a seguir determina se existe um caminho comparando o código de retorno do subprocesso com 0.

Lembre-se que no Linux, se um processo for bem, ele retornará zero, caso contrário retornará qualquer outro código.

 In [1]: from subprocess import run In [2]: run(['test', '-e', 'testfile.txt']).returncode == 0 Out[2]: True In [3]: run(['test', '-e', 'im-not-here.txt']).returncode == 0 Out[3]: False

Na primeira instrução, estamos importando o módulo de subprocesso e, em seguida, usando a função run e obtendo seu código de retorno.

Verificar a existência de um arquivo com subprocesso

 In [4]: run(['test', '-f', 'testfile.txt']).returncode == 0 Out[4]: True In [5]: run(['test', '-f', 'testdirectory']).returncode == 0 Out[5]: False

Verificando um diretório com subprocesso:

 In [6]: run(['test', '-d', 'testfile.txt']).returncode == 0 Out[6]: False In [7]: run(['test', '-d', 'testdirectory']).returncode == 0 Out[7]: True

Não é recomendado usar esta opção, pois consome mais recursos e não estamos obtendo nenhuma vantagem com isso.

Resumindo

Python é uma das linguagens de programação mais usadas para automatizar processos interagindo com o sistema operacional. Uma coisa legal que você pode fazer com ele é verificar se existe um arquivo ou uma pasta.

Os mais simples de fazer são:

• Abrindo e gerenciando exceções de arquivo imediatamente
• Usando a função existe () dos módulos os.path ou pathlib.

Neste tutorial, você aprendeu:

• Como abrir um arquivo e lidar com exceções caso ele não exista
• O significado dos caminhos
• 3 funções diferentes que o submódulo os.path fornece para verificar a existência de um arquivo ou pasta
• Unix usa barras invertidas (/), enquanto o Windows usa barras invertidas (\)

Próxima leitura: O que é um subprocesso em Python? [5 exemplos de uso]