it-swarm-pt.tech

Como faço para verificar se existe um arquivo sem exceções?

Como faço para ver se um arquivo existe ou não, sem usar a instrução try ?

4981
spence91

Se a razão que você está checando é para que você possa fazer algo como if file_exists: open_it(), é mais seguro usar try na tentativa de abri-lo. Marcar e abrir abre o risco de o arquivo ser excluído ou movido ou algo entre quando você verifica e quando você tenta abri-lo.

Se você não está planejando abrir o arquivo imediatamente, você pode usar os.path.isfile

Retorna True se path é um arquivo regular existente. Isso segue links simbólicos, portanto ambos islink () e isfile () podem ser verdadeiros para o mesmo caminho.

import os.path
os.path.isfile(fname) 

se você precisa ter certeza de que é um arquivo.

Começando com o Python 3.4, o módulo pathlib oferece uma abordagem orientada a objetos (backportada para pathlib2 no Python 2.7):

from pathlib import Path

my_file = Path("/path/to/file")
if my_file.is_file():
    # file exists

Para verificar um diretório, faça:

if my_file.is_dir():
    # directory exists

Para verificar se existe um objeto Path independentemente de ser um arquivo ou diretório, use exists():

if my_file.exists():
    # path exists

Você também pode usar resolve(strict=True) em um bloco try:

try:
    my_abs_path = my_file.resolve(strict=True)
except FileNotFoundError:
    # doesn't exist
else:
    # exists
4560
rslite

Você tem a função os.path.exists :

import os.path
os.path.exists(file_path)

Isso retorna True para arquivos e diretórios, mas você pode usar

os.path.isfile(file_path)

para testar se é um arquivo especificamente. Segue links simbólicos.

1913
PierreBdR

Ao contrário de isfile() , exists() retornará True para diretórios.
Então, dependendo se você quer apenas arquivos simples ou diretórios, você usará isfile() ou exists(). Aqui está uma saída simplesREPL.

>>> print os.path.isfile("/etc/password.txt")
True
>>> print os.path.isfile("/etc")
False
>>> print os.path.isfile("/does/not/exist")
False
>>> print os.path.exists("/etc/password.txt")
True
>>> print os.path.exists("/etc")
True
>>> print os.path.exists("/does/not/exist")
False
885
bortzmeyer
import os.path

if os.path.isfile(filepath):
543
Paul

Use os.path.isfile() com os.access() :

import os
import os.path

PATH='./file.txt'

if os.path.isfile(PATH) and os.access(PATH, os.R_OK):
    print "File exists and is readable"
else:
    print "Either the file is missing or not readable"
268
Yugal Jindle
import os
os.path.exists(path) # Returns whether the path (directory or file) exists or not
os.path.isfile(path) # Returns whether the file exists or not
248
benefactual

Esta é a maneira mais simples de verificar se existe um arquivo. Apenas porque o arquivo existia quando você verificou não garantia que ele estará lá quando você precisar abri-lo.

import os
fname = "foo.txt"
if os.path.isfile(fname):
    print("file does exist at this time")
else:
    print("no such file exists at this time")
145
un33k

Python 3.4+ tem um módulo de caminho orientado a objetos: pathlib . Usando este novo módulo, você pode verificar se um arquivo existe assim:

import pathlib
p = pathlib.Path('path/to/file')
if p.is_file():  # or p.is_dir() to see if it is a directory
    # do stuff

Você pode (e geralmente deve) ainda usar um bloco try/except ao abrir arquivos:

try:
    with p.open() as f:
        # do awesome stuff
except OSError:
    print('Well darn.')

O módulo pathlib tem muitas coisas legais: globbing conveniente, verificação do dono do arquivo, junção de caminho mais fácil, etc. Vale a pena conferir. Se você estiver em um Python mais antigo (versão 2.6 ou posterior), ainda poderá instalar o pathlib com o pip:

# installs pathlib2 on older Python versions
# the original third-party module, pathlib, is no longer maintained.
pip install pathlib2

Em seguida, importe-o da seguinte maneira:

# Older Python versions
import pathlib2 as pathlib
132
Cody Piersall

Prefira a instrução try. É considerado melhor estilo e evita condições de corrida.

Não tome minha palavra para isso. Há muito apoio para essa teoria. Aqui está um casal:

116
pkoch

Como faço para verificar se existe um arquivo usando Python sem usar uma instrução try?

