Comment puis-je vérifier si un fichier existe sans exceptions?

Si la raison pour laquelle vous êtes la vérification de sorte que vous pouvez faire quelque chose comme if file_exists: open_it(), il est préférable d'utiliser un try autour de la tentative de l'ouvrir. Vérifier puis de l'ouverture de risques que le fichier supprimé ou déplacé, ou quelque chose entre le moment où vous passez et lorsque vous essayez de l'ouvrir.

Si vous n'avez pas l'intention d'ouvrir le fichier immédiatement, vous pouvez utiliser os.chemin d'accès.isfile

Retour True si le chemin est un fichier régulier. Cela suit les liens symboliques, de sorte que les deux islink() et isfile() peut être vrai pour le même chemin.

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

si vous avez besoin d'être sûr que c'est un fichier.

De commencer avec Python 3.4, la pathlib module propose une approche orientée-objet (reporté à pathlib2 en Python 2.7):

from pathlib import Path

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

Pour vérifier un répertoire, n':

if my_file.is_dir():
    # directory exists

Pour vérifier si un Path objet existe indépendamment de savoir si c'est un fichier ou un répertoire, utilisez exists():

if my_file.exists():
    # path exists

Vous pouvez également utiliser resolve(strict=True) dans un try bloc:

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

OriginalL'auteur rslite

Contrairement à isfile(), exists() sera de retour True pour les répertoires.

Donc, en fonction de si vous voulez que les fichiers simples ou aussi des répertoires, vous allez utiliser isfile() ou exists(). Voici un simple REPL sortie.

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

OriginalL'auteur bortzmeyer

Utilisation os.chemin d'accès.isfile() avec 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"

OriginalL'auteur Yugal Jindle

Bien que presque tous les moyens possibles ont été répertoriées dans (au moins un) de la réponse (par exemple Python 3.4 choses spécifiques, a été ajoutée), je vais essayer de groupe tout ensemble.

Note: chaque morceau de Python de la bibliothèque standard de code que je vais les poster, appartient à la version 3.5.3.

Énoncé du problème:

1. Fichier de contrôle (défendable: dossier ("spécial" fichier) ?) l'existence
2. Ne pas utiliser essayer /sauf /d'autre /enfin blocs

Solutions possibles:

1. [Python 3]: os.chemin d'accès.existe(chemin) (également consulter d'autres la fonction de membres de la famille comme os.path.isfile, os.path.isdir, os.path.lexists pour des comportements légèrement différents)

   os.path.exists(path)

   Retour True si chemin fait référence à un chemin existant ou un descripteur de fichier ouvert. Retourne False pour cassé les liens symboliques. Sur certaines plates-formes, cette fonction peut retourner False si l'autorisation n'est pas accordée à exécuter os.stat() sur le fichier demandé, même si la chemin existe physiquement.

   Tout bon, mais si la suite de l'importation de l'arbre:

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

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

   c'est juste un essayer /sauf bloc autour [Python 3]: os.stat(chemin d'accès, *, dir_fd=None, follow_symlinks=True). Ainsi, votre code est essayer /sauf libre, mais plus faible dans le framestack il y a (au moins) un un tel bloc. Ceci s'applique également à d'autres funcs (y compris os.path.isfile).

   1.1. [Python 3]: Chemin D'Accès.is_file()

   • C'est un amateur (et plus pythonic) de manipulation des chemins, mais

   • Sous le capot, il ne exactement la même chose (pathlib.py, ligne ~#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 3]: Avec L'Énoncé De Contexte Gestionnaires. Soit:

   • Créer un:

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

     • Et de son utilisation - je vais reproduire le os.path.isfile comportement (à noter que c'est juste pour la démonstration, ne pas tentative pour écrire un tel code pour production):

       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

   • Utilisation [Python 3]: contextlib.supprimer(*les exceptions) - qui a été spécifiquement conçu pour sélectivement la suppression des exceptions

   Mais, ils semblent être des wrappers sur essayer /sauf /d'autre /enfin blocs, comme [Python 3]: Le avec déclaration états:

   Cela permet essayez...sauf...enfin les schémas d'utilisation pour être encapsulé pour la pratique de la réutilisation.

3. Système de fichiers de la traversée des fonctions (et de rechercher les résultats pour l'élément correspondant(s))

   • [Python 3]: os.listdir(chemin='.') (ou [Python 3]: os.scandir(chemin='.') sur Python v3.5+, backport: [PyPI]: scandir)

     • Sous le capot, à la fois usage:

       • Nix: [man7]: fonctions opendir(3) /[man7]: READDIR(3) /[man7]: CLOSEDIR(3)
       • Gagner: [MME Docs]: FindFirstFileW fonction /[MME Docs]: FindNextFileW fonction /[MME Docs]: FindClose fonction

       via [GitHub]: python/disponible - (master) disponible/Modules/posixmodule.c

     À l'aide de scandir() au lieu de listdir() peut augmenter de manière significative la performance de code qui a aussi besoin de type de fichier ou les informations d'attribut de fichier, parce que os.DirEntry objets exposer ces informations si le système d'exploitation fournit lors de la numérisation d'un répertoire. Tous les os.DirEntry méthodes peuvent effectuer un appel système, mais is_dir() et is_file() habituellement seulement besoin d'un système d'appel pour les liens symboliques; os.DirEntry.stat() toujours besoin d'un système d'appel sur Unix, mais ne nécessite qu'un seul pour les liens symboliques sous Windows.

   • [Python 3]: os.pied(haut de la page, descendante=True, onerror=None, followlinks=False)
     • Il utilise os.listdir (os.scandir lorsque disponible)
   • [Python 3]: glob.iglob(chemin d'accès, * récursive=False) (ou son prédécesseur: glob.glob)
     • Ne semble pas une traversée de la fonction soi (au moins dans certains cas), mais il utilise quand même os.listdir

   Depuis ces itérer sur les dossiers, (dans la plupart des cas), ils sont inefficaces pour notre problème (il y a des exceptions, comme les non un caractère astérisque globbing - @ShadowRanger souligné), donc je ne vais pas insister sur eux. Pour ne pas mentionner que, dans certains cas, le nom de fichier de traitement peut être nécessaire.

4. [Python 3]: os.accès(chemin d'accès, le mode de fonctionnement, *, dir_fd=None, effective_ids=False, follow_symlinks=True) dont le comportement est proche de os.path.exists (en fait c'est plus large, principalement en raison de la 2^ème argument)

   • les autorisations de l'utilisateur pourrait peut-être limiter le fichier "visibilité" que le doc états:
     

     ...test si l'invocation de l'utilisateur a l'accès spécifié à chemin. mode devrait être F_OK pour tester l'existence d'un chemin...

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

   Depuis, je travaille également dans C, j'ai utiliser cette méthode, car sous le capot, il appelle natif APIs (encore une fois, via "${PYTHON_SRC_DIR}/Modules/posixmodule.c"), mais elle ouvre également la porte d'un possible les erreurs de l'utilisateur, et c'est pas comme Pythonic comme d'autres variantes. Donc, comme @AaronHall souligne à juste titre, de ne pas l'utiliser, sauf si vous savez ce que vous faites:

   • Nix: [man7]: l'ACCÈS(2) (!!! prêter attention à la remarque à propos de l' trou de sécurité son utilisation peut présenter !!!)
   • Gagner: [MME Docs]: GetFileAttributesW fonction

   Note: appel des indigènes APIs est également possible via [Python 3]: ctypes - Un étranger bibliothèque de fonctions pour Python, mais dans la plupart des cas, c'est plus compliqué.

   (Gagner spécifique): Depuis vcruntime* (msvcr*) .dll les exportations d'un [MME Docs]: _access, _waccess fonction de la famille, voici un exemple:

   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.notexist", os.F_OK)
   -1

   Notes:

   • Bien que ce n'est pas une bonne pratique, je suis en utilisant os.F_OK dans l'appel, mais c'est juste pour plus de clarté (sa valeur est 0)
   • Je suis en utilisant _waccess de sorte que le même code fonctionne sur Python3 et Python2 (en dépit de unicode différences liées entre elles)
   • Bien que cette cible un domaine très spécifique, il n'est pas mentionnée dans les réponses précédentes

   La Lnx (Ubtu (16 x64)) de contrepartie ainsi:

   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"/tmp.notexist", os.F_OK)
   -1

   Notes:

   • Au lieu coder en dur libc's path ("/lib/x86_64-linux-gnu/libc..6") qui peut (et probablement,) varie en fonction de l'ensemble des systèmes, Aucun (ou la chaîne vide) peut être transmis à CDLL constructeur (ctypes.CDLL(None).access(b"/tmp", os.F_OK)). Selon [man7]: DLOPEN(3):

     Si nom de fichier est NULLE, alors le handle retourné est le principal
     programme. Lorsqu'il est administré à dlsym(), cette poignée de causes à la recherche d'une
     symbole dans le programme principal, suivi par tous les objets partagés chargé à
     le démarrage du programme, et ensuite tous les objets partagés chargé par dlopen() avec
     le drapeau RTLD_GLOBAL.

     • Principal (en cours) programme (python) est liée à l'encontre de libc, de sorte que ses symboles (y compris les accès) sera chargé
     • Ce doit être manipulé avec soin, car les fonctions comme principal, Py_Main et le (tous les), d'autres sont disponibles; les appelant peut avoir des effets désastreux (sur le programme actuel)
     • Ce n'est pas aussi s'appliquer à Gagner (mais ce n'est pas une grosse affaire, depuis msvcrt.dll est situé dans "%SystemRoot%\System32" qui est en %PATH% par défaut). J'ai voulu aller plus loin et de reproduire ce comportement sur Gagner (et de soumettre un patch), mais comme il s'avère, [MME Docs]: la fonction GetProcAddress seulement "voit" exporté symboles, de sorte que si l'on déclare les fonctions dans l'exécutable principal comme __declspec(dllexport) (pourquoi sur la Terre, le régulière personne qui ferait ça?), le programme principal est chargeable mais à peu près inutilisable

5. Installer un module tiers avec le système de fichiers capacités

   Plus probable, sera de s'appuyer sur l'une des manières ci-dessus (peut-être avec une légère personnalisations).
   En est un exemple (encore une fois, Gagner spécifique) [GitHub]: mhammond/pywin32 - Python pour Windows (pywin32) Extensions, qui est un Python wrapper sur WINAPIs.

   Mais, depuis c'est plus comme une solution de contournement, j'arrête ici.

6. Un autre (lame) solution (gainarie) est (comme j'aime l'appeler), la sysadmin approche: utiliser Python comme un wrapper pour exécuter des commandes shell

   • Gagner:

     (py35x64_test) e:\Work\Dev\StackOverflow\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\StackOverflow\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

   • Nix (Lnx (Ubtu)):

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

Ligne de fond:

• Ne utilisation essayer /sauf /d'autre /enfin blocs, car ils peuvent vous empêcher de vous en cours d'exécution dans une série de méchants problèmes. Un contre-exemple qui, je pense, est de la performance: ces blocs sont coûteux, alors essayez de ne pas les placer dans le code qu'il est censé exécuter des centaines de milliers de fois par seconde (mais depuis (dans la plupart des cas), il implique l'accès au disque, il ne sera pas le cas).

Note finale(s):

• Je vais essayer de le tenir à jour, toutes les suggestions sont les bienvenues, je vais intégrer quelque chose d'utile qui va venir dans la réponse

OriginalL'auteur CristiFati

Python 3.4+ a orienté objet module path: pathlib. L'utilisation de ce nouveau module, vous pouvez vérifier si un fichier existe comme ceci:

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

Vous pouvez (et devriez) toujours utiliser un try/except bloc lors de l'ouverture de fichiers:

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

La pathlib module a plein de trucs sympas dans: pratique d'expansion, la vérification propriétaire du fichier, le chemin plus facile de rejoindre, etc. Il vaut la peine de vérifier. Si vous êtes sur une ancienne Python (version 2.6 ou version ultérieure), vous pouvez toujours installer pathlib avec pip:

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

Puis de l'importer comme suit:

# Older Python versions
import pathlib2 as pathlib

OriginalL'auteur Cody Piersall

Comment puis-je vérifier si un fichier existe, à l'aide de Python, sans l'aide d'une instruction try?

Maintenant disponible depuis Python 3.4, l'importation et l'instancier un Path de l'objet avec le nom de fichier, et de vérifier le is_file méthode (notez que cela renvoie Vrai pour les liens symboliques pointant vers des fichiers normaux):

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

Si vous êtes sur Python 2, vous pouvez backport la pathlib module de pypi, pathlib2, ou sinon vérifier isfile de la os.path module:

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

Maintenant, le ci-dessus est probablement le meilleur pragmatique directe de réponse ici, mais il y a la possibilité d'une condition de concurrence (en fonction de ce que vous essayez d'accomplir), et le fait que l'implémentation sous-jacente utilise un try, mais Python utilise try partout dans sa mise en œuvre.

Parce que Python utilise try partout, il n'y a vraiment pas de raison pour éviter une mise en œuvre qui l'utilise.

Mais le reste de cette réponse tente de tenir compte de ces mises en garde.

Plus, beaucoup plus pédant réponse

Disponibles depuis le Python 3.4, l'utilisation de la nouvelle Path objet dans pathlib. Notez que .exists n'est pas tout à fait le droit, parce que les répertoires ne sont pas des fichiers (sauf dans le unix sens que tout est un fichier).

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

Nous avons donc besoin d'utiliser is_file:

>>> root.is_file()
False

Ici de l'aide sur is_file:

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

Prenons donc un fichier que nous savons, c'est un fichier:

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

Par défaut, NamedTemporaryFile supprime le fichier quand il est fermé (et se ferment automatiquement lorsque toutes les références existent).

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

Si vous creusez dans la mise en œuvre, cependant, vous verrez que is_file utilise 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

Des Conditions de course: Pourquoi nous aimons essayer

Nous comme try car elle évite des conditions de course. Avec try, vous essayez simplement de lire votre fichier, s'attendant à être là, et si non, vous intercepter l'exception et effectuer que les secours comportement de sens.

Si vous voulez vérifier qu'un fichier existe avant de tenter de le lire, et vous pourriez être le supprimer et alors vous pourriez être en utilisant plusieurs threads ou processus, ou un autre programme sait à propos de ce fichier et peut les supprimer, vous risquez de le un condition de course si vous vérifiez qu'il existe, parce que vous êtes alors de course l'ouvrir avant son condition (de son existence) des changements.

Conditions de course sont très difficiles à déboguer parce qu'il y a une très petite fenêtre dans laquelle ils peuvent causer votre programme à l'échec.

Mais si c'est votre motivation, vous peut obtenir la valeur d'un try déclaration à l'aide de la suppress gestionnaire de contexte.

Éviter des conditions de course sans une instruction try: suppress

Python 3.4, nous donne la supprimer gestionnaire de contexte (auparavant le ignorer gestionnaire de contexte), qui ne sémantiquement exactement la même chose en moins de lignes, mais aussi (au moins superficiellement) la satisfaction de la demande initiale afin d'éviter une try déclaration:

from contextlib import suppress
from pathlib import Path

Utilisation:

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

Plus tôt Pythons, vous pouvez rouler vos propres suppress, mais sans try sera plus bavarde que avec. Je ne crois c'est vraiment la seule réponse qui n'utilise pas try à tout niveau dans le Python qui peut être appliqué avant le Python 3.4, car il utilise un gestionnaire de contexte à la place:

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)

