python créer - Comment vérifier si un fichier existe sans exception?





extension renommer (25)


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.

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




Si le fichier est destiné à l'ouverture, vous pouvez utiliser l'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!')

METTRE À JOUR

Juste pour éviter toute confusion et sur la base des réponses que j'ai obtenues, la réponse actuelle trouve un fichier ou un répertoire portant le même nom.




import os.path

if os.path.isfile(filepath):



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



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 .




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




En 2016, le meilleur moyen consiste toujours à utiliser os.path.isfile :

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

Ou en Python 3, vous pouvez utiliser pathlib :

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



Bien que je recommande toujours d'utiliser tryet d' exceptinstructions, voici quelques possibilités (mon préféré: utiliser os.access):

  1. Essayez d'ouvrir le fichier:

    L’ouverture du fichier vérifiera toujours l’existence du fichier. Vous pouvez créer une fonction comme ceci:

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

    Si la valeur est False, l'exécution s'arrête avec une erreur IOError ou OSError non gérée dans les versions ultérieures de Python. Pour attraper l'exception, vous devez utiliser une clause try except. Bien sûr, vous pouvez toujours utiliser une trydéclaration except` comme ceci (merci à hsandt de me faire réfléchir):

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

    Cela vérifiera l'existence de ce que vous spécifiez. Cependant, il vérifie la présence de fichiers et de répertoires, alors méfiez-vous de la façon dont vous l'utilisez.

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

    Cela vérifiera si vous avez accès au fichier. Il va vérifier les autorisations. Sur la base de la documentation os.py, en tapant os.F_OK, il vérifiera l’existence du chemin. Cependant, cela créera une faille de sécurité, car quelqu'un peut attaquer votre fichier en utilisant le temps écoulé entre la vérification des autorisations et l'ouverture du fichier. Vous devriez plutôt aller directement à l'ouverture du fichier au lieu de vérifier ses autorisations. ( EAFP vs LBYP ). Si vous n'allez pas ouvrir le fichier par la suite et que vous ne vérifiez que son existence, vous pouvez l'utiliser.

    Quoi qu'il en soit, ici:

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

Je devrais également mentionner qu'il y a deux manières pour que vous ne puissiez pas vérifier l'existence d'un fichier. Soit le problème sera permission deniedou no such file or directory. Si vous attrapez un IOError, définissez la IOError as e(comme ma première option), puis tapez print(e.args)afin que vous puissiez déterminer votre problème, espérons-le. J'espère que ça aide! :)




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



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.




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.



Vous avez la fonction os.path.exists :

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

Ceci renvoie True pour les fichiers et les répertoires, mais vous pouvez plutôt utiliser

os.path.isfile(file_path)

pour tester si c'est un fichier spécifiquement. Il s'ensuit des liens symboliques.




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



Si vous vérifiez si vous pouvez faire quelque chose comme if file_exists: open_it() , il est plus sûr d' try essayer de l'ouvrir. Vérifier et ensuite ouvrir risque de supprimer ou de déplacer le fichier ou quelque chose entre le moment de vérifier et le moment où vous essayez de l'ouvrir.

Si vous ne prévoyez pas d'ouvrir le fichier immédiatement, vous pouvez utiliser os.path.isfile

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

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

si vous devez être sûr que c'est un fichier.

À partir de Python 3.4, le module pathlib offre une approche orientée objet (rétroportée sur pathlib2 dans 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, faites:

if my_file.is_dir():
    # directory exists

Pour vérifier si un objet Path existe, qu'il s'agisse d'un fichier ou d'un répertoire, utilisez exists() :

if my_file.exists():
    # path exists

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

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



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

L'augmentation des exceptions est considérée comme une approche acceptable et Pythonic du contrôle de flux dans votre programme. Pensez à gérer les fichiers manquants avec IOErrors. Dans ce cas, une exception IOError sera générée si le fichier existe mais que l'utilisateur ne dispose pas des autorisations de lecture.

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




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.




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.




Si vous avez importé NumPy déjà à d' autres fins alors il n'y a pas besoin d'importer d' autres bibliothèques comme pathlib, os, paths, etc.

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

Cela retournera vrai ou faux en fonction de son existence.




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



Ajouter une autre légère variation qui ne se reflète pas exactement dans les autres réponses.

Cela gérera le cas de l' file_pathêtre Noneou une chaîne vide.

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

Ajouter une variante basée sur une suggestion de Shahbaz

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

Ajouter une variante basée sur une suggestion de Peter Wood

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






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



Voici un exemple simple d'enchaînement de décorateurs. Notez la dernière ligne - elle montre ce qui se passe sous les couvertures.

############################################################
#
#    decorators
#
############################################################

def bold(fn):
    def decorate():
        # surround with bold tags before calling original function
        return "<b>" + fn() + "</b>"
    return decorate


def uk(fn):
    def decorate():
        # swap month and day
        fields = fn().split('/')
        date = fields[1] + "/" + fields[0] + "/" + fields[2]
        return date
    return decorate

import datetime
def getDate():
    now = datetime.datetime.now()
    return "%d/%d/%d" % (now.day, now.month, now.year)

@bold
def getBoldDate(): 
    return getDate()

@uk
def getUkDate():
    return getDate()

@bold
@uk
def getBoldUkDate():
    return getDate()


print getDate()
print getBoldDate()
print getUkDate()
print getBoldUkDate()
# what is happening under the covers
print bold(uk(getDate))()

La sortie ressemble à:

17/6/2013
<b>17/6/2013</b>
6/17/2013
<b>6/17/2013</b>
<b>6/17/2013</b>




python file file-exists