Agora disponível desde o Python 3.4, importe e instancie um objeto Path com o nome do arquivo, e verifique o método is_filenote que isso retorna True para links simbólicos apontando também para arquivos regulares):

>>> from pathlib import Path
>>> Path('/').is_file()
False
>>> Path('/initrd.img').is_file()
True
>>> Path('/doesnotexist').is_file()
False

Se você está no Python 2, você pode fazer backport do módulo pathlib de pypi, pathlib2 , ou então verificar isfile a partir do módulo os.path:

>>> import os
>>> os.path.isfile('/')
False
>>> os.path.isfile('/initrd.img')
True
>>> os.path.isfile('/doesnotexist')
False

Agora, o acima é provavelmente a melhor resposta direta pragmática aqui, mas existe a possibilidade de uma condição de corrida (dependendo do que você está tentando realizar) e o fato de que a implementação subjacente usa um try, mas Python usa try em todos os lugares implementação.

Como o Python usa try em todos os lugares, não há motivo para evitar uma implementação que o use.

Mas o resto desta resposta tenta considerar essas ressalvas.

Resposta mais longa e pedante

Disponível desde o Python 3.4, use o novo objeto Path em pathlib. Note que .exists não está certo, porque os diretórios não são arquivos (exceto no sentido unix que _ (everythingé um arquivo).

>>> from pathlib import Path
>>> root = Path('/')
>>> root.exists()
True

Então, precisamos usar is_file:

>>> root.is_file()
False

Aqui está a ajuda em is_file:

is_file(self)
    Whether this path is a regular file (also True for symlinks pointing
    to regular files).

Então vamos pegar um arquivo que sabemos que é um arquivo:

>>> import tempfile
>>> file = tempfile.NamedTemporaryFile()
>>> filepathobj = Path(file.name)
>>> filepathobj.is_file()
True
>>> filepathobj.exists()
True

Por padrão, NamedTemporaryFile exclui o arquivo quando fechado (e será fechado automaticamente quando não houver mais referências a ele).

>>> del file
>>> filepathobj.exists()
False
>>> filepathobj.is_file()
False

Se você cavar em the implementation , você verá que is_file usa try:

def is_file(self):
    """
    Whether this path is a regular file (also True for symlinks pointing
    to regular files).
    """
    try:
        return S_ISREG(self.stat().st_mode)
    except OSError as e:
        if e.errno not in (ENOENT, ENOTDIR):
            raise
        # Path doesn't exist or is a broken symlink
        # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
        return False

Condições de corrida: Por que gostamos de tentar

Nós gostamos de try porque evita condições de corrida. Com try, você simplesmente tenta ler seu arquivo, esperando que ele esteja lá, e se não, você pega a exceção e executa qualquer comportamento de fallback que faça sentido.

Se você quiser verificar se existe um arquivo antes de tentar lê-lo, e pode estar excluindo-o e, em seguida, pode estar usando vários processos ou threads, ou outro programa sabe sobre esse arquivo e pode excluí-lo - arrisca a chance de a condição de corrida se você verificar que existe, porque você está então racingpara abri-lo antes de seu condição(sua existência) muda.

As condições de corrida são muito difíceis de depurar porque há uma janela muito pequena na qual elas podem causar falhas no seu programa.

Mas se essa for sua motivação, você podeobter o valor de uma instrução try usando o gerenciador de contexto suppress.

Evitando condições de corrida sem uma instrução try: suppress

O Python 3.4 nos dá o gerenciador de contexto suppress (anteriormente o gerenciador de contexto ignore ), que faz semanticamente exatamente a mesma coisa em menos linhas, enquanto também (pelo menos superficialmente) atende a requisição original para evitar um try declaração:

from contextlib import suppress
from pathlib import Path

Uso:

>>> with suppress(OSError), Path('doesnotexist').open() as f:
...     for line in f:
...         print(line)
... 
>>>
>>> with suppress(OSError):
...     Path('doesnotexist').unlink()
... 
>>> 

Para os Pythons anteriores, você poderia rolar seu próprio suppress, mas sem um try será mais detalhado do que com. Eu acredito esta é a única resposta que não usa try em qualquer nível no Python que pode ser aplicado antes do Python 3.4 porque ele usa um gerenciador de contexto:

class suppress(object):
    def __init__(self, *exceptions):
        self.exceptions = exceptions
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type is not None:
            return issubclass(exc_type, self.exceptions)

Talvez mais fácil com uma tentativa:

from contextlib import contextmanager

@contextmanager
def suppress(*exceptions):
    try:
        yield
    except exceptions:
        pass

Outras opções que não atendem ao pedido "sem tentar":

isfile

import os
os.path.isfile(path)

do docs :

os.path.isfile(path)

Retorna True se path for um arquivo regular existente. Isso segue os links simbólicos, portanto, tanto islink() quanto isfile() podem ser verdadeiros para o mesmo caminho.

Mas se você examinar o source desta função, verá que ele realmente usa uma instrução try:

# This follows symbolic links, so both islink() and isdir() can be true
# for the same path on systems that support symlinks
def isfile(path):
    """Test whether a path is a regular file"""
    try:
        st = os.stat(path)
    except os.error:
        return False
    return stat.S_ISREG(st.st_mode)
>>> OSError is os.error
True

Tudo o que ele está fazendo é usar o caminho fornecido para ver se ele pode obter estatísticas sobre ele, pegando OSError e, em seguida, verificando se é um arquivo se ele não levantou a exceção.

Se você pretende fazer alguma coisa com o arquivo, sugiro tentar diretamente com ele, exceto para evitar uma condição de corrida:

try:
    with open(path) as f:
        f.read()
except OSError:
    pass

os.access

Disponível para Unix e Windows é os.access, mas para usar você deve passar flags, e ele não diferencia entre arquivos e diretórios. Isso é mais usado para testar se o usuário de chamada real tem acesso em um ambiente de privilégio elevado:

import os
os.access(path, os.F_OK)

Ele também sofre dos mesmos problemas de condição de corrida que isfile. Do docs :

Nota: Usando o acesso () para verificar se um usuário está autorizado, por exemplo, abra um arquivo antes de fazê-lo usando open () cria uma falha de segurança, porque o usuário pode explorar o curto intervalo de tempo entre a verificação e a abertura do arquivo para manipulá-lo. É preferível usar as técnicas do EAFP. Por exemplo:

if os.access("myfile", os.R_OK):
    with open("myfile") as fp:
        return fp.read()
return "some default data"

é melhor escrito como:

try:
    fp = open("myfile")
except IOError as e:
    if e.errno == errno.EACCES:
        return "some default data"
    # Not a permission error.
    raise
else:
    with fp:
        return fp.read()

Evite usar os.access. É uma função de baixo nível que tem mais oportunidades de erro do usuário do que os objetos e funções de nível superior discutidos acima.

Crítica de outra resposta:

Outra resposta diz isso sobre os.access:

Pessoalmente, eu prefiro este porque, sob o capô, ele chama APIs nativas (via "$ {PYTHON_SRC_DIR} /Modules/posixmodule.c"), mas também abre uma porta para possíveis erros do usuário, e não é tão Pythonic quanto outras variantes :

Esta resposta diz que prefere um método não-Pythoniano propenso a erros, sem justificativa. Parece incentivar os usuários a usar APIs de baixo nível sem compreendê-las.

Ele também cria um gerenciador de contexto que, ao retornar incondicionalmente True, permite que todas as Exceções (incluindo KeyboardInterrupt e SystemExit!) Passem silenciosamente, o que é uma boa maneira de esconder bugs.

Isso parece encorajar os usuários a adotarem práticas inadequadas.

110
Aaron Hall
import os
#Your path here e.g. "C:\Program Files\text.txt"
#For access purposes: "C:\\Program Files\\text.txt"
if os.path.exists("C:\..."):   
    print "File found!"
else:
    print "File not found!"

A importação de os facilita a navegação e a execução de ações padrão com o sistema operacional.

Para referência também consulte Como verificar se existe um arquivo usando Python?

Se você precisar de operações de alto nível, use shutil.

82
bishop

Teste de arquivos e pastas com os.path.isfile(), os.path.isdir() e os.path.exists()

Supondo que o "caminho" seja um caminho válido, esta tabela mostra o que é retornado por cada função para arquivos e pastas:

 enter image description here

Você também pode testar se um arquivo é um determinado tipo de arquivo usando os.path.splitext() para obter a extensão (se você ainda não souber)

>>> import os
>>> path = "path to a Word document"
>>> os.path.isfile(path)
True
>>> os.path.splitext(path)[1] == ".docx" # test if the extension is .docx
True
75
Tom Fuller

Em 2016, a melhor maneira ainda é usar os.path.isfile:

>>> os.path.isfile('/path/to/some/file.txt')

Ou no Python 3 você pode usar pathlib:

import pathlib
path = pathlib.Path('/path/to/some/file.txt')
if path.is_file():
    ...
67
KaiBuxe

Não parece haver uma diferença funcional significativa entre try/except e isfile(), portanto, você deve usar qual deles faz sentido.

Se você quiser ler um arquivo, se existir, faça

try:
    f = open(filepath)
except IOError:
    print 'Oh dear.'

Mas se você quiser apenas renomear um arquivo se ele existir e, portanto, não precisar abri-lo, faça

if os.path.isfile(filepath):
    os.rename(filepath, filepath + '.old')

Se você quiser gravar em um arquivo, se ele não existir, faça

# python 2
if not os.path.isfile(filepath):
    f = open(filepath, 'w')

# python 3, x opens for exclusive creation, failing if the file already exists
try:
    f = open(filepath, 'wx')
except IOError:
    print 'file already exists'

Se você precisar de bloqueio de arquivo, isso é um assunto diferente.

62
chad

Você poderia tentar isso (mais seguro):

try:
    # http://effbot.org/zone/python-with-statement.htm
    # 'with' is safer to open a file
    with open('whatever.txt') as fh:
        # Do something with 'fh'
except IOError as e:
    print("({})".format(e))

A saída seria:

([Errno 2] Nenhum arquivo ou diretório: 'whatever.txt')

Então, dependendo do resultado, seu programa pode continuar correndo de lá ou você pode codificar para pará-lo se quiser.

53
philberndt

Embora eu sempre recomende usar as instruções try e except, aqui estão algumas possibilidades para você (meu favorito pessoal é usar os.access):

  1. Tente abrir o arquivo:

    Abrir o arquivo sempre verificará a existência do arquivo. Você pode fazer uma função assim:

    def File_Existence(filepath):
        f = open(filepath)
        return True
    

    Se for False, interromperá a execução com um IOError ou OSError não manipulado em versões posteriores do Python. Para capturar a exceção, você deve usar uma cláusula try, exceto. Claro, você sempre pode usar uma instrução try except` assim (graças a hsandt por me fazer pensar):

    def File_Existence(filepath):
        try:
            f = open(filepath)
        except IOError, OSError: # Note OSError is for later versions of Python
            return False
    
        return True
    
  2. Use os.path.exists(path):

    Isso irá verificar a existência do que você especificar. No entanto, ele verifica se há arquivos e , portanto, esteja atento ao modo como você o utiliza.

    import os.path
    >>> os.path.exists("this/is/a/directory")
    True
    >>> os.path.exists("this/is/a/file.txt")
    True
    >>> os.path.exists("not/a/directory")
    False
    
  3. Use os.access(path, mode):

    Isto irá verificar se você tem acesso ao arquivo. Ele irá verificar as permissões. Com base na documentação do os.py, digitando os.F_OK, ele verificará a existência do caminho. No entanto, usar isso criará uma falha de segurança, já que alguém pode atacar seu arquivo usando o tempo entre a verificação das permissões e a abertura do arquivo. Você deve ir diretamente para abrir o arquivo em vez de verificar suas permissões. ( EAFP vs LBYP ). Se você não for abrir o arquivo depois e verificar apenas sua existência, poderá usá-lo.

    De qualquer forma, aqui:

    >>> import os
    >>> os.access("/is/a/file.txt", os.F_OK)
    True
    

Também devo mencionar que há duas maneiras de você não conseguir verificar a existência de um arquivo. O problema será permission denied ou no such file or directory. Se você pegar um IOError, defina o IOError as e (como a minha primeira opção) e, em seguida, digite print(e.args) para que você possa determinar o seu problema. Espero que ajude! :)

48
Zizouz212

Data: 2017-12-04

Todas as soluções possíveis foram listadas em outras respostas.

Uma maneira intuitiva e discutível de verificar se um arquivo existe é o seguinte:

import os
os.path.isfile('~/file.md')  # Returns True if exists, else False
# additionaly check a dir
os.path.isdir('~/folder')  # Returns True if the folder exists, else False
# check either a dir or a file
os.path.exists('~/file')

Eu fiz um cheatsheet exaustivo para sua referência:

#os.path methods in exhaustive cheatsheet
{'definition': ['dirname',
               'basename',
               'abspath',
               'relpath',
               'commonpath',
               'normpath',
               'realpath'],
'operation': ['split', 'splitdrive', 'splitext',
               'join', 'normcase'],
'compare': ['samefile', 'sameopenfile', 'samestat'],
'condition': ['isdir',
              'isfile',
              'exists',
              'lexists'
              'islink',
              'isabs',
              'ismount',],
 'expand': ['expanduser',
            'expandvars'],
 'stat': ['getatime', 'getctime', 'getmtime',
          'getsize']}
42
JawSaw

Além disso, os.access():

if os.access("myfile", os.R_OK):
    with open("myfile") as fp:
        return fp.read()

Sendo R_OK, W_OK e X_OK os sinalizadores para testar as permissões ( doc ).

32
zgoda

Se o arquivo for para abertura, você pode usar uma das seguintes técnicas:

>>> with open('somefile', 'xt') as f: #Using the x-flag, Python3.3 and above
...     f.write('Hello\n')

>>> if not os.path.exists('somefile'): 
...     with open('somefile', 'wt') as f:
...         f.write("Hello\n")
... else:
...     print('File already exists!')

UPDATE

Apenas para evitar confusão e com base nas respostas que recebi, a resposta atual encontra um diretório file ou a com o nome dado.

30
bergercookie
if os.path.isfile(path_to_file):
    try: 
        open(path_to_file)
            pass
    except IOError as e:
        print "Unable to open file"

Criar exceções é considerado uma abordagem aceitável e Pythonica para o controle de fluxo em seu programa. Considere lidar com arquivos ausentes com IOErrors. Nessa situação, uma exceção IOError será gerada se o arquivo existir, mas o usuário não tiver permissões de leitura.

SRC: http://www.pfinn.net/python-check-if-file-exists.html

20
Pedro Lobito

Você pode escrever a sugestão de Brian sem o try:.

from contextlib import suppress

with suppress(IOError), open('filename'):
    process()

suppress faz parte do Python 3.4. Em versões mais antigas, você pode escrever rapidamente sua própria supressão:

from contextlib import contextmanager

@contextmanager
def suppress(*exceptions):
    try:
        yield
    except exceptions:
        pass
17
Chris

Se você já importou o NumPy para outros fins, não há necessidade de importar outras bibliotecas como pathlib, os, paths, etc.

import numpy as np
np.DataSource().exists("path/to/your/file")

Isso retornará verdadeiro ou falso com base em sua existência.

17
durjoy

Arquivo de verificação ou diretório existe

Você pode seguir estas três formas:

Nota 1: O os.path.isfile usado apenas para arquivos

import os.path
os.path.isfile(filename) # True if file exists
os.path.isfile(dirname) # False if directory exists

Nota 2: O os.path.exists usado para arquivos e diretórios

import os.path
os.path.exists(filename) # True if file exists
os.path.exists(dirname) #True if directory exists

O método pathlib.Path (incluído no Python 3+, instalável com o pip para o Python 2)

from pathlib import Path
Path(filename).exists()
16
Ali Hallaji

Adicionando mais uma leve variação que não é exatamente refletida nas outras respostas.

Isso manipulará o caso de file_path sendo None ou string vazia.

def file_exists(file_path):
    if not file_path:
        return False
    Elif not os.path.isfile(file_path):
        return False
    else:
        return True

Adicionando uma variante baseada na sugestão do Shahbaz

def file_exists(file_path):
    if not file_path:
        return False
    else:
        return os.path.isfile(file_path)

Adicionando uma variante baseada na sugestão de Peter Wood

def file_exists(file_path):
    return file_path and os.path.isfile(file_path):
15
Marcel Wilson

Eu sou o autor de um pacote que existe há cerca de 10 anos, e tem uma função que aborda essa questão diretamente. Basicamente, se você estiver em um sistema não-Windows, ele usa Popen para acessar find. No entanto, se você estiver no Windows, ele replicará find com um walker eficiente do sistema de arquivos.

O código em si não usa um bloco try… exceto ao determinar o sistema operacional e, assim, direcionar você para o estilo “Unix” find ou o hand-buillt find. Os testes de tempo mostraram que a try foi mais rápida na determinação do sistema operacional, então usei um deles (mas em nenhum outro lugar).

>>> import pox
>>> pox.find('*python*', type='file', root=pox.homedir(), recurse=False)
['/Users/mmckerns/.python']

E o doc ...

>>> print pox.find.__doc__
find(patterns[,root,recurse,type]); Get path to a file or directory

    patterns: name or partial name string of items to search for
    root: path string of top-level directory to search
    recurse: if True, recurse down from root directory
    type: item filter; one of {None, file, dir, link, socket, block, char}
    verbose: if True, be a little verbose about the search

    On some OS, recursion can be specified by recursion depth (an integer).
    patterns can be specified with basic pattern matching. Additionally,
    multiple patterns can be specified by splitting patterns with a ';'
    For example:
        >>> find('pox*', root='..')
        ['/Users/foo/pox/pox', '/Users/foo/pox/scripts/pox_launcher.py']

        >>> find('*shutils*;*init*')
        ['/Users/foo/pox/pox/shutils.py', '/Users/foo/pox/pox/__init__.py']

>>>

A implementação, se você quiser ver, está aqui: https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190

15
Mike McKerns

Aqui está um comando Python de 1 linha para o ambiente de linha de comando do Linux. Eu acho isso MUITO HANDY desde que eu não sou um cara Bash tão quente.

python -c "import os.path; print os.path.isfile('/path_to/file.xxx')"

Espero que isto seja útil.

14

Como posso verificar se existe um arquivo, sem usar a instrução try?

Em 2016, essa ainda é a maneira mais fácil de verificar se um arquivo existe e se é um arquivo:

import os
os.path.isfile('./file.txt')    # Returns True if exists, else False

isfile é na verdade apenas um método auxiliar que usa internamente os.stat e stat.S_ISREG(mode) embaixo. Este os.stat é um método de nível inferior que fornece informações detalhadas sobre arquivos, diretórios, soquetes, buffers e muito mais. Mais sobre os.stat aqui

Nota: No entanto, esta abordagem não irá bloquear o arquivo de qualquer forma e, portanto, seu código pode se tornar vulnerável a " tempo de verificação para o tempo de uso " (TOCTTOU) insetos.

Portanto, criar exceções é considerado uma abordagem aceitável e Pythonica para o controle de fluxo em seu programa. E deve-se considerar o manuseio de arquivos ausentes com IOErrors, em vez de instruções if (apenas um conselho).

11
Inconnu

Você pode usar a biblioteca "OS" do Python:

>>> import os
>>> os.path.exists("C:\\Users\\####\\Desktop\\test.txt") 
True
>>> os.path.exists("C:\\Users\\####\\Desktop\\test.tx")
False
11
Pradip Das
import os.path

def isReadableFile(file_path, file_name):
    full_path = file_path + "/" + file_name
    try:
        if not os.path.exists(file_path):
            print "File path is invalid."
            return False
        Elif not os.path.isfile(full_path):
            print "File does not exist."
            return False
        Elif not os.access(full_path, os.R_OK):
            print "File cannot be read."
            return False
        else:
            print "File can be read."
            return True
    except IOError as ex:
        print "I/O error({0}): {1}".format(ex.errno, ex.strerror)
    except Error as ex:
        print "Error({0}): {1}".format(ex.errno, ex.strerror)
    return False
#------------------------------------------------------

path = "/usr/khaled/documents/puzzles"
fileName = "puzzle_1.txt"

isReadableFile(path, fileName)
9
Khaled.K

Você pode usar o seguinte método aberto para verificar se um arquivo existe + legível:

open(inputFile, 'r')
9
user3197473
import os
path = /path/to/dir

root,dirs,files = os.walk(path).next()
if myfile in files:
   print "yes it exists"

Isso é útil ao verificar vários arquivos. Ou você deseja fazer uma interseção/subtração com uma lista existente.

8
Jesvin Jose

Para verificar se existe um arquivo,

from sys import argv

from os.path import exists
script, filename = argv
target = open(filename)
print "file exists: %r" % exists(filename)
7
Hanson

Você pode usar os.listdir para verificar se um arquivo está em um determinado diretório.

import os
if 'file.ext' in os.listdir('dirpath'):
    #code
5
iPhynx
import os

# for testing purpose args defaulted to current folder & file. 
# returns True if file found
def file_exists(FOLDER_PATH='../', FILE_NAME=__file__):
    return os.path.isdir(FOLDER_PATH) \
        and os.path.isfile(os.path.join(FOLDER_PATH, FILE_NAME))

Basicamente, uma verificação de pasta, em seguida, uma verificação de arquivo com o separador de diretório apropriado usando os.path.join .

4
Vimal Maheedharan

Você definitivamente deveria usar este.

from os.path import exists

if exists("file") == True:
    print "File exists."
Elif exists("file") == False:
    print "File doesn't exist."
3
user2154354

Não é necessário, provavelmente, mas se for, aqui está um código

import os

def file_exists(path, filename):
    for file_or_folder in os.listdir(path):
        if file_or_folder == filename:
            return True
    return False
0
The dark side of Gaming