Peut-être plus facile avec un essai:

from contextlib import contextmanager

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

D'autres options qui ne répondent pas à la demande", sans essayer":

isfile

import os
os.path.isfile(path)

de la docs:

os.path.isfile(path)

Retourne True si le chemin est un fichier régulier. Ce qui suit symbolique
des liens, de sorte que les deux islink() et isfile() peut être vrai pour le même chemin.

Mais si vous examinez les source de cette fonction, vous verrez qu'il ne fait d'utiliser une instruction 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

Ca fais utilisant le chemin d'accès donné pour voir si elle peut obtenir des statistiques sur elle, la capture de OSError et puis de vérifier si c'est un fichier si il n'a pas de soulever l'exception.

Si vous avez l'intention de faire quelque chose avec le fichier, je voudrais suggérer directement essayer avec un essai, sauf pour éviter une condition de course:

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

os.l'accès

Disponibles pour Unix et Windows est os.access, mais pour l'utiliser, vous devez passer les drapeaux, et il ne fait pas de distinction entre les fichiers et les répertoires. C'est plus utilisé pour tester si le réel en invoquant l'utilisateur a accès à une élévation de privilège de l'environnement:

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

Il souffre également de la même condition de course des problèmes comme isfile. À partir de la docs:

Note:
À l'aide de access() pour vérifier si un utilisateur est autorisé à ouvrir un fichier
avant de le faire à l'aide de open() crée un trou de sécurité, parce que
l'utilisateur peut exploiter le peu de temps d'intervalle entre la vérification et l'
ouvrir le fichier pour le manipuler. Il est préférable d'utiliser l'aeap
des techniques. Par exemple:

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

