python remove - Come posso verificare se un file esiste senza eccezioni?




15 Answers

Se la ragione per cui stai verificando è così che puoi fare qualcosa come if file_exists: open_it() , è più sicuro usare una try per tentare di aprirla. Il controllo e l'apertura rischiano di eliminare o spostare il file o qualcosa tra il momento in cui si verifica e quando si tenta di aprirlo.

Se non hai intenzione di aprire immediatamente il file, puoi utilizzare os.path.isfile

Restituisce True se path è un file regolare esistente. Questo segue collegamenti simbolici, quindi sia islink() che os.path.isfile possono essere veri per lo stesso percorso.

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

se hai bisogno di essere sicuro che sia un file

A partire da Python 3.4, il modulo pathlib offre un approccio orientato agli oggetti (backported a pathlib2 in Python 2.7):

from pathlib import Path

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

Per controllare una directory, fai:

if my_file.is_dir():
    # directory exists

Per verificare se esiste un oggetto Path indipendentemente dal fatto che si tratti di un file o di una directory, utilizzare exists() :

if my_file.exists():
    # path exists

Puoi anche usare resolve() in un blocco try :

try:
    my_abs_path = my_file.resolve()
except FileNotFoundError:
    # doesn't exist
else:
    # exists
rename create

Come faccio a vedere se un file esiste o no, senza usare la dichiarazione try ?




A differenza di isfile() , exists() restituisce True per le directory.
Quindi, a seconda se vuoi solo file normali o anche directory, utilizzerai isfile() o exists() . Ecco un semplice output 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



Utilizzare os.path.isfile() con 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 :

Sebbene quasi tutte le modalità possibili siano state elencate in (almeno una delle) risposte esistenti (ad esempio, sono state aggiunte specifiche cose di Python 3.4 ), cercherò di raggruppare tutto insieme.

Nota : ogni parte del codice della libreria standard Python che sto per postare appartiene alla versione 3.5.3 (le virgolette del doc sono specifiche della versione 3 ).

Dichiarazione di problema :

  1. Controlla file ( discutibile : anche cartella (file "speciale")?) Esistenza
  2. Non usare try / except / else / finally blocks

