padrao - salvando arquivo txt python




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

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_file (note que isso também retorna True para links simbólicos apontando para arquivos regulares):

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

Se você estiver no Python 2, você pode voltar a portar o módulo pathlib de pypi, pathlib2 ou, de outra forma, verificar o isfile 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 há 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 uma try , mas o Python usa try em todos os lugares implementação.

Como o Python usa o try todos os lugares, não há realmente nenhum 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 no pathlib . Note que .exists não está certo, porque diretórios não são arquivos (exceto no sentido unix de que tudo é um arquivo).

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

Então precisamos usar o is_file :

>>> root.is_file()
False

Aqui está a ajuda no 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 existem mais referências a ele).

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

Se você investigar a implementação , verá que o is_file usa:

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: porque 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 excluí-lo e, em seguida, pode estar usando vários segmentos ou processos, ou outro programa sabe sobre esse arquivo e pode excluí-lo - arrisca a chance de uma condição de corrida se você verificar que existe, porque você está correndo para abri-lo antes que sua condição (sua existência) mude.

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

Mas se esta é sua motivação, você pode obter o valor de uma instrução try usando o gerenciador de contexto de suppress .

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

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

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 fazer sua própria suppress , mas sem try será mais detalhado do que com. Eu acredito que esta é a única resposta que não usa try em qualquer nível no Python que possa 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)

dos docs :

os.path.isfile(path)

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

Mas se você examinar a source dessa função, verá que ela 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 o OSError e, em seguida, verificando se é um arquivo se ele não levantou a exceção.

Se você pretende fazer algo com o arquivo, sugiro tentar diretamente com uma tentativa, 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 bandeiras, e 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 com os mesmos problemas de condição de corrida que o isfile . Dos docs :

Nota: O uso de acesso () para verificar se um usuário está autorizado a abrir 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 isto 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 Python 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 entendê-las.

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

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

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


Como faço para 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.state stat.S_ISREG(mode)por baixo. Este os.staté um método de nível inferior que fornecerá informações detalhadas sobre arquivos, diretórios, soquetes, buffers e muito mais. Mais sobre os.stat aqui

Nota: No entanto, esta abordagem não bloqueará o arquivo de qualquer forma e, portanto, seu código pode se tornar vulnerável a bugs " time of check to time of use " ( TOCTTOU ).

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 ifinstruções ( apenas um conselho ).


Ao contrário de isfile() , exists() retornará True para diretórios.
Portanto, dependendo se você deseja apenas arquivos simples ou também diretórios, você usará isfile() ou exists() . Aqui está uma saída simples do REPL.

>>> 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

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 o pathlib :

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

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.



Testando 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:

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

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"

2017/12/22 :

Embora quase todas as formas possíveis tenham sido listadas em (pelo menos uma das) respostas existentes (por exemplo, coisas específicas do Python 3.4 foram adicionadas), tentarei agrupar tudo.

Nota : cada pedaço do código da biblioteca padrão do Python que eu vou postar, pertence à versão 3.5.3 (as citações do doc são específicas da versão 3 ).

Declaração do problema :

  1. Verifique o arquivo ( discutível : também pasta (arquivo "especial")?) Existência
  2. Não use blocos try / except / else / finally