est mieux écrit que:

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

Éviter d'utiliser os.access. C'est un faible niveau de fonction qui a plus de possibilités pour l'utilisateur d'erreur que les objets de niveau supérieur et les fonctions évoquées ci-dessus.

La critique d'une autre réponse:

Une autre réponse, dit ceci à propos de os.access:

Personnellement, je préfère celui-ci car sous le capot, il appelle les Api natives (via "${PYTHON_SRC_DIR}/Modules/posixmodule.c"), mais il ouvre également une porte pour d'éventuelles erreurs de l'utilisateur, et il n'est pas Pythonic que d'autres variantes:

Cette réponse, dit-il préfère un non-Pythonic, le risque d'erreur de méthode, sans aucune justification. Il semble encourager les utilisateurs à utiliser les APIs bas-niveau sans les comprendre.

Il crée également un gestionnaire de contexte qui, par la reprise inconditionnelle True, permet à toutes les Exceptions (y compris les KeyboardInterrupt et SystemExit!) pour passer en mode silencieux, ce qui est un bon moyen de cacher des bugs.

Ce qui semble encourager les utilisateurs à adopter de mauvaises pratiques.

OriginalL'auteur Aaron Hall

Tests pour les fichiers et les dossiers avec os.path.isfile(), os.path.isdir() et os.path.exists()

En supposant que le "chemin" est un chemin d'accès valide, ce tableau nous montre ce qui est retourné par chaque fonction pour les fichiers et les dossiers:

Vous pouvez également tester si un fichier est un type de fichier à l'aide de os.path.splitext() pour obtenir l'extension (si vous ne la connaissez pas déjà)

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

OriginalL'auteur Tom Fuller

Il ne semble pas comme il y a une véritable différence fonctionnelle entre les try/except et isfile(), de sorte que vous devriez utiliser qui on fait un sens.

Si vous voulez lire un fichier, s'il existe, ne

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

Mais si vous voulais juste renommer le fichier si le fichier existe, et n'ont donc pas besoin de l'ouvrir, ne

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

Si vous voulez écrire dans un fichier, s'il n'existe pas, ne

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

Si vous avez besoin d'un fichier de verrouillage, c'est une autre affaire.

OriginalL'auteur chad

Bien que je recommande toujours à l'aide de try et except déclarations, voici quelques possibilités pour vous (mon favori personnel est à l'aide de os.access):

1. Essayer d'ouvrir le fichier:

   De l'ouverture du fichier sera toujours vérifier l'existence du fichier. Vous pouvez faire une fonction comme:

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

   Si c'est Faux, il va arrêter l'exécution avec un unhanded IOError
   ou OSError dans les versions ultérieures de Python. Pour intercepter l'exception,
   vous devez utiliser un essai à l'exception de la clause. Bien sûr, vous pouvez toujours
   utiliser un try à l'exception de l'énoncé comme (grâce à hsandt
   pour me faire penser):

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

