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

A biblioteca padrão do Python contém a maior parte da funcionalidade 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 no lugar no momento da execução.

No tutorial de hoje, você aprenderá algumas maneiras rápidas de verificar se um arquivo ou pasta existe em 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ê tiver uma versão 2.x, precisará usar o comando “python3”. Confira nosso guia de instalação do Python se você não tiver o Python 3 instalado.

Usaremos 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 jogar, um diretório de teste e outro arquivo dentro do diretório de teste. Os arquivos podem estar vazios, pois não precisaremos ler seu conteúdo,

Observação: se você estiver usando o Windows, configure essa estrutura de arquivo simples com um gerenciador de arquivos gráfico.

Por fim, usaremos IpythonName como nosso shell Python interativo, que fornece 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 nos aprofundar nas maneiras de verificar se uma pasta ou arquivo existe em Python.

Tentar, Abrir 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 tratar 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.

  8 Modelos de matriz de esforço de impacto final para tomar decisões informadas

Observe como a função exit() só será executada se uma exceção for levantada. Vamos ver o que acontece quando o arquivo que estamos procurando 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.

Chamando file.write() sem usar a palavra-chave with ou chamando file.close() pode fazer com que os argumentos de file.write() não sejam completamente gravados no disco, mesmo que o programa seja encerrado com êxito.

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

Se não quisermos fechar o arquivo sozinhos, podemos usar o with context manager. 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 quisermos apenas verificar se existe um arquivo. Vamos mergulhar em outras opções para conseguir isso.

os.path.exists()

o módulo os fornece múltiplas funções para interagir com o sistema operacional. Para verificar se existe um arquivo ou pasta, podemos usar a função path.exists() que aceita o caminho para o arquivo ou diretório como um argumento. Ele retorna um booleano baseado na existência do caminho.

Nota: Um caminho é o local exclusivo de um arquivo ou diretório em um sistema de arquivos

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

/home/daniel/.bashrc

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

.bashrc
# Running the script in my home folder

Aqui estão vários exemplos usando a função os.path.exists(), rodando no diretório onde 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, ele retorna True ao testar com o arquivo testfile.txt e a pasta testdirectory, e False quando o arquivo não existe.

  Como carregar seu laptop em qualquer lugar com um carregador portátil

os.path.isfile()

Se você quisesse apenas 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, vejamos porque:

  • testdirectory/ é um diretório, portanto não é considerado um arquivo. Isso não é absolutamente verdade, pois no Linux tudo é um descritor de arquivomas 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, 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 aponta para um arquivo existente.

glob

o glob módulo fornece funções para trabalhar com Padrões semelhantes a shell do 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 o glob.glob() função.

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 ambos os caminhos existem, a função retorna uma lista com os nomes dos caminhos correspondentes dentro dela.

Observação: 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 de suas principais vantagens?

O código abaixo obtém todos os caminhos de arquivo com 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

o Classe de caminho é uma das melhores maneiras de trabalhar com caminhos, pois nos dá uma interface limpa para trabalhar com caminhos de arquivos como objetos.

  Como faço para cancelar a assinatura Starz na Amazon

A cereja do bolo é que as instâncias Path têm todos os métodos necessários 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 Path que você usará:

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ê é um amante do módulo de subprocesso, você precisa conhecer esta opção. Você pode determinar se um arquivo ou pasta existe usando o comando de teste.

Observação: o comando test funciona apenas no Unix.

Os seguintes sinalizadores de teste farão o trabalho:

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

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

man test

Verificando um caminho com subprocesso:

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

Lembre-se que no Linux, se um processo correu bem, ele retornará zero, se não, 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 o executar função e obtendo seu código de retorno.

Verificando 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 é tão recomendável 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 é verificar se existe um arquivo ou uma pasta.

Os mais simples de fazer são:

  • Abrindo e lidando com exceções de arquivo imediatamente
  • Usando a função exists() 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 (/), enquanto o Windows usa barras invertidas ()

Próxima leitura: O que é um subprocesso em Python? [5 Usage Examples]