it-swarm-eu.dev

Come posso verificare se un file esiste senza eccezioni?

Come faccio a vedere se un file esiste o no, senza usare il comando try statement?

4981
spence91

Se il motivo che stai controllando è così che puoi fare qualcosa come if file_exists: open_it(), è più sicuro usare un try attorno al tentativo di aprirlo. 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 usare os.path.isfile

Restituisce True se path è un file regolare esistente. Questo segue collegamenti simbolici, quindi entrambi islink () e isfile () può essere vero 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(strict=True) in un blocco try:

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

Hai la funzione os.path.exists :

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

Ciò 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.

1913
PierreBdR

A differenza di isfile() , exists() restituirà True per le directory.
Quindi, a seconda se vuoi solo file normali o anche directory, userai isfile() o exists(). Ecco un semplice REPL output.

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

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

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

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
132
Cody Piersall

Preferisco la dichiarazione try. È considerato uno stile migliore ed evita le condizioni di gara.

Non prendere la mia parola per questo. C'è un sacco di supporto per questa teoria. Ecco una coppia:

116
pkoch
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 Come verificare se esiste un file usando Python?

Se hai bisogno di operazioni di alto livello, usa shutil.

82
bishop

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:

 enter image description here

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
75
Tom Fuller

Nel 2016 il modo migliore è ancora utilizzare os.path.isfile:

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

Oppure in Python 3 puoi usare pathlib:

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

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.

62
chad

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.

53
philberndt

Anche se consiglio sempre di usare le dichiarazioni try e except, ecco alcune possibilità per te (il mio preferito è usare 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 un'istruzione try except` in questo modo (grazie a hsandt per farmi 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 file e 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. Sulla base della documentazione 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.

    Ad ogni modo, qui:

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

Vorrei 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 denied o no such file or directory. Se si cattura un IOError, impostare IOError as e (come la mia prima opzione), quindi digitare print(e.args) in modo da poter determinare il problema. Spero possa essere d'aiuto! :)

48
Zizouz212

Data: 2017/12/04

Ogni possibile soluzione è stata elencata in altre risposte.

Un modo intuitivo e discutibile per verificare se esiste un file è 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 esauriente 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']}
42
JawSaw

Inoltre, os.access():

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

Essere R_OK, W_OK e X_OK i flag per verificare le autorizzazioni ( doc ).

32
zgoda

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

UPDATE

Giusto per evitare confusione e in base alle risposte che ho ottenuto, la risposta corrente trova una directory file o a con il nome specificato.

30
bergercookie
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. Considerare la gestione dei 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

20
Pedro Lobito

Puoi scrivere il suggerimento di Brian senza try:.

from contextlib import suppress

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

suppress fa parte di Python 3.4. Nelle versioni precedenti è possibile scrivere rapidamente la propria eliminazione:

from contextlib import contextmanager

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

Se hai già importato NumPy per altri scopi, non è necessario importare altre librerie come pathlib, os, paths, ecc.

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

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

17
durjoy

Controlla il file o la directory esiste

Puoi seguire questi tre modi:

Nota 1: os.path.isfile utilizzato solo per i file

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

Nota2: os.path.exists utilizzato per file e directory

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

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

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

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

Questo gestirà il caso in cui file_path sia None o 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):
15
Marcel Wilson

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, utilizza Popen per accedere a find. Tuttavia, se sei su Windows, replica find con un efficiente walker del filesystem.

Il codice stesso non usa un blocco try ... tranne nel determinare il sistema operativo e quindi indirizzarti allo stile "Unix" find o al hand-buillt find. I test di temporizzazione hanno mostrato che try era più veloce nel determinare il sistema operativo, 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

15
Mike McKerns

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.

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 internamente utilizza os.stat e 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. Ulteriori informazioni su os.stat qui

Nota: Tuttavia, questo approccio non bloccherà il file in alcun modo e quindi il tuo codice può diventare vulnerabile a " ora di controllo al momento dell'uso " (TOCTTOU) bug.

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 istruzioni if (solo un consiglio).

11
Inconnu

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

È possibile utilizzare il seguente metodo aperto per verificare se un file esiste + leggibile:

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"

Questo è utile quando si controllano diversi file. O vuoi fare un punto di intersezione/sottrazione con un elenco esistente.

8
Jesvin Jose

Per verificare se esiste un file,

from sys import argv

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

È possibile utilizzare os.listdir per verificare se un file si trova in una determinata directory.

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

Fondamentalmente un controllo di cartella, quindi un controllo di file con il separatore di directory appropriato usando os.path.join .

4

Dovresti assolutamente usare questo.

from os.path import exists

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

Non è necessario probabilmente, ma se lo è, ecco un po 'di codice

import os

def file_exists(path, filename):
    for file_or_folder in os.listdir(path):
        if file_or_folder == filename:
            return True
    return False