Possibili soluzioni :

  1. [Python]: os.path. esiste ( percorso ) (controlla anche altri membri della famiglia di funzioni come os.path.isfile , os.path.isdir , os.path.lexists per comportamenti leggermente diversi)

    os.path.exists(path)
    

    Restituisce True se path fa riferimento a un percorso esistente o a un descrittore di file aperto. Restituisce False per collegamenti simbolici non funzionanti. Su alcune piattaforme, questa funzione può restituire False se non viene concessa l'autorizzazione per eseguire os.stat() sul file richiesto, anche se il percorso esiste fisicamente.

    Tutto bene, ma se si segue l'albero di importazione:

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

      • genericpath.py , line ~ # 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
        

    è solo un try/except block around os.stat() os.stat() . Quindi, il tuo codice è try/except free, ma in basso nel framestack c'è (almeno) uno di questi blocchi. Questo vale anche per altre funzioni ( incluso os.path.isfile ).

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

    • È un modo più manieroso (e più python ic) di gestire i percorsi, ma
    • Sotto il cofano, fa esattamente la stessa cosa ( pathlib.py , line ~ # 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]: con i gestori di contesto delle istruzioni . O:

    • Crearne uno:

      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 il suo utilizzo - replicherò il comportamento di isfile (si noti che questo è solo a scopo dimostrativo, non tentare di scrivere tale codice per la produzione ):

        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
        
    • Usa [Python]: contextlib. sopprimere ( * eccezioni ) - che è stato specificamente progettato per sopprimere selettivamente le eccezioni


    Ma, sembrano essere wrapper su try/except/else/finally blocks, come [Python]: The con statement afferma:

    Ciò consente di try comune ... except ... finally modelli di utilizzo da incapsulare per un comodo riutilizzo.

  3. Funzioni di attraversamento del filesystem (e cerca i risultati per gli articoli corrispondenti)


    Dal momento che queste iterano su cartelle, (nella maggior parte dei casi) sono inefficaci per il nostro problema (ci sono delle eccezioni, come il bing non glob in caratteri jolly - come sottolineato da @ShadowRanger), quindi non ho intenzione di insistere su di esse. Per non parlare del fatto che in alcuni casi potrebbe essere necessaria l'elaborazione dei nomi dei file.

  4. [Python]: os. accesso ( percorso, modalità, *, dir_fd = Nessuno, effective_ids = False, follow_symlinks = True ) il cui comportamento è vicino a os.path.exists (in realtà è più ampio, principalmente a causa del secondo argomento)

    • le autorizzazioni utente potrebbero limitare il file "visibilità" come afferma il documento:

      ... verifica se l'utente che ha richiamato ha l'accesso al percorso specificato. la modalità dovrebbe essere F_OK per verificare l'esistenza del percorso ...

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

    Dato che lavoro anche in C , utilizzo anche questo metodo perché sotto il cofano chiama le API native (di nuovo, tramite "$ {PYTHON_SRC_DIR} /Modules/posixmodule.c" ), ma apre anche un gate per un possibile utente errori , e non è come Python come altre varianti. Quindi, come ha giustamente sottolineato @AaronHall, non usarlo a meno che tu non sappia cosa stai facendo:

    Nota : la chiamata alle API native è anche possibile tramite [Python]: ctypes - Una libreria di funzioni estranee per Python , ma nella maggior parte dei casi è più complicata.

    ( Win specifico): poiché msvcr * ( vcruntime * ) esporta una famiglia di [MSDN]: _access, _waccess , ecco un esempio:

    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
    

    Note :

    • Anche se non è una buona pratica, sto usando os.F_OK nella chiamata, ma è solo per chiarezza (il suo valore è 0 )
    • Sto usando _waccess modo che lo stesso codice funzioni su Python3 e Python2 (nonostante le differenze relative all'unicode tra di loro)
    • Sebbene si rivolga a un'area molto specifica, non è stata menzionata in nessuna delle precedenti risposte


    Anche la controparte Lnx ( Ubtu (16 x64) ):

    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
    

    Note :

    • Invece di codificare il percorso di libc ( "/lib/x86_64-linux-gnu/libc.so.6" ) che può (e molto probabilmente, sarà) variare tra i sistemi, None (o la stringa vuota) può essere passato al costruttore CDLL ( ctypes.CDLL(None).access(b"/tmp", os.F_OK) ). Secondo [man]: DLOPEN (3) :

      Se il nome del file è NULL, l'handle restituito è per il programma principale. Quando viene assegnato a dlsym (), questo handle provoca la ricerca di un simbolo nel programma principale, seguito da tutti gli oggetti condivisi caricati all'avvio del programma e quindi tutti gli oggetti condivisi caricati da dlopen () con il flag RTLD_GLOBAL .

      • Il programma principale (corrente) ( python ) è collegato alla libc , quindi i suoi simboli (incluso l' access ) verranno caricati
      • Questo deve essere gestito con cura, poiché sono disponibili funzioni come main , Py_Main e (tutti) gli altri; chiamarli potrebbe avere effetti disastrosi (sul programma attuale)
      • Questo non vale anche per Win (ma non è un grosso problema, dato che msvcrt.dll si trova in "% SystemRoot% \ System32" che è in % PATH% per impostazione predefinita). Volevo andare oltre e replicare questo comportamento su Win (e inviare una patch), ma come risulta, la funzione [MSDN]: GetProcAddress "vede" solo i simboli esportati , quindi a meno che qualcuno dichiari le funzioni nell'eseguibile principale come __declspec(dllexport) (perché sulla Terra la persona normale lo farebbe?), il programma principale è caricabile ma praticamente inutilizzabile
  5. Installa alcuni moduli di terze parti con funzionalità di filesystem

    Molto probabilmente, si baserà su uno dei modi sopra (forse con lievi personalizzazioni).
    Un esempio potrebbe essere (ancora una volta Win specifico) [GitHub]: Python per Windows (pywin32) Extensions , che è un wrapper Python su WINAPI s.

    Ma poiché questo è più simile a una soluzione alternativa, mi fermo qui.

  6. Un'altra soluzione (lame) ( gainarie ) è (come mi piace chiamarla) l'approccio sysadmin : usare Python come wrapper per eseguire i comandi della shell

    • Vincere :

      (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
      

In conclusione :

  • Usa i blocchi try / except / else / finally , perché possono impedirti di incontrare una serie di problemi sgradevoli. Un contro-esempio che posso pensare è la performance: tali blocchi sono costosi, quindi cerca di non metterli in codice che dovrebbe funzionare centinaia di migliaia di volte al secondo (ma dal momento che (nella maggior parte dei casi) comporta l'accesso al disco, non sarà il caso).

Nota / i finale / i :

  • Cercherò di tenerlo aggiornato, ogni suggerimento è ben accetto, incorporerò tutto ciò che sarà utile nella risposta



Python 3.4+ ha un modulo di percorso orientato agli oggetti: pathlib . Usando questo nuovo modulo, puoi verificare se esiste un file come questo:

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

Puoi (e di solito dovresti) usare ancora un blocco try/except quando apri i file:

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

Il modulo pathlib ha un sacco di cose interessanti: il globbing conveniente, il controllo del proprietario del file, l'unione più facile dei percorsi, ecc. Vale la pena provarlo. Se sei su un vecchio Python (versione 2.6 o successiva), puoi ancora installare pathlib con pip:

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

Quindi importalo come segue:

# Older Python versions
import pathlib2 as pathlib



Come posso verificare se esiste un file, usando Python, senza usare una dichiarazione try?

Ora disponibile da Python 3.4, importa e istanzia un oggetto Path con il nome del file e controlla il metodo is_file (nota che questo restituisce True per i collegamenti simbolici che puntano anche a file regolari):

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

Se sei su Python 2, puoi eseguire il backport del modulo pathlib da pypi, pathlib2 , o altrimenti controlla isfile dal modulo os.path :

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

Ora quanto sopra è probabilmente la migliore risposta diretta pragmatica qui, ma c'è la possibilità di una race condition (a seconda di cosa stai cercando di ottenere), e il fatto che l'implementazione sottostante usi un try , ma Python usa try ovunque nella sua implementazione.

Poichè Python usa try ovunque, non c'è davvero alcun motivo per evitare un'implementazione che lo usa.

Ma il resto di questa risposta tenta di considerare questi avvertimenti.

Risposta più lunga, molto più pedante

Disponibile da Python 3.4, usa il nuovo oggetto Path in pathlib . Nota che .exists non è del tutto corretto, perché le directory non sono file (eccetto che nell'unix senso che tutto è un file).

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

Quindi dobbiamo usare is_file :

>>> root.is_file()
False

Ecco l'aiuto su is_file :

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

Quindi prendiamo un file che sappiamo essere un file:

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

Per impostazione predefinita, NamedTemporaryFile elimina il file quando è chiuso (e si chiude automaticamente quando non vi sono più riferimenti ad esso).

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

Se is_file l'implementazione , vedrai che 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

Condizioni di gara: perché ci piace provare

Ci piace try perché evita le condizioni di gara. Con try , si tenta semplicemente di leggere il file, aspettandosi che sia lì, e in caso contrario, si cattura l'eccezione e si esegue qualsiasi comportamento di fallback ha senso.

Se vuoi verificare che esista un file prima di tentare di leggerlo, e potresti cancellarlo e quindi potresti usare più thread o processi, o un altro programma sa di quel file e potresti eliminarlo, rischi di avere la possibilità di una condizione di competizione se la controlli esiste, perché stai correndo per aprirla prima che la sua condizione (la sua esistenza) cambi.

Le condizioni di gara sono molto difficili da eseguire il debug perché c'è una finestra molto piccola in cui possono causare il fallimento del programma.

Ma se questa è la tua motivazione, puoi ottenere il valore di una dichiarazione try usando il gestore del contesto di suppress .

Evitare le condizioni di gara senza una dichiarazione di prova: suppress

Python 3.4 ci fornisce il gestore del contesto di suppress (in precedenza il gestore di contesto ignore ), che semanticamente fa esattamente la stessa cosa in meno righe, mentre anche (almeno superficialmente) incontrando l'originale chiede di evitare un'istruzione 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()
... 
>>> 

Per i Python precedenti potresti lanciare il tuo suppress , ma senza una try sarai più prolisso che con. Credo che in realtà questa sia l'unica risposta che non usa la try a qualsiasi livello nel Python che può essere applicata a precedenti a Python 3.4 perché invece usa un gestore di contesto:

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)

Forse più facile con un tentativo:

from contextlib import contextmanager

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

Altre opzioni che non soddisfano il chiedere "senza provare":

isfile

import os
os.path.isfile(path)

dai docs :

os.path.isfile(path)

Restituisce True se path è un file regolare esistente. Questo segue collegamenti simbolici, quindi sia islink() che isfile() possono essere veri per lo stesso percorso.

Ma se esamini il source di questa funzione, vedrai che effettivamente usa una dichiarazione 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

Tutto ciò che sta facendo è usare il percorso dato per vedere se può ottenere statistiche su di esso, catturando OSError e quindi controllando se si tratta di un file se non ha sollevato l'eccezione.

Se hai intenzione di fare qualcosa con il file, ti suggerisco di provarlo direttamente con un tentativo, tranne che per evitare una condizione di gara:

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

os.access

Disponibile per Unix e Windows è os.access , ma per usare devi passare dei flag, e non differenzia tra file e directory. Questo è più utilizzato per verificare se l'utente che ha effettuato il richiamo ha accesso in un ambiente con privilegi elevati:

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

Soffre anche degli stessi problemi di condizione di gara di isfile . Dai docs :

Nota: l'uso di access () per verificare se un utente è autorizzato ad aprire un file prima di farlo in realtà usando open () crea un buco di sicurezza, poiché l'utente potrebbe sfruttare il breve intervallo di tempo tra il controllo e l'apertura del file per manipolarlo. È preferibile utilizzare le tecniche EAFP. Per esempio:

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

è meglio scritto come:

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

Evitare l'uso di os.access . È una funzione di basso livello che ha più opportunità per l'errore dell'utente rispetto agli oggetti e alle funzioni di livello superiore discussi sopra.

Critica di un'altra risposta:

Un'altra risposta dice di os.access :

Personalmente, preferisco questo perché sotto il cofano, chiama le API native (tramite "$ {PYTHON_SRC_DIR} /Modules/posixmodule.c"), ma apre anche una porta per possibili errori dell'utente, e non è così Pythonic come altre varianti :

Questa risposta dice che preferisce un metodo non-Pythonic, incline agli errori, senza giustificazione. Sembra incoraggiare gli utenti a utilizzare API di basso livello senza comprenderle.

Crea anche un gestore di contesto che, restituendo incondizionatamente True , consente a tutte le eccezioni (inclusi KeyboardInterrupt e SystemExit !) Di passare in silenzio, il che è un buon modo per nascondere i bug.

Questo sembra incoraggiare gli utenti ad adottare pratiche scorrette.




Test per file e cartelle con os.path.isfile() , os.path.isdir() e os.path.exists()

Supponendo che il "percorso" sia un percorso valido, questa tabella mostra cosa viene restituito da ciascuna funzione per file e cartelle:

Puoi anche verificare se un file è un certo tipo di file usando os.path.splitext() per ottenere l'estensione (se non lo conosci già)

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



Non sembra che ci sia una differenza funzionale significativa tra try / except e isfile() , quindi dovresti usare quale ha senso.

Se vuoi leggere un file, se esiste, fallo

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

Ma se vuoi semplicemente rinominare un file se esiste, e quindi non è necessario aprirlo, fallo

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

Se vuoi scrivere su un file, se non esiste, fallo

# 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 hai bisogno di bloccare i file, è diverso.




Anche se consiglio sempre di usare trye exceptdichiarazioni, ecco alcune possibilità per te (il mio preferito è l'utilizzo os.access):

  1. Prova ad aprire il file:

    L'apertura del file verificherà sempre l'esistenza del file. Puoi fare una funzione nello stesso modo:

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

    Se è False, interromperà l'esecuzione con un IOError o OSError non maneggiato nelle versioni successive di Python. Per cogliere l'eccezione, devi usare una clausola try try. Certo, puoi sempre usare tryun'istruzione except ecc. In questo modo (grazie a hsandt per avermi fatto pensare):

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

    Questo controllerà l'esistenza di ciò che specifichi. Tuttavia, controlla i file e le directory, quindi fai attenzione a come lo usi.

    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. Usa os.access(path, mode):

    Questo controllerà se hai accesso al file. Controllerà le autorizzazioni. Basato sulla documentazione di os.py, digitando os.F_OK, controllerà l'esistenza del percorso. Tuttavia, l'utilizzo di questo creerà un buco di sicurezza, in quanto qualcuno può attaccare il tuo file utilizzando il tempo che intercorre tra la verifica delle autorizzazioni e l'apertura del file. Dovresti invece andare direttamente ad aprire il file invece di controllarne le autorizzazioni. ( EAFP vs LBYP ). Se non hai intenzione di aprire il file in seguito, e solo verificandone l'esistenza, puoi utilizzarlo.

    Comunque, qui:

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

Dovrei anche ricordare che ci sono due modi in cui non sarai in grado di verificare l'esistenza di un file. O il problema sarà permission deniedo no such file or directory. Se ne prendi uno IOError, imposta la IOError as e(come la mia prima opzione), quindi digita in print(e.args)modo da poter eventualmente determinare il problema. Spero possa essere d'aiuto! :)




Inoltre, os.access():

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

Essere R_OK, W_OKe X_OKle flag per verificare le autorizzazioni ( doc ).




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

Aumentare le eccezioni è considerato un approccio accettabile e Pythonic per il controllo del flusso nel tuo programma. Prendi in considerazione la possibilità di gestire i file mancanti con IOErrors. In questa situazione, verrà sollevata un'eccezione IOError se il file esiste ma l'utente non dispone delle autorizzazioni di lettura.

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




Se hai importato NumPy già per altri scopi, allora non c'è bisogno di importare altre librerie come pathlib, os, paths, etc.

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

Ciò restituirà vero o falso in base alla sua esistenza.




Aggiungendo un'altra leggera variazione che non si riflette esattamente nelle altre risposte.

Questo gestirà il caso file_pathdell'essere Noneo stringa vuota.

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

Aggiunta di una variante basata sul suggerimento di Shahbaz

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

Aggiunta di una variante basata sul suggerimento di Peter Wood

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



Controlla il file o la directory esiste

Puoi seguire questi tre modi:

Nota 1: os.path.isfileutilizzata solo per i file

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

Nota 2: os.path.existsutilizzata per file e directory

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

Il pathlib.Pathmetodo (incluso in Python 3+, installabile con pip per Python 2)

from pathlib import Path
Path(filename).exists()



Puoi usare la libreria "OS" di Python:

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



Related

python file file-exists