Nota: O seguinte artigo irá ajudá-lo com: 7 maneiras de verificar se um arquivo ou pasta existe em Python
A biblioteca padrão do Python contém a maioria das funcionalidades que um desenvolvedor precisaria 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 local 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 brincar, um diretório de teste e outro arquivo dentro do diretório de testes. 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 arquivos simples com um gerenciador de arquivos gráfico.
Finalmente, usaremos o Ipython como nosso shell interativo do Python, 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á o a um belo shell Python apenas digitando ipython.
Agora você está pronto, vamos mergulhar nas maneiras de verificar se uma pasta ou arquivo existe no Python.
Experimentar, Abrir e Exceto
Esta é a opção mais simples. 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 parando a execução do programa caso o arquivo não exista.
Observe como o saída() A função 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. É considerado uma boa prática de acordo com a documentação do Python.
Chamando file.write() sem usar a palavra-chave com ou chamando file.close() poderia 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 com gerenciador de contexto. 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 queremos apenas verificar se um arquivo existe. Vamos mergulhar em outras opções para conseguir isso.
os.path.exists()
O módulo os oferece múltiplas 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 baseado na existência do caminho.
Observação: Um caminho é o local exclusivo 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 path 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 o os.path.exists() função, executando no diretório 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 Verdadeiro ao testar com o testfile.txt arquivo e o diretório de teste pasta, e Falso quando o arquivo não existe.
os.path.isfile()
Se você quisesse apenas provar a existência de um arquivo (não de um diretório), você chamaria o método os.path.isfile() função.
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
Observação: No UNIX, todos os diretórios terminam com uma barra (/), enquanto no Windows usamos uma barra invertida (\).
No código acima o isfile() retorno de função Falso em duas ocasiões, vamos ver o porquê:
- 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á uma 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 o os.path.isdir() função, que só retorna Verdadeiro se o caminho indicado 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 Falso mesmo quando o caminho está apontando para um arquivo que existe.
Globo
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 ado 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.
Observação: Se o padrão não corresponder, você obterá uma lista vazia.
Considerando que podemos ar padrões para a função glob, por que não testar algumas das principais vantagens dela?
O código abaixo 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 de caminho
A classe Path é uma das melhores maneiras de trabalhar com caminhos, pois nos dá uma interface limpa para trabalhar com caminhos de arquivo como objetos.
A cereja do bolo é que as instâncias do 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.caminho.isdir().
subprocesso
Se você é um amante do módulo de subprocesso, você precisa conhecer esta opção. Você pode determinar se existe um arquivo ou pasta usando o comando test.
Observação: o teste comando só funciona em Unix.
Os seguintes sinalizadores de teste farão o trabalho:
- teste -e: Verifique se existe um caminho
- teste -f: Verifique se existe um arquivo
- teste-d: Verifique 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 deu certo, ele retornará zero, se não retornar, 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, usando a função run 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 é recomendado usar essa opção, pois consome mais recursos e não estamos obtendo nenhuma vantagem com isso.
Resumindo
Python é uma das linguagens de programação mais utilizadas para automatizar processos interagindo com o SO. 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 manipulando exceções de arquivo imediatamente
- Usando o existe() função do os.path ou pathlib módulos.
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 o os.path submódulo fornece para verificar a existência de um arquivo ou pasta
- O Unix usa barras (/), enquanto o Windows usa barras invertidas (\)
Leia a seguir: O que é um subprocesso em Python? [5 Usage Examples]
