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




python rename file (20)

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.

https://code.i-harness.com

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


Come posso verificare se esiste un file, senza usare la dichiarazione try?

Nel 2016, questo è ancora discutibilmente il modo più semplice per verificare se esiste un file e se si tratta di un file:

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

isfileè in realtà solo un metodo di supporto che utilizza internamente os.state al di stat.S_ISREG(mode)sotto. Questo os.statè un metodo di livello inferiore che ti fornirà informazioni dettagliate su file, directory, socket, buffer e altro. Maggiori informazioni su os.stat qui

Nota: tuttavia, questo approccio non bloccherà il file in alcun modo e pertanto il codice potrebbe diventare vulnerabile agli errori " time of check to time of use " ( TOCTTOU ).

Quindi sollevare le eccezioni è considerato un approccio accettabile e Pythonic per il controllo del flusso nel tuo programma. E si dovrebbe considerare la gestione dei file mancanti con IOErrors, piuttosto che le ifdichiarazioni ( solo un consiglio ).


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

Hai la funzione os.path.exists :

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

Questo restituisce True per entrambi i file e le directory, ma puoi invece usarlo

os.path.isfile(file_path)

per verificare se si tratta di un file specifico. Segue i collegamenti simbolici.


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.


Potresti provare questo (più sicuro):

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

L'uscita sarebbe:

([Errno 2] Nessun file o directory di questo tipo: 'whatever.txt')

Quindi, a seconda del risultato, il tuo programma può semplicemente continuare a funzionare da lì o puoi codificarlo per fermarlo se vuoi.


Questo è il modo più semplice per verificare se esiste un file. Solo perché il file esisteva quando hai controllato non garantisce che sarà lì quando è necessario aprirlo.

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

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

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

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

Data: 2017/12/04

Ogni possibile soluzione è stata elencata in altre risposte.

Un modo intuitivo e discutibile per verificare se un file esiste è il seguente:

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

Ho fatto un cheatsheet esaustivo per il vostro riferimento:

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

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

Se il file è aperto, puoi utilizzare una delle seguenti tecniche:

>>> 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!')

AGGIORNARE

Giusto per evitare confusione e basato sulle risposte che ho ottenuto, la risposta corrente trova o un file o una directory con il nome dato.


Ecco un comando Python a 1 riga per l'ambiente della riga di comando di Linux. Trovo questo MOLTO HANDY dal momento che non sono un tipo Bash così sexy.

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

Spero che questo sia utile.


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


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.


Sono l'autore di un pacchetto che esiste da circa 10 anni e ha una funzione che risponde direttamente a questa domanda. In sostanza, se si utilizza un sistema non Windows, viene utilizzato Popenper accedere find. Tuttavia, se si è su Windows, si replica findcon un efficiente walker del filesystem.

Il codice in sé non usa un tryblocco ... tranne che nel determinare il sistema operativo e quindi findguidarti allo stile "Unix" o al hand-buillt find. I test di cronometraggio hanno dimostrato che il trysistema operativo era più veloce nel determinare il SO, quindi ne ho usato uno lì (ma da nessun'altra parte).

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

E il 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']

>>>

L'implementazione, se ti interessa guardare, è qui: https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190


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

L'importazione di os semplifica la navigazione e l'esecuzione di azioni standard con il tuo sistema operativo.

Per riferimento vedi anche share

Se hai bisogno di operazioni di alto livello, usa 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