Soluções possíveis :

  1. [Python]: os.path. exists ( caminho ) (também verifique outros membros da família de função como os.path.isfile , os.path.isdir , os.path.lexists para comportamentos ligeiramente diferentes)

    os.path.exists(path)
    

    Retorna True se o caminho se referir a um caminho existente ou a um descritor de arquivo aberto. Retorna False para links simbólicos quebrados. Em algumas plataformas, essa função pode retornar False se a permissão não for concedida para executar os.stat() no arquivo solicitado, mesmo que o caminho exista fisicamente.

    Tudo bem, mas se seguindo a árvore de importação:

    • os.path - posixpath.py ( ntpath.py )

      • genericpath.py , linha ~ # 20 +

        def exists(path):
            """Test whether a path exists.  Returns False for broken symbolic links"""
            try:
                st = os.stat(path)
            except os.error:
                return False
            return True
        

    é só try/except bloquear os.stat() os.stat() . Então, seu código é try/except free, mas no final da página há (pelo menos) um desses blocos. Isso também se aplica a outras funcs ( incluindo os.path.isfile ).

    1.1. [Python]: pathlib.Path. is_file ()

    • É uma maneira mais extravagante (e mais python ic) de lidar com caminhos, mas
    • Sob o capô, ele faz exatamente a mesma coisa ( pathlib.py , linha ~ # 1330 ):

      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
      
  2. [Python]: com gerenciadores de contexto de declaração . Ou:

    • Crie um:

      class Swallow:  # Dummy example
          swallowed_exceptions = (FileNotFoundError,)
      
          def __enter__(self):
              print("Entering...")
      
          def __exit__(self, exc_type, exc_value, exc_traceback):
              print("Exiting:", exc_type, exc_value, exc_traceback)
              return exc_type in Swallow.swallowed_exceptions  # only swallow FileNotFoundError (not e.g. TypeError - if the user passes a wrong argument like None or float or ...)
      
      • E seu uso - replicarei o comportamento do isfile (observe que isso é apenas para fins de demonstração, não tente gravar esse código para produção ):

        import os
        import stat
        
        
        def isfile_seaman(path):  # Dummy func
            result = False
            with Swallow():
                result = stat.S_ISREG(os.stat(path).st_mode)
            return result
        
    • Use [Python]: contextlib. suprimir ( * exceções ) - que foi especificamente projetado para suprimir seletivamente exceções


    Mas, eles parecem ser invólucros sobre blocos try/except/else/finally , como [Python]: A afirmação com afirma:

    Isso permite testes comuns ... except ... finally padrões de uso a serem encapsulados para reutilização conveniente.

  3. Funções de passagem do sistema de arquivos (e busca os resultados para item (ns) correspondente (s))


    Como iterar sobre pastas, (na maioria dos casos) elas são ineficientes para o nosso problema (há exceções, como o não-wildcarded glob bing - como apontado pelo @ShadowRanger), então não vou insistir nelas. Sem mencionar que, em alguns casos, o processamento de nomes de arquivo pode ser necessário.

  4. [Python]: os. acesso ( caminho, modo, *, dir_fd = Nenhum, effective_ids = Falso, follow_symlinks = True ) cujo comportamento é próximo de os.path.exists (na verdade é mais amplo, principalmente por causa do argumento)

    • as permissões de usuário podem restringir o arquivo "visibilidade" conforme o documento diz:

      ... teste se o usuário solicitante tiver o acesso especificado ao caminho . modo deve ser F_OK para testar a existência de caminho ...

    os.access("/tmp", os.F_OK)
    

    Como eu também trabalho em C , eu uso esse método também porque, sob o capô, ele chama APIs nativas (novamente, via "$ {PYTHON_SRC_DIR} /Modules/posixmodule.c" ), mas também abre um gate para um possível usuário erros , e não é tão Python ic como outras variantes. Então, como apontou corretamente @AaronHall, não use a menos que você saiba o que está fazendo:

    Nota : também é possível chamar APIs nativas via [Python]: ctypes - Uma biblioteca de funções externas para Python , mas na maioria dos casos é mais complicada.

    (Específico do Win ): Como o msvcr * ( vcruntime * ) exporta uma família de funções [MSDN]: _access, _waccess , aqui está um exemplo:

    Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 16:02:32) [MSC v.1900 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import os, ctypes
    >>> ctypes.CDLL("msvcrt")._waccess(u"C:\\Windows\\System32\\cmd.exe", os.F_OK)
    0
    >>> ctypes.CDLL("msvcrt")._waccess(u"C:\\Windows\\System32\\___cmd.exe", os.F_OK)
    -1
    

    Notas :

    • Embora não seja uma boa prática, estou usando os.F_OK na chamada, mas isso é apenas para clareza (seu valor é 0 )
    • Estou usando o _waccess para que o mesmo código funcione no Python3 e no Python2 (apesar das diferenças relacionadas a unicode entre eles)
    • Embora isto vise uma área muito específica, não foi mencionado em nenhuma das respostas anteriores


    A contraparte Lnx ( Ubtu (16 x64) ) também:

    Python 3.5.2 (default, Nov 17 2016, 17:05:23)
    [GCC 5.4.0 20160609] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import os, ctypes
    >>> ctypes.CDLL("/lib/x86_64-linux-gnu/libc.so.6").access(b"/tmp", os.F_OK)
    0
    >>> ctypes.CDLL("/lib/x86_64-linux-gnu/libc.so.6").access(b"/tmp1", os.F_OK)
    -1
    

    Notas :

    • Em vez disso, o caminho da libc ( "/lib/x86_64-linux-gnu/libc.so.6" ) que pode (e provavelmente, irá) variar entre os sistemas, None (ou a string vazia) pode ser passada para o construtor CDLL ( ctypes.CDLL(None).access(b"/tmp", os.F_OK) ). De acordo com [homem]: DLOPEN (3) :

      Se filename for NULL, o identificador retornado será para o programa principal. Quando dado a dlsym (), esse identificador faz com que uma busca por um símbolo no programa principal, seguido por todos os objetos compartilhados carregados na inicialização do programa e, em seguida, todos os objetos compartilhados carregados por dlopen () com o sinalizador RTLD_GLOBAL .

      • O programa principal (atual) ( python ) é vinculado à libc , portanto seus símbolos (incluindo o access ) serão carregados
      • Isso tem que ser tratado com cuidado, já que funções como main , Py_Main e (todas) outras estão disponíveis; chamá-los poderia ter efeitos desastrosos (no programa atual)
      • Isso também não se aplica ao Win (mas isso não é grande coisa, já que o msvcrt.dll está localizado em "% SystemRoot% \ System32", que está em % PATH% por padrão). Eu queria levar as coisas adiante e replicar esse comportamento no Win (e enviar um patch), mas, como se vê, [MSDN]: função GetProcAddress apenas "vê" símbolos exportados , a menos que alguém declare as funções no executável principal como __declspec(dllexport) (por que __declspec(dllexport) a pessoa normal faria isso?), o programa principal é carregável, mas praticamente inutilizável
  5. Instale algum módulo de terceiros com recursos de sistema de arquivos

    Muito provavelmente, contará com uma das formas acima (talvez com pequenas personalizações).
    Um exemplo seria (novamente, específico do Win ) [GitHub]: Extensões do Python para Windows (pywin32) , que é um wrapper do Python sobre WINAPI s.

    Mas, como isso é mais como uma solução alternativa, estou parando aqui.

  6. Outra solução alternativa (coxo) ( gainarie ) é (como eu gosto de chamar) a abordagem sysadmin : use o Python como um wrapper para executar comandos shell

    • Vitória :

      (py35x64_test) e:\Work\Dev\\q000082831>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os; print(os.system('dir /b \"C:\\Windows\\System32\\cmd.exe\" > nul 2>&1'))"
      0
      
      (py35x64_test) e:\Work\Dev\\q000082831>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" -c "import os; print(os.system('dir /b \"C:\\Windows\\System32\\cmd.exe.notexist\" > nul 2>&1'))"
      1
      
    • Lnx ( Ubtu ):

      [[email protected]:~]> python3 -c "import os; print(os.system('ls \"/tmp\" > /dev/null 2>&1'))"
      0
      [[email protected]:~]> python3 -c "import os; print(os.system('ls \"/tmp.notexist\" > /dev/null 2>&1'))"
      512
      

Resumindo :

  • Use blocos try / except / else / finally , porque eles podem evitar que você tenha uma série de problemas desagradáveis. Um contra-exemplo que eu posso pensar é o desempenho: tais blocos são caros, então tente não colocá-los no código que deveria rodar centenas de milhares de vezes por segundo (mas como (na maioria dos casos) envolve acesso ao disco, não será o caso).

Nota (s) final (ais) :

  • Vou tentar mantê-lo atualizado, sugestões são bem-vindas, vou incorporar qualquer coisa útil que surja na resposta

O Python 3.4+ possui 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, entrada mais fácil no caminho, etc. Vale a pena conferir. Se você estiver em um Python 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

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']}

No Python 3.4, a linguagem fornece um novo módulo para gerenciar arquivos:

import pathlib
path = pathlib.Path('path/to/file')
if path.is_file(): # If you want to check a directory: path.is_dir()
    # If it is true, return true on your code.

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

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.


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

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

Espero que isto seja útil.


Embora eu sempre recomende usar trye exceptdeclarações, 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ê precisa usar uma cláusula try, exceto. Claro, você sempre pode usar uma trydeclaração exceto como (graças ao 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):

    Isto irá verificar a existência do que você especificar. No entanto, ele verifica se há arquivos e diretórios, portanto, fique 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 a 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 existem duas maneiras de você não conseguir verificar a existência de um arquivo. O problema será permission deniedou 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! :)


Se você importou NumPy já para outros fins, então 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.


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

from contextlib import suppress

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

suppressfaz 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

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 do sistema facilita a navegação e a execução de ações padrão com o sistema operacional.

Para referência também consulte share

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


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




file-exists