Как проверить, существует ли файл?

Как узнать, существует ли файл или нет, без использования инструкции try ?

вопрос задан 17.09.2008
spence91
24608 репутация

39 ответов


  • 0 рейтинг

    Проверить файл или каталог

    Вы можете выполнить следующие три способа:

    Примечание1: os.path.isfile используется только для файлов

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

    Примечание2: os.path.exists используемые как для файлов, так и для каталогов

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

    Метод pathlib.Path (входит в состав Python 3+, устанавливается с помощью пипа для Python 2)

     from pathlib import Path
    Path(filename).exists()
     
    ответ дан Ali Hallaji, с репутацией 330, 4.03.2018
  • 0 рейтинг

    Дата: 2017-12-04

    Все возможные решения перечислены в других ответах.

    Интуитивно понятный и спорный способ проверить, существует ли файл:

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

    Я сделал исчерпывающий чарт для вашей справки:

     #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']}
     
    ответ дан JawSaw, с репутацией 3060, 4.12.2017
  • 0 рейтинг

    2017/12/22 :

    Хотя почти все возможные способы были перечислены в (по крайней мере, одном из) существующих ответов (например, добавлены конкретные вещи Python 3.4 ), я попытаюсь объединить все вместе.

    Примечание : каждый фрагмент стандартного библиотечного кода Python, который я собираюсь опубликовать, принадлежит версии 3.5.3 (котировки doc относятся к версии 3 ).

    Заявление о проблемах :

    1. Проверьте файл (спорно: также папка ( «специальный» файл)?) Существование
    2. Не используйте try /except /else /finally блоков

    Возможные решения :

    1. [Python]: os.path. существует ( путь ) (также проверяйте другие члены семейства функций, такие как os.path.isfile , os.path.isdir , os.path.lexists для немного другого поведения)

       os.path.exists(path)
       

      Верните True если путь относится к существующему пути или к файлу открытого дескриптора. Возвращает False для сломанных символических ссылок. На некоторых платформах эта функция может возвращать False если разрешение не предоставлено для выполнения os.stat () в запрошенном файле, даже если путь физически существует.

      Все хорошо, но если следовать дереву импорта:

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

        • genericpath.py , строка ~ # 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
           

      это всего лишь try/except блоков вокруг [Python]: os. stat ( путь, *, dir_fd = None, follow_symlinks = True ) . Итак, ваш код try/except бесплатно, но ниже в кадре есть (по крайней мере) один такой блок. Это также относится к другим функциям ( включая os.path.isfile ).

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

      • Это лучший способ (и больше python ic) для обработки путей, но
      • Под капотом, он делает то же самое (pathlib.py, линия ~ # 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]: с менеджерами контекста Statement . Или:

      • Создай:

         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 ...)
         
        • И его использование - я воспроизведу isfile поведение (обратите внимание, что это только для демонстрации целей, не пытайтесь написать такой код для производства ):

           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
           
      • Используйте [Python]: contextlib. подавляющие (* исключения) - который был специально предназначен для выборочного подавляющих исключений


      Но они кажутся обертки более try/except/else/finally блоков, как [Python]: оператор with утверждает:

      Это позволяет использовать обычную попытку ... кроме ... наконец, шаблоны использования, которые должны быть инкапсулированы для удобного повторного использования.

    3. Функции обхода файловой системы (и поиск результатов для соответствия элементов (ов))


      Поскольку эти итерации по папкам (в большинстве случаев), они неэффективны для нашей проблемы (есть исключения, такие как не подстановочные glob- бины, как указывал @ShadowRanger), поэтому я не буду настаивать на них. Не говоря уже о том, что в некоторых случаях может потребоваться обработка имени файла.

    4. [Python]: os. access ( путь, режим, *, dir_fd = None, effective_ids = False, follow_symlinks = True ) , поведение которого близко к os.path.exists (на самом деле оно шире, главным образом из-за 2- го аргумента)

      • пользовательские разрешения могут ограничивать файл «видимость», поскольку состояние документа:

        ... проверить, имеет ли вызывающий пользователь указанный путь к пути . режим должен быть F_OK для проверки существования пути ...

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

      Поскольку я также работаю в C , я также использую этот метод, потому что под капотом он вызывает собственный API s (опять же через «$ {PYTHON_SRC_DIR} /Modules/posixmodule.c» ), но также открывает ворота для возможного пользователя ошибок , и это не как Python ic, как другие варианты. Итак, как справедливо указал @AaronHall, не используйте его, если вы не знаете, что делаете:

      Примечание : вызов native API s также возможен через [Python]: ctypes - внешняя библиотека функций для Python , но в большинстве случаев это сложнее.

      ( Win specific): Поскольку msvcr * ( vcruntime * ) экспортирует семейство функций [MSDN]: _access, _waccess , вот пример:

       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
       

      Примечания :

      • Хотя это не очень хорошая практика, я использую os.F_OK в вызове, но это просто для ясности (его значение равно 0 )
      • Я использую _waccess чтобы один и тот же код работал на Python3 и Python2 (несмотря на различия в unicode между ними)
      • Хотя это относится к очень конкретной области, оно не упоминалось ни в одном из предыдущих ответов


      Lnx ( Ubtu (16 x64) ), а также:

       Python 3.5.2 (default, Nov 17 2016, 17:05:23)
      [GCC 5.4.0 20160609] on linux
      Type "help", "copyright", "credits" or "license" for more information.
      >>> import os, ctypes
      >>> ctypes.CDLL("/lib/x86_64-linux-gnu/libc.so.6").access(b"/tmp", os.F_OK)
      0
      >>> ctypes.CDLL("/lib/x86_64-linux-gnu/libc.so.6").access(b"/tmp1", os.F_OK)
      -1
       

      Примечания :

      • Вместо этого путь hardcoding libc ( "/lib/x86_64-linux-gnu/libc.so.6" ), который может (и, скорее всего, будет) изменяться в разных системах, None (или пустая строка) может быть передан CDLL конструктору ( ctypes.CDLL(None).access(b"/tmp", os.F_OK) ). Согласно [человеку]: DLOPEN (3) :

        Если имя файла NULL, то возвращаемый дескриптор предназначен для основной программы. Когда этот параметр задан dlsym (), этот дескриптор вызывает поиск символа в основной программе, за которым следуют все общие объекты, загруженные при запуске программы, а затем все общие объекты, загруженные dlopen (), с флагом RTLD_GLOBAL .

        • Основная (текущая) программа ( python ) связана с libc , поэтому ее символы (включая access ) будут загружены
        • С этим нужно обращаться с осторожностью, поскольку доступны такие функции, как main , Py_Main и (все) другие; их вызов может иметь катастрофические последствия (по текущей программе)
        • Это также не относится к Win (но это не так уж и важно, поскольку msvcrt.dll находится в «% SystemRoot% \ System32», который по умолчанию равен % PATH% ). Я хотел еще что-то сделать и воспроизвести это поведение на Win (и отправить патч), но, как оказалось, функция [MSDN]: GetProcAddress только «видит» экспортированные символы, поэтому, если кто-то не объявит функции в основном исполняемом файле как __declspec(dllexport) (почему на Земле обычный человек это сделал?), основная программа загружаема, но в значительной степени непригодна для использования
    5. Установите 3- й партийный модуль с возможностями файловой системы

      Скорее всего, будет опираться на один из способов выше (возможно, с небольшими настройками).
      Одним из примеров может быть (опять же, Win specific) [GitHub]: расширение Python для Windows (pywin32) , которое представляет собой оболочку Python поверх WINAPI .

      Но, поскольку это больше похоже на обходной путь, я останавливаюсь здесь.

    6. Другим (хромым) обходным решением ( gainarie ) является (как мне нравится его называют) подход sysadmin : используйте Python в качестве оболочки для выполнения команд оболочки

      • Выиграть :

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

    Итог :

    • Есть ли использовать try /except /else /finally блоков, потому что они могут помешать вам запуск в серию неприятных проблем. Контр-пример, о котором я могу думать, - это производительность: такие блоки являются дорогостоящими, поэтому старайтесь не размещать их в коде, который должен запускаться сотнями тысяч раз в секунду (но поскольку (в большинстве случаев) он включает в себя доступ к диску, это не так).

    Заключительное примечание (и) :

    • Я постараюсь держать его в курсе, любые предложения приветствуются, я включу что-нибудь полезное, которое придет в ответ
    ответ дан CristiFati, с репутацией 10244, 20.06.2017
  • 0 рейтинг
    import os.path
    
    def isReadableFile(file_path, file_name):
        full_path = file_path + "/" + file_name
        try:
            if not os.path.exists(file_path):
                print "File path is invalid."
                return False
            elif not os.path.isfile(full_path):
                print "File does not exist."
                return False
            elif not os.access(full_path, os.R_OK):
                print "File cannot be read."
                return False
            else:
                print "File can be read."
                return True
        except IOError as ex:
            print "I/O error({0}): {1}".format(ex.errno, ex.strerror)
        except Error as ex:
            print "Error({0}): {1}".format(ex.errno, ex.strerror)
        return False
    #------------------------------------------------------
    
    path = "/usr/khaled/documents/puzzles"
    fileName = "puzzle_1.txt"
    
    isReadableFile(path, fileName)
    
    ответ дан Khaled.K, с репутацией 4996, 5.08.2015
  • 0 рейтинг

    Вы должны обязательно использовать этот.

     from os.path import exists
    
    if exists("file") == True:
        print "File exists."
    elif exists("file") == False:
        print "File doesn't exist."
     
    ответ дан user2154354, с репутацией 308, 4.04.2013
  • 0 рейтинг

    Вы можете написать предложение Брайана без try: .

     from contextlib import suppress
    
    with suppress(IOError), open('filename'):
        process()
     

    suppress является частью Python 3.4. В старых версиях вы можете быстро написать свое собственное подавление:

     from contextlib import contextmanager
    
    @contextmanager
    def suppress(*exceptions):
        try:
            yield
        except exceptions:
            pass
     
    ответ дан Chris, с репутацией 710, 10.02.2014
  • 0 рейтинг

    В этом случае вы можете проверить, существует ли имя файла в listdir или нет. Если нет, то просто файл не существует.

     import os
    filename = 'D:\\Python\\Python27\\prz\\passwords\\alpa.txt'
    li = filename.split('\\')
    st = ''
    for i in range(0, len(li)-1):
        st = st + li[i] + '\\'
    dirlist = os.listdir(st)
    if(li[len(li)-1] in dirlist):
        fp = open(filename, 'r')
    else:
        print "FILE NOT FOUND"
     

    Это работает отлично.

    ответ дан Prashant Godhani, с репутацией 30, 22.11.2017
  • 0 рейтинг

    Я нашел эту строку при попытке создать следующую функциональность:

    1. Проверьте, присутствует ли файл в статических каталогах в представлении Django
    2. Если файл присутствует, откройте его в шаблоне
    3. Если файл отсутствует, выполните диалог в шаблоне, в котором отсутствует файл.

    Проработав различные решения, я обнаружил, что ни одно решение не работало как в среде разработки (с локальными статическими файлами), так и в производственной среде (с использованием хранилища S3).

    Таким образом, следующее:

     import os.path
    import urllib2
    from django.templatetags.static import static
    from django.contrib.staticfiles import finders
    
    ## Determine if file present to serve
    doc_title = 'document.pdf'
    doc_available = False
    try:
        if site_settings.CLOUD_STATIC :
            doc_path = static('app/document/%s' % doc_title)
            try:
                ret = urllib2.urlopen(doc_path)
            except Exception as e:
                pass
            else:
                if ret.code == 200:
                    doc_available = True
        else:
            doc_path = finders.find('app/document/%s' % doc_title)
            doc_available = os.path.isfile(doc_path)
    
    except Exception as e:
        doc_path = None
     

    Ответ может быть не очень Pythonic, поэтому, пожалуйста, улучшите.

    site_settings.CLOUD_STATIC - это параметр bool, который определяет, следует ли использовать облачное хранилище на основе среды (может использовать site_settings.DEBUG).

    Таким образом, я передаю doc_available bool шаблону и обрабатываю его соответствующим образом.

    ответ дан job, с репутацией 16, 31.05.2018
  • 0 рейтинг

    Кроме того, os.access() :

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

    Будучи R_OK , W_OK и X_OK флажками для проверки разрешений ( doc ).

    ответ дан zgoda, с репутацией 11108, 17.09.2008
  • 0 рейтинг

    Вы можете попробовать это (безопаснее):

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

    Выходом будет:

    ([Errno 2] Нет такого файла или каталога: «whatever.txt»)

    Затем, в зависимости от результата, ваша программа может просто продолжать работать оттуда или вы можете закодировать ее, если хотите.

    ответ дан philberndt, с репутацией 820, 25.01.2011
  • 0 рейтинг

    Если вы импортировали NumPy уже для других целей, нет необходимости импортировать другие библиотеки, такие как pathlib , os , paths и т. Д.

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

    Это вернет true или false, основываясь на его существовании.

    ответ дан durjoy, с репутацией 452, 10.08.2017
  • 0 рейтинг

    Как проверить, существует ли файл, без использования инструкции try?

    В 2016 году это, по-прежнему, самый простой способ проверить, существует ли файл и есть ли он файл:

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

    isfile на самом деле просто вспомогательный метод, который внутренне использует os.stat и stat.S_ISREG(mode) под ним. Это os.stat - метод более низкого уровня, который предоставит вам подробную информацию о файлах, каталогах, сокетах, буферах и т. Д. Подробнее о os.stat здесь

    Примечание. Однако этот подход не будет блокировать файл каким-либо образом, поэтому ваш код может стать уязвимым для ошибок « время проверки на время использования » ( TOCTTOU ).

    Таким образом, создание исключений считается приемлемым и Pythonic-подходом для управления потоком в вашей программе. И нужно рассматривать обработку отсутствующих файлов с помощью IOErrors, а не if операторов ( просто совет ).

    ответ дан Inconnu, с репутацией 3347, 2.12.2016
  • 0 рейтинг

    Тестирование файлов и папок с помощью os.path.isfile() , os.path.isdir() и os.path.exists()

    Предполагая, что «путь» является допустимым путем, в этой таблице показано, что возвращается каждой функцией для файлов и папок:

    введите описание изображения здесь

    Вы также можете проверить, является ли файл определенным типом файла, используя os.path.splitext() для получения расширения (если вы еще этого не знаете)

     >>> 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
     
    ответ дан Tom Fuller, с репутацией 3055, 8.10.2016
  • 0 рейтинг
     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!"
     

    Импорт os упрощает навигацию и выполнение стандартных действий с вашей операционной системой.

    Для справки также см. Как проверить, существует ли файл с использованием Python?

    Если вам нужны операции высокого уровня, используйте shutil .

    ответ дан Bishop, с репутацией 2258, 25.05.2015
  • 0 рейтинг

    Добавление еще одной небольшой вариации, которая не совсем отражена в других ответах.

    Это будет обрабатывать случай, когда file_path является None или пустой строкой.

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

    Добавление варианта, основанного на предположении от Шахбаза

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

    Добавление варианта, основанного на предположении от Питера Вуда

     def file_exists(file_path):
        return file_path and os.path.isfile(file_path):
     
    ответ дан Marcel Wilson, с репутацией 1318, 5.08.2016
  • 0 рейтинг

    Чтобы проверить, существует ли файл,

     from sys import argv
    
    from os.path import exists
    script, filename = argv
    target = open(filename)
    print "file exists: %r" % exists(filename)
     
    ответ дан Hanson, с репутацией 172, 17.10.2014
  • 0 рейтинг

    Вы можете использовать следующий открытый метод, чтобы проверить, существует ли файл + читаемый:

     open(inputFile, 'r')
     
    ответ дан user3197473, с репутацией 143, 23.05.2014
  • 0 рейтинг

    Ниже приведена 1 строка Python для среды командной строки Linux. Я нахожу это ОЧЕНЬ ХОРОШО, потому что я не такой горячий парень из Бэша.

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

    Надеюсь, это полезно.

    ответ дан Love and peace - Joe Codeswell, с репутацией 1342, 29.08.2015
  • 0 рейтинг

    Хотя я всегда рекомендую использовать try и except заявления, вот несколько возможностей для вас (мой личный фаворит использует os.access ):

    1. Попробуйте открыть файл:

      Открытие файла всегда проверяет наличие файла. Вы можете сделать функцию так:

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

      Если это False, это прекратит выполнение с помощью unhanded IOError или OSError в более поздних версиях Python. Чтобы поймать исключение, вам нужно использовать предложение try except. Конечно, вы всегда можете использовать инструкцию try except` (спасибо hsandt за то, что заставляют меня думать):

       def File_Existence(filepath):
          try:
              f = open(filepath)
          except IOError, OSError: # Note OSError is for later versions of Python
              return False
      
          return True
       
    2. Используйте os.path.exists(path) :

      Это проверяет существование того, что вы укажете. Тем не менее, он проверяет файлы и каталоги, поэтому остерегайтесь того, как вы его используете.

       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. Используйте os.access(path, mode) :

      Это проверит, есть ли у вас доступ к файлу. Он будет проверять разрешения. Основываясь на документации os.py, набрав в os.F_OK , он проверит существование пути. Тем не менее, использование этого приведет к созданию дыры в безопасности, так как кто-то может атаковать ваш файл, используя время между проверкой разрешений и открытием файла. Вместо этого вы должны перейти непосредственно к открытию файла, а не проверять его разрешения. ( ЭСПЦ против LBYP ). Если вы не собираетесь открывать файл после этого и проверяете его существование, вы можете использовать его.

      Во всяком случае, здесь:

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

    Я также должен упомянуть, что есть два способа, которыми вы не сможете проверить наличие файла. Либо проблема будет permission denied либо no such file or directory . Если вы поймаете IOError , установите IOError as e (как и мой первый вариант), а затем введите print(e.args) чтобы можно было надеяться определить вашу проблему. Я надеюсь, что это помогает! :)

    ответ дан Zizouz212, с репутацией 3226, 26.12.2014
  • 0 рейтинг

    Если файл открыт, вы можете использовать один из следующих способов:

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

    ОБНОВИТЬ

    Чтобы избежать путаницы и на основании полученных ответов, текущий ответ находит либо файл, либо каталог с заданным именем.

    ответ дан bergercookie, с репутацией 896, 13.10.2014
  • 0 рейтинг
     if os.path.isfile(path_to_file):
        try: 
            open(path_to_file)
                pass
        except IOError as e:
            print "Unable to open file"
     

    Получение исключений считается приемлемым, а Pythonic - подходом к управлению потоком в вашей программе. Рассмотрите возможность обработки отсутствующих файлов с помощью IOErrors. В этой ситуации исключение IOError будет повышаться, если файл существует, но у пользователя нет прав на чтение.

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

    ответ дан Pedro Lobito, с репутацией 44814, 28.04.2015
  • 0 рейтинг
    import os.path
    
    if os.path.isfile(filepath):
    
    ответ дан Paul, с репутацией 12874, 17.09.2008
  • 0 рейтинг

    Вы можете использовать библиотеку «OS» Python:

     >>> import os
    >>> os.path.exists("C:\\Users\\####\\Desktop\\test.txt") 
    True
    >>> os.path.exists("C:\\Users\\####\\Desktop\\test.tx")
    False
     
    ответ дан Pradip Das, с репутацией 535, 20.12.2014
  • 0 рейтинг
    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
    
    ответ дан benefactual, с репутацией 4466, 17.09.2008
  • 0 рейтинг

    В 2016 году лучший способ по-прежнему использует os.path.isfile :

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

    Или в Python 3 вы можете использовать pathlib :

     import pathlib
    path = pathlib.Path('/path/to/some/file.txt')
    if path.is_file():
        ...
     
    ответ дан KaiBuxe, с репутацией 688, 24.02.2016
  • 0 рейтинг

    У вас есть функция os.path.exists :

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

    Это возвращает True для файлов и каталогов, но вместо этого вы можете использовать

     os.path.isfile(file_name)
     

    проверить, является ли это файлом. Это следует за символическими ссылками.

    ответ дан PierreBdR, с репутацией 29139, 17.09.2008
  • 0 рейтинг

    Если причина, по которой вы проверяете, так что вы можете сделать что-то вроде if file_exists: open_it() , безопаснее использовать try вокруг попытки открыть ее. Проверка, а затем раскрытие рисков удаляет или перемещает файл или что-то между ними при проверке и при попытке открыть его.

    Если вы не планируете немедленно открывать файл, вы можете использовать os.path.isfile

    Верните True если путь - это обычный файл. Это следует за символическими ссылками, поэтому оба islink () и isfile () могут быть истинными для одного и того же пути.

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

    если вам нужно убедиться, что это файл.

    Начиная с Python 3.4, то pathlib Модуль предлагает объектно-ориентированный подход (портированном до pathlib2 в Python 2.7):

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

    Чтобы проверить каталог, выполните следующие действия:

     if my_file.is_dir():
        # directory exists
     

    Чтобы проверить, существует ли объект Path независимо от того, является ли он файлом или каталогом, используйте exists() :

     if my_file.exists():
        # path exists
     

    Вы также можете использовать resolve() в try блоках:

     try:
        my_abs_path = my_file.resolve()
    except FileNotFoundError:
        # doesn't exist
    else:
        # exists
     
    ответ дан rslite, с репутацией 55468, 17.09.2008
  • 0 рейтинг

    Предпочитаете утверждение try. Это считается лучшим стилем и позволяет избежать условий гонки.

    Не верьте мне на слово. Существует большая поддержка этой теории. Вот пара:

    ответ дан pkoch, с репутацией 2120, 4.11.2009
  • 0 рейтинг
     import os
    path = /path/to/dir
    
    root,dirs,files = os.walk(path).next()
    if myfile in files:
       print "yes it exists"
     

    Это полезно при проверке нескольких файлов. Или вы хотите сделать набор пересечений /вычитаний с существующим списком.

    ответ дан aitchnyu, с репутацией 10142, 26.08.2011
  • 0 рейтинг

    Я являюсь автором пакета, который существует около 10 лет, и он имеет функцию, которая напрямую решает этот вопрос. В принципе, если вы находитесь в системе, отличной от Windows, она использует Popen для доступа к find . Однако, если вы находитесь в Windows, он реплицирует find с эффективным ходоком файловой системой.

    Сам код не использует try блока ... кроме определения операционной системы и, таким образом, управления вами на «Unix» -стиле find или в ручном блоке find . Временные тесты показали, что try были быстрее при определении ОС, поэтому я использовал их там (но нигде больше).

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

    И док ...

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

    Реализация, если вы хотите посмотреть, находится здесь: https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190

    ответ дан Mike McKerns, с репутацией 16345, 5.05.2016
  • 0 рейтинг

    Если вы хотите сделать это в Bash, это будет:

     if [ -e "$FILE" ]; then
        prog "$FILE"
    fi
     

    Что я иногда делаю при использовании Python для выполнения более сложных манипуляций с списком имен (поскольку иногда мне нужно использовать Python для), метод try open(file): except: не совсем то, что нужно, поскольку это не тот процесс Python, который предназначен для открытия файл.

    В одном случае цель состоит в том, чтобы отфильтровать список имен в зависимости от того, существуют ли они в настоящее время (и нет процессов, которые могут удалить файл, или проблем с безопасностью, поскольку это на моей малине Pi, которая не имеет чувствительных файлов на SD карта).

    Мне интересно, будет ли сайт «простых шаблонов» хорошей идеей? Чтобы, например, вы могли проиллюстрировать оба метода со ссылками между ними и ссылками на дискуссии о том, когда использовать шаблон.

    ответ дан John Allsup, с репутацией 412, 15.11.2013
  • 0 рейтинг

    В отличие от isfile() , exists() вернет True для каталогов.
    Поэтому в зависимости от того, хотите ли вы только простые файлы или каталоги, вы будете использовать isfile() или exists() . Вот простой вывод REPL.

     >>> print os.path.isfile("/etc/password.txt")
    True
    >>> print os.path.isfile("/etc")
    False
    >>> print os.path.isfile("/does/not/exist")
    False
    >>> print os.path.exists("/etc/password.txt")
    True
    >>> print os.path.exists("/etc")
    True
    >>> print os.path.exists("/does/not/exist")
    False
     
    ответ дан bortzmeyer, с репутацией 24803, 17.09.2008
  • 0 рейтинг

    Это самый простой способ проверить, существует ли файл. Просто потому, что файл существовал при проверке, не гарантирует, что он будет там, когда вам нужно его открыть.

     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")
     
    ответ дан un33k, с репутацией 8774, 27.06.2013
  • 0 рейтинг

    Используйте os.path.isfile() с 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"
     
    ответ дан Yugal Jindle, с репутацией 21540, 16.01.2012
  • 0 рейтинг

    В Python 3.4 язык предоставляет новый модуль для управления файлами:

     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.
     
    ответ дан Unai Sainz de la Maza, с репутацией 685, 5.11.2015
  • 0 рейтинг

    Не похоже, что существует значимое функциональное различие между try /except и isfile() , поэтому вы должны использовать тот, который имеет смысл.

    Если вы хотите прочитать файл, если он существует, выполните

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

    Но если вы просто хотели переименовать файл, если он существует, и поэтому не нужно его открывать,

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

    Если вы хотите записать файл, если он не существует, выполните

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

    Если вам нужна блокировка файлов, это другое дело.

    ответ дан chad, с репутацией 969, 25.09.2013
  • 0 рейтинг

    Вы можете использовать os.listdir, чтобы проверить, находится ли файл в определенном каталоге.

     import os
    if 'file.ext' in os.listdir('dirpath'):
        #code
     
    ответ дан iPhynx, с репутацией 300, 8.06.2016
  • 0 рейтинг

    Python 3.4+ имеет объектно-ориентированный путь: pathlib . Используя этот новый модуль, вы можете проверить, существует ли файл такой:

     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
     

    Вы можете (и обычно должны) использовать try/except блок при открытии файлов:

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

    В модуле pathlib есть много классных вещей: удобное globbing, проверка владельца файла, упрощение соединения и т. Д. Это стоит проверить. Если вы используете более старый Python (версия 2.6 или новее), вы все равно можете установить pathlib с pip:

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

    Затем импортируйте его следующим образом:

     # Older Python versions
    import pathlib2 as pathlib
     
    ответ дан Cody Piersall, с репутацией 5038, 8.02.2014
  • 0 рейтинг

    Как проверить, существует ли файл, используя Python, без использования инструкции try?

    Теперь, начиная с Python 3.4, импортируйте и создайте объект Path с именем файла и проверьте метод is_file (обратите внимание, что это возвращает True для символических ссылок, указывающих на обычные файлы):

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

    Если вы находитесь на Python 2, вы можете выполнить резервное копирование модуля pathlib из pypi, pathlib2 или иным образом проверить isfile из os.path модулей:

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

    Теперь приведенный выше, вероятно, лучший прагматичный прямой ответ здесь, но есть вероятность состояния гонки (в зависимости от того, что вы пытаетесь выполнить), и того факта, что базовая реализация использует try , но Python использует try в своей реализация.

    Поскольку Python использует try везде, нет оснований избегать реализации, которая его использует.

    Но в остальном этот ответ пытается рассмотреть эти оговорки.

    Более длинный, гораздо более педантичный ответ

    Доступно с Python 3.4, используйте новый объект Path в pathlib . Обратите внимание, что .exists не совсем прав, потому что каталоги не являются файлами (за исключением unix, что все является файлом).

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

    Поэтому нам нужно использовать is_file :

     >>> root.is_file()
    False
     

    Вот помощь по is_file :

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

    Итак, давайте получим файл, который, как нам известно, является файлом:

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

    По умолчанию NamedTemporaryFile удаляет файл при закрытии (и автоматически закрывается, когда к нему не существует никаких ссылок).

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

    Если вы вникнете в реализацию , вы увидите, что is_file использует 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
     

    Условия гонки: почему нам нравится попробовать

    Нам нравится try потому что это позволяет избежать условий гонки. С try вы просто пытаетесь прочитать свой файл, ожидая, что он будет там, а если нет, вы поймаете исключение и выполните все, что имеет место при резервном поведении.

    Если вы хотите проверить, существует ли файл перед попыткой его прочитать, и вы можете удалить его, а затем вы можете использовать несколько потоков или процессов, или другая программа знает об этом файле и может удалить его - вы рискуете шансом условие гонки, если вы проверяете его на наличие, потому что вы затем участвуете в гонках, чтобы открыть его до того, как его состояние (его существование) изменится.

    Условия гонки очень сложно отладить, потому что есть очень маленькое окно, в котором они могут привести к сбою вашей программы.

    Но если это ваша мотивация, вы можете получить значение инструкции try , используя менеджер контекста suppress .

    Избежать условий гонки без заявления о попытке: suppress

    Python 3.4 дает нам suppress диспетчер контекста (ранее ignore менеджер контекста), который делает семантически точно то же самое в меньшем количестве строк, а также (по крайней мере поверхностно), удовлетворяя первоначальный запрос, чтобы избежать инструкции try :

     from contextlib import suppress
    from pathlib import Path
     

    Применение:

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

    Для более ранних Pythons вы можете катить свои suppress , но без try будет более многословным, чем с. Я действительно считаю, что это единственный ответ, который не использует try на любом уровне Python, который может применяться до Python 3.4, потому что вместо этого он использует диспетчер контекста:

     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)
     

    Возможно, проще попробовать:

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

    Другие варианты, которые не соответствуют запросу «без попытки»:

    ISFILE

     import os
    os.path.isfile(path)
     

    из документов :

    os.path.isfile(path)

    Вернуть True, если путь - это существующий обычный файл. Это следует за символическими ссылками, поэтому и islink() и isfile() могут быть истинными для одного и того же пути.

    Но если вы изучите источник этой функции, вы увидите, что на самом деле она использует инструкцию 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
     

    Все, что он делает, это использовать заданный путь, чтобы узнать, может ли он получить статистику по нему, поймав OSError а затем проверив, является ли это файлом, если он не вызвал исключение.

    Если вы намереваетесь что-то сделать с файлом, я бы предложил прямо попытаться с ним попробовать, кроме как избежать состояния гонки:

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

    os.access

    Доступно для Unix и Windows - os.access , но для использования вы должны передавать флаги и не различать файлы и каталоги. Это больше используется для проверки того, имеет ли реальный вызывающий пользователь доступ в среде с повышенными привилегиями:

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

    Он также страдает от тех же проблем с расы, что и у isfile . Из документов :

    Примечание. Использование access () для проверки того, разрешено ли пользователю открывать файл, прежде чем это делать, используя open (), создает отверстие для безопасности, поскольку пользователь может использовать короткий промежуток времени между проверкой и открытием файла для его манипулирования. Предпочтительно использовать методы EAFP. Например:

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

    лучше писать:

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

    Избегайте использования os.access . Это функция низкого уровня, которая имеет больше возможностей для пользовательской ошибки, чем объекты и функции более высокого уровня, рассмотренные выше.

    Критика другого ответа:

    Другой ответ говорит о os.access :

    Лично я предпочитаю это, потому что под капотом он вызывает собственные API (через «$ {PYTHON_SRC_DIR} /Modules/posixmodule.c»), но также открывает ворота для возможных пользовательских ошибок, и это не так, как Pythonic, как другие варианты :

    Этот ответ говорит, что он предпочитает непитонический, подверженный ошибкам метод, без каких-либо оснований. Похоже, пользователи поощряют использование низкоуровневых API без их понимания.

    Он также создает диспетчер контекста, который безоговорочно возвращает True , позволяет всем Исключениям (включая KeyboardInterrupt и SystemExit !) Проходить молча, что является хорошим способом скрыть ошибки.

    Это, по-видимому, побуждает пользователей принимать плохую практику.

    ответ дан Aaron Hall, с репутацией 153756, 11.08.2015