supprimer - voir si un dossier existe python




Comment vérifier si un fichier existe sans exception? (20)

Comment voir si un fichier existe ou non, sans utiliser l'instruction try ?


Comment vérifier si un fichier existe en utilisant Python sans utiliser une instruction try?

Désormais disponible depuis Python 3.4, importez et instanciez un objet Path avec le nom du fichier et vérifiez la méthode is_file (notez que cela renvoie True pour les liens symboliques pointant également 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 utilisez Python 2, vous pouvez effectuer un backport du module pathlib depuis pypi, pathlib2 , ou bien vérifier le isfile depuis le module os.path :

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

Maintenant, ce qui précède est probablement la meilleure réponse directe pragmatique ici, mais il est possible qu’une condition de concurrence critique (en fonction de ce que vous essayez d’accomplir) et du fait que l’implémentation sous-jacente utilise un try , mais Python utilise cet try partout. la mise en oeuvre.

Comme Python utilise try partout, il n’ya aucune raison d’éviter une implémentation qui l’utilise.

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

Réponse plus longue, beaucoup plus pédante

Disponible depuis Python 3.4, utilisez le nouvel objet Path dans pathlib . Notez que .exists n’est pas tout à fait correct, car les répertoires ne sont pas des fichiers (sauf au sens unix où tout est un fichier).

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

Nous devons donc utiliser is_file :

>>> root.is_file()
False

Voici l'aide sur is_file :

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

Alors prenons un fichier que nous savons être 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 lorsqu'il est fermé (et se ferme automatiquement lorsqu'il n'y a plus de références).

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

Si vous creusez dans l'implémentation , 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

Conditions de course: Pourquoi nous aimons essayer

Nous aimons try car cela évite les conditions de course. Avec try , vous essayez simplement de lire votre fichier, en s’attendant à ce qu’il soit présent. Sinon, vous interceptez l’exception et appliquez le comportement de remplacement qui vous semble logique.

Si vous voulez vérifier qu'un fichier existe avant de tenter de le lire, que vous voulez peut-être le supprimer, vous utilisez peut-être plusieurs threads ou processus, ou qu'un autre programme est au courant de ce fichier et peut le supprimer - vous courez le risque de une condition de concurrence critique si vous vérifiez qu'elle existe, car vous tentez de l'ouvrir avant que sa condition (son existence) ne soit modifiée.

Les conditions de course sont très difficiles à déboguer car il existe une très petite fenêtre dans laquelle elles peuvent entraîner l'échec de votre programme.

Mais si telle est votre motivation, vous pouvez obtenir la valeur d'une instruction try en utilisant le gestionnaire de contexte de suppress .

Eviter les conditions de course sans déclaration try: suppress

Python 3.4 nous donne le gestionnaire de contexte de suppress (anciennement le gestionnaire de contexte ignore ), qui effectue la même chose de manière sémantique exactement en moins de lignes, tout en répondant (au moins superficiellement) à la demande initiale pour éviter une instruction try :

from contextlib import suppress
from pathlib import Path

Usage:

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

Pour les Pythons antérieurs, vous pouvez lancer votre propre suppress , mais sans try il sera plus détaillé que avec. Je pense que c'est en fait la seule réponse qui n'utilise pas try à aucun niveau du Python auquel on peut appliquer avant Python 3.4 car il utilise plutôt un gestionnaire de contexte:

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

Autres options qui ne répondent pas à la demande "sans essayer":

isfile

import os
os.path.isfile(path)

des docs :

os.path.isfile(path)

Renvoie True si path est un fichier régulier existant. Cela suit les liens symboliques, ainsi islink() et isfile() peuvent être vrais pour le même chemin.

Mais si vous examinez la source de cette fonction, vous verrez qu'elle utilise effectivement 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

Tout ce qu'il fait, c'est utiliser le chemin indiqué pour voir s'il peut obtenir des statistiques, capturer OSError puis vérifier s'il s'agit d'un fichier s'il n'a pas OSError exception.

Si vous avez l'intention de faire quelque chose avec le fichier, je suggérerais de le tenter directement avec un essai, sauf pour éviter une situation de concurrence critique:

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

os.access

os.access est disponible pour Unix et Windows, mais pour l'utiliser, vous devez passer des indicateurs et ne faire aucune distinction entre les fichiers et les répertoires. Ceci est plus utilisé pour tester si l'utilisateur invoquant réel a accès dans un environnement à privilèges élevés:

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

Il souffre également des mêmes problèmes de condition de course que isfile . De la docs :

Remarque: utiliser access () pour vérifier si un utilisateur est autorisé, par exemple, à ouvrir un fichier avant de le faire, utiliser open () crée un trou de sécurité, car il se peut qu’il exploite le court intervalle entre la vérification et l’ouverture du fichier pour le manipuler. Il est préférable d'utiliser les techniques EAFP. Par exemple:

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

est mieux écrit comme:

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

Évitez d'utiliser os.access . Il s’agit d’une fonction de bas niveau offrant plus d’occasions d’erreur utilisateur que les objets et fonctions de niveau supérieur décrits ci-dessus.

Critique d'une autre réponse:

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

Personnellement, je préfère celui-ci car, à l’état du capot, il appelle des API natives (via "$ {PYTHON_SRC_DIR} /Modules/posixmodule.c"), mais il ouvre également une porte pour éviter les erreurs éventuelles des utilisateurs, et il n’est pas aussi pythonique que d’autres variantes. :

Cette réponse indique qu'elle préfère une méthode non pythonique, sujette aux erreurs, sans justification. Cela semble encourager les utilisateurs à utiliser des API de bas niveau sans les comprendre.

Il crée également un gestionnaire de contexte qui, en renvoyant inconditionnellement True , permet à toutes les exceptions (y compris KeyboardInterrupt et SystemExit !) De passer en mode silencieux, ce qui est un bon moyen de masquer les bogues.

Cela semble encourager les utilisateurs à adopter de mauvaises pratiques.


Comment vérifier si un fichier existe sans utiliser l'instruction try?

En 2016, c'est toujours le moyen le plus simple de vérifier si un fichier existe et s'il s'agit d'un fichier:

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

isfileest en fait juste une méthode d'assistance qui utilise en interne os.statet en stat.S_ISREG(mode)dessous. Il os.stats'agit d'une méthode de niveau inférieur qui vous fournira des informations détaillées sur les fichiers, les répertoires, les sockets, les tampons, etc. Plus d'informations sur os.stat ici

Note: Cependant, cette approche ne se verrouille pas le fichier en aucune façon et donc votre code peut devenir vulnérable à « moment de l' enregistrement en temps d'utilisation » ( TOCTTOU bogues).

Donc, lever des exceptions est considéré comme une approche acceptable, et Pythonic, pour le contrôle de flux dans votre programme. Et on devrait envisager de traiter les fichiers manquants avec IOErrors, plutôt que des ifdéclarations ( juste un conseil ).


C'est le moyen le plus simple de vérifier si un fichier existe. Ce n’est pas parce que le fichier existait lorsque vous avez coché que vous pourrez l’ouvrir lorsque vous aurez besoin de l’ouvrir.

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

Contrairement à isfile() , isfile() renverra True pour les répertoires.
Donc, selon que vous souhaitiez uniquement des fichiers simples ou également des répertoires, vous utiliserez isfile() ou isfile() exists() . Voici une sortie REPL simple.

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

Il ne semble pas y avoir de différence fonctionnelle significative entre try / except et isfile() , vous devez donc utiliser celle qui a du sens.

Si vous voulez lire un fichier, s’il existe, faites

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

Mais si vous voulez juste renommer un fichier s’il existe et que vous n’avez 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 encore, faites

# 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 verrouillage de fichier, c'est une autre affaire.



Test de fichiers et de dossiers avec os.path.isfile() , os.path.isdir() et os.path.exists()

En supposant que le "chemin" soit un chemin valide, ce tableau indique ce qui est renvoyé par chaque fonction pour les fichiers et les dossiers:

Vous pouvez également tester si un fichier est un certain type de fichier en utilisant os.path.splitext() pour obtenir l'extension (si vous ne le 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

Utilisez os.path.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"

2017/12/22 :

Bien que presque toutes les solutions possibles aient été répertoriées dans (au moins une des) réponses existantes (par exemple, des éléments spécifiques à Python 3.4 ont été ajoutés), je vais essayer de tout regrouper.

Remarque : chaque morceau de code de bibliothèque standard Python que je vais publier appartient à la version 3.5.3 (les citations doc sont spécifiques à la version 3 ).

Déclaration du problème :

  1. Vérifier le fichier ( argumentable : aussi le dossier (fichier "spécial")?)
  2. Ne pas utiliser les blocs try / except / else / finally

Solutions possibles :

  1. [Python]: os.path. existe ( chemin ) (vérifiez également les autres membres de la famille de fonctions comme os.path.isfile , os.path.isdir , os.path.lexists pour des comportements légèrement différents)

    os.path.exists(path)
    

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

    Tout va bien, mais si vous suivez l'arbre d'importation:

    • 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 bloc try/except autour de os.stat() os.stat() . Donc, votre code est try/except free, mais plus bas dans le framestack, il y a (au moins) un tel bloc. Ceci s'applique également à d'autres fonctions ( y compris os.path.isfile ).

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

    • C’est un moyen plus sophistiqué (et plus python ic) de gérer les chemins, mais
    • Sous le capot, il fait exactement la même chose ( 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]: Avec les gestionnaires de contexte d'instruction . Non plus:

    • Créer une:

      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 son utilisation - je vais reproduire le comportement du isfile (notez qu'il s'agit simplement d'une démonstration, n'essayez pas d'écrire un tel code pour la 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
        
    • Utilisez [Python]: contextlib. supprime ( * exceptions ) - spécialement conçu pour supprimer sélectivement les exceptions


    Mais, ils semblent être des wrappers sur try/except/else/finally , comme [Python]: L'instruction with déclare:

    Cela permet d' try ... except ... finally ... les modèles d'utilisation soient encapsulés pour une réutilisation pratique.

  3. Fonctions de parcours du système de fichiers (et recherche dans les résultats pour les éléments correspondants)


    Comme ils parcourent les dossiers (dans la plupart des cas), ils sont inefficaces pour notre problème (il y a des exceptions, comme un globing non générique - comme l'a souligné @ShadowRanger), je ne vais donc pas insister dessus. Sans oublier que dans certains cas, le traitement du nom de fichier peut être requis.

  4. [Python]: os. access ( chemin, mode, *, dir_fd = None, effective_ids = False, follow_symlinks = True ) dont le comportement est proche de os.path.exists (en réalité, il est plus large, principalement à cause du deuxième argument)

    • les autorisations des utilisateurs peuvent limiter la "visibilité" du fichier comme indiqué dans le document:

      ... teste si l'utilisateur appelant dispose de l'accès spécifié au chemin . le mode devrait être F_OK pour tester l'existence du chemin ...

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

    Depuis que je travaille aussi en C , j’utilise cette méthode aussi parce que sous le capot, elle appelle les API natives (à nouveau, via "$ {PYTHON_SRC_DIR} /Modules/posixmodule.c" ), mais ouvre également une porte pour les utilisateurs éventuels . erreurs , et ce n'est pas aussi Python ic que d'autres variantes. Donc, comme l'a souligné à juste titre @AaronHall, ne l'utilisez pas si vous ne savez pas ce que vous faites:

    Remarque : l'appel des API natives est également possible via [Python]: ctypes - Une bibliothèque de fonctions étrangères pour Python , mais dans la plupart des cas, c'est plus compliqué.

    (Spécifique à Windows ): msvcr * ( vcruntime * ) exportant également une famille de fonctions [MSDN]: _access, _waccess , 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", os.F_OK)
    -1
    

    Notes :

    • Bien que ce ne soit pas une bonne pratique, j'utilise os.F_OK dans l'appel, mais c'est pour plus de clarté (sa valeur est 0 )
    • J'utilise _waccess pour que le même code fonctionne sur Python3 et Python2 (malgré les différences liées à Unicode entre eux)
    • Bien que cela concerne un domaine très spécifique, cela n’a été mentionné dans aucune des réponses précédentes.


    La contrepartie Lnx ( Ubtu (16 x64) ) également:

    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
    

    Notes :

    • Au lieu de cela, codez en dur le chemin de libc ( "/lib/x86_64-linux-gnu/libc.so.6" ) qui peut (et le plus probablement, varier) d’un système à l’autre, None (ou la chaîne vide) ne peut être passé au constructeur CDLL ( ctypes.CDLL(None).access(b"/tmp", os.F_OK) ). D'après [homme]: DLOPEN (3) :

      Si le nom de fichier est NULL, le descripteur renvoyé est destiné au programme principal. Lorsqu'il est attribué à dlsym (), ce descripteur provoque la recherche d'un symbole dans le programme principal, suivi de tous les objets partagés chargés au démarrage du programme, puis de tous les objets partagés chargés par dlopen () avec l'indicateur RTLD_GLOBAL .

      • Le programme principal (actuel) ( python ) est lié à la bibliothèque , donc ses symboles (y compris l' access ) seront chargés
      • Ceci doit être manipulé avec précaution, car des fonctions comme main , Py_Main et (toutes les) autres sont disponibles; les appeler pourrait avoir des effets désastreux (sur le programme actuel)
      • Cela ne s'applique pas également à Win (mais ce n'est pas si grave, car msvcrt.dll se trouve dans "% SystemRoot% \ System32", qui se trouve par défaut dans % PATH% ). Je voulais aller plus loin et reproduire ce comportement sous Windows (et soumettre un correctif), mais il se trouve que [MSDN]: la fonction GetProcAddress "ne voit" que les symboles exportés . Par conséquent, à moins que quelqu'un ne déclare les fonctions dans l'exécutable principal sous la forme __declspec(dllexport) (pourquoi donc la personne ordinaire ferait-elle cela?), le programme principal est chargeable mais pratiquement inutilisable
  5. Installer un module tiers avec des capacités de système de fichiers

    Très probablement, utilisera l'une des méthodes ci-dessus (peut-être avec de légères personnalisations).
    Un exemple serait (encore une fois, spécifique à Win ) [GitHub]: extensions Python pour Windows (pywin32) , qui est un wrapper Python sur WINAPI .

    Mais, puisque cela ressemble plus à une solution de contournement, je m'arrête ici.

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

    • Win :

      (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
      

Ligne de fond :

  • Utilisez les blocs try / except / else / finally , car ils peuvent vous éviter une série de problèmes désagréables. La performance est un contre-exemple auquel je peux penser: de tels blocs sont coûteux, alors essayez de ne pas les placer dans un code censé être exécuté des centaines de milliers de fois par seconde (mais dans la plupart des cas, cela implique un accès au disque, ce ne sera pas le cas).

Note finale :

  • Je vais essayer de le tenir à jour, toutes les suggestions sont les bienvenues, je vais incorporer tout ce qui est utile qui viendra dans la réponse

Python 3.4+ a un module de chemin orienté objet: pathlib . En utilisant 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 normalement) continuer à utiliser un bloc try/except lors de l'ouverture de fichiers:

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

Le module pathlib contient de nombreux éléments intéressants: un agrandissement pratique, la vérification du propriétaire du fichier, la jonction plus facile du chemin, etc. Cela vaut la peine de vérifier. Si vous utilisez un ancien Python (version 2.6 ou 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 importez-le comme suit:

# Older Python versions
import pathlib2 as pathlib

Dans Python 3.4, le langage 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.

Date: 2017-12-04

Toutes les solutions possibles ont été énumérées dans d’autres réponses.

Voici un moyen intuitif et discutable de vérifier l’existence d’un fichier:

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

J'ai fait une feuille de triche exhaustive pour votre référence:

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

Vous pouvez essayer ceci (plus sûr):

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

La sortie serait:

([Errno 2] Aucun fichier ni répertoire de ce type: 'quel que soit le type de fichier')

Ensuite, en fonction du résultat, votre programme peut simplement continuer à partir de là ou vous pouvez programmer pour l’arrêter si vous le souhaitez.


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

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

De plus os.access():

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

Être R_OK, W_OKet X_OKles drapeaux pour tester les autorisations ( doc ).


Je suis l'auteur d'un package qui existe depuis environ 10 ans et dont la fonction répond directement à cette question. Fondamentalement, si vous utilisez un système autre que Windows, il utilise Popenpour y accéder find. Cependant, si vous êtes sous Windows, il se réplique findavec un système de fichiers efficace.

Le code lui-même n'utilise pas de trybloc ... sauf pour déterminer le système d'exploitation et ainsi vous diriger vers le style "Unix" findou le hand-buillt find. Les tests de synchronisation ont montré que le trysystème d'exploitation était plus rapide à déterminer, alors j'en ai utilisé un ici (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 souhaitez regarder, est ici: https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190


Voici une commande Python d'une ligne pour l'environnement de ligne de commande Linux. Je trouve cela TRÈS HANDY puisque je ne suis pas un type Bash aussi sexy.

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

J'espère que ceci est utile.


Vous pouvez écrire la suggestion de Brian sans le try:.

from contextlib import suppress

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

suppressfait partie de Python 3.4. Dans les anciennes versions, vous pouvez rapidement écrire votre propre suppression:

from contextlib import contextmanager

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

import os
#Your path here e.g. "C:\Program Files\text.txt"
#For access purposes: "C:\\Program Files\\text.txt"
if os.path.exists("C:\..."):   
    print "File found!"
else:
    print "File not found!"

L'importation de os facilite la navigation et l'exécution d'actions standard avec votre système d'exploitation.

Pour référence, voir également share

Si vous avez besoin d'opérations de haut niveau, utilisez 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