2. Utilisation os.path.exists(path):

   Il s'agira de vérifier l'existence de ce que vous spécifiez. Cependant, il vérifie les fichiers et répertoires méfiez-vous donc sur la façon dont vous l'utiliser.

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

   Cela permettra de vérifier si vous avez accès au fichier. Il va vérifier les autorisations. Basé sur le os.py la documentation, en tapant dans os.F_OK, il va vérifier l'existence de la voie. Cependant, l'utilisation de ce va créer un trou de sécurité, que l'on peut attaquer votre fichier en utilisant le temps de vérifier les autorisations et l'ouverture du fichier. Vous devriez plutôt aller directement à l'ouverture du fichier au lieu de vérifier les permissions. (L'aeap vs LBYP). Si vous n'allez pas ouvrir le fichier par la suite, et la seule vérification de son existence, alors vous pouvez utiliser ce.

   De toute façon, ici:

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

Je dois aussi mentionner qu'il y a deux façons que vous ne serez pas en mesure de vérifier l'existence d'un fichier. La question sera permission denied ou no such file or directory. Si vous attrapez un IOError, définir la IOError as e (comme pour ma première option), puis tapez dans print(e.args) de sorte que vous pouvez espérer de déterminer votre problème. J'espère que cela aide! 🙂

OriginalL'auteur Zizouz212

En Python 3.4 la langue fournit un nouveau module pour gérer les fichiers:

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.

OriginalL'auteur Unai Sainz de la Maza

Si le fichier est pour l'ouverture, vous pouvez utiliser une des techniques suivantes:

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

---

Mise à JOUR

Juste pour éviter la confusion et sur la base des réponses que j'ai eu, réponse actuelle trouve un fichier ou un répertoire avec le nom donné.

OriginalL'auteur bergercookie

Vous pouvez écrire de Brian suggestion sans try:.

from contextlib import suppress

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

suppress est partie de Python 3.4. Dans les anciennes versions, vous pouvez écrire rapidement vos propres supprimer:

from contextlib import contextmanager

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

OriginalL'auteur Chris

Vérifier le fichier ou le répertoire existe

Vous pouvez suivre ces trois façons:

Note1: Le os.path.isfile utilisé uniquement pour les fichiers

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

Note2: Le os.path.exists utilisé pour les fichiers et les répertoires

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

La pathlib.Path méthode (inclus dans Python 3+, installable avec le pip pour Python 2)

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

OriginalL'auteur Ali Hallaji

Je suis l'auteur d'un paquet qui a été autour depuis environ 10 ans, et il a une fonction qui répond à cette question directement. En gros, si vous êtes sur un non-système de Windows, il utilise Popen pour accéder à find. Toutefois, si vous êtes sur Windows, il réplique find avec un efficace système de fichiers walker.

Le code lui-même n'utilise pas de try bloc... à l'exception de déterminer le système d'exploitation et ainsi de pilotage vous à la "Unix"style find ou de la main-buillt find. Calendrier des tests ont montré que la try a été plus rapide dans la détermination de l'OS, donc j'ai utilisé un il y a (mais nulle part ailleurs).

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

Et le 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']

>>>

La mise en œuvre, si vous vous souciez de regarder, c'est ici:
https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190

OriginalL'auteur Mike McKerns

Vous pouvez utiliser les "OS" de la bibliothèque de Python:

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

OriginalL'auteur Pradip Das