[Python] यह जांचने के लिए कि कोई फ़ाइल मौजूद है या नहीं?


Answers

आपके पास os.path.exists फ़ंक्शन है:

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

यह दोनों फाइलों और निर्देशिकाओं के लिए True लेकिन आप यह os.path.isfile लिए os.path.isfile का उपयोग कर सकते हैं यदि यह विशेष रूप से फ़ाइल है। यह सिम्लिंक का पालन करता है।

Question

यह देखने के लिए कि कोई फ़ाइल मौजूद है या नहीं, try कथन का उपयोग किए बिना?




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

Raising exceptions is considered to be an acceptable, and Pythonic, approach for flow control in your program. Consider handling missing files with IOErrors. In this situation, an IOError exception will be raised if the file exists but the user does not have read permissions.

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




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 आयात करना आपके ऑपरेटिंग सिस्टम के साथ नेविगेट करना और मानक क्रियाएं करना आसान बनाता है।

संदर्भ के लिए यह भी देखें share

यदि आपको उच्च स्तरीय संचालन की आवश्यकता है, तो shutil उपयोग shutil




ऐसा प्रतीत नहीं होता है कि कोशिश / छोड़कर और 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'

अगर आपको फाइल लॉकिंग की ज़रूरत है, तो यह एक अलग मामला है।




2017/12/22 :

यद्यपि लगभग हर संभव तरीके से मौजूदा उत्तरों (कम से कम एक) में सूचीबद्ध किया गया है (उदाहरण के लिए पायथन 3.4 विशिष्ट सामान जोड़ा गया था), मैं सब कुछ एक साथ समूह करने की कोशिश करूंगा।

नोट : पाइथन मानक लाइब्रेरी कोड का प्रत्येक टुकड़ा जिसे मैं पोस्ट करने जा रहा हूं, संस्करण 3.5.3 से संबंधित है (दस्तावेज़ उद्धरण संस्करण 3 विशिष्ट हैं)।

समस्या कथन :

  1. फ़ाइल जांचें ( बहस योग्य : फ़ोल्डर भी ("विशेष" फ़ाइल)?) अस्तित्व
  2. try / except / else / finally ब्लॉक का उपयोग न करें

संभावित समाधान :

  1. [पायथन]: os.path। मौजूद है ( पथ ) ( os.path.isfile , os.path.isdir , os.path.lexists जैसे अन्य फ़ंक्शन परिवार सदस्यों को भी थोड़ा अलग व्यवहार के लिए 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
        

    यह सिर्फ os.stat() आसपास ब्लॉक try/except os.stat() os.stat() । तो, आपका कोड मुफ्त try/except मुक्त करने का try/except , लेकिन framestack में कम (कम से कम) एक ऐसा ब्लॉक है। यह अन्य funcs ( os.path.isfile सहित ) पर भी लागू होता है।

    1.1। [पायथन]: pathlib.Path। is_file ()

    • यह पथों को संभालने का एक प्रशंसक (और अधिक पायथन आईसी) तरीका है, लेकिन
    • हुड के तहत, यह वही काम करता है ( 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. [पायथन]: स्टेटमेंट संदर्भ प्रबंधक के साथ । कोई एक:

    • एक बनाए:

      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 व्यवहार को 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
        
    • [पायथन] का प्रयोग करें : contextlib। दबाने ( * अपवाद ) - जिसे विशेष रूप से चुनिंदा अपवादों को दबाने के लिए डिज़ाइन किया गया था


    लेकिन, वे [पायथन] के रूप में try/except/else/finally ब्लॉक पर रैपर होने लगते हैं : कथन के साथ :

    यह आम try अनुमति देता है ... except ... finally उपयोग के पैटर्न को सुविधाजनक पुन: उपयोग के लिए encapsulated किया जा सकता है।

  3. फाइलसिस्टम ट्रैवर्सल फ़ंक्शंस (और मेल खाने वाले आइटम के लिए परिणाम खोजें)


    चूंकि ये फ़ोल्डरों पर पुनरावृत्त होते हैं, (ज्यादातर मामलों में) वे हमारी समस्या के लिए अक्षम हैं (अपवाद हैं, जैसे गैर वाइल्डकार्ड ग्लोब बिंग - जैसे @ShadowRanger ने इंगित किया), इसलिए मैं उन पर जोर नहीं दे रहा हूं। उल्लेख नहीं है कि कुछ मामलों में, फ़ाइल नाम प्रसंस्करण की आवश्यकता हो सकती है।

  4. [पायथन]: ओएस। एक्सेस ( पथ, मोड, *, dir_fd = कोई नहीं, प्रभावी_आईडी = झूठी, follow_symlinks = सही ) जिसका व्यवहार os.path.exists करीब है (वास्तव में यह व्यापक है, मुख्य रूप से 2 वें तर्क के कारण)

    • उपयोगकर्ता अनुमतियां दस्तावेज़ "दृश्यता" को दस्तावेज़ों के रूप में प्रतिबंधित कर सकती हैं:

      ... परीक्षण अगर आक्रमणकारी उपयोगकर्ता के पास पथ तक निर्दिष्ट पहुंच है। पथ के अस्तित्व का परीक्षण करने के लिए मोड F_OK होना चाहिए ...

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

    चूंकि मैं सी में भी काम करता हूं, इसलिए मैं इस विधि का भी उपयोग करता हूं क्योंकि हुड के तहत, यह देशी एपीआई (फिर से, " $ {PYTHON_SRC_DIR} /Modules/posixmodule.c " के माध्यम से ) कहता है , लेकिन यह संभावित उपयोगकर्ता के लिए एक द्वार भी खोलता है त्रुटियां , और यह अन्य प्रकार के रूप में पायथन आईसी के रूप में नहीं है। तो, जैसा कि @AaronHall ने सही ढंग से इंगित किया है, इसका उपयोग न करें जबतक कि आप यह नहीं जानते कि आप क्या कर रहे हैं:

    नोट : देशी पाइडर को कॉल करना [पायथन] के माध्यम से भी संभव है : ctypes - पायथन के लिए एक विदेशी फ़ंक्शन लाइब्रेरी , लेकिन ज्यादातर मामलों में यह अधिक जटिल है।

    ( विन विशिष्ट): चूंकि msvcr * ( vcruntime * ) एक [एमएसडीएन] निर्यात करता है : _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 का उपयोग कर रहा हूं ताकि एक ही कोड पायथन 3 और पायथन 2 पर काम करता हो (उनके बीच यूनिकोड से संबंधित अंतर के बावजूद)
    • यद्यपि यह एक बहुत ही विशिष्ट क्षेत्र को लक्षित करता है, लेकिन पिछले किसी भी उत्तर में इसका उल्लेख नहीं किया गया था


    एलएनएक्स ( उबतु (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
    

    नोट्स :

    • इसके बजाय libc के पथ को हार्डकोड करना ( "/lib/x86_64-linux-gnu/libc.so.6" ) जो सिस्टम (और सबसे अधिक संभावना है,) सिस्टम में भिन्न हो सकता है, None (या खाली स्ट्रिंग) CDLL कन्स्ट्रक्टर को पास नहीं किया जा सकता है ( ctypes.CDLL(None).access(b"/tmp", os.F_OK) )। [आदमी] के अनुसार : डोलपेन (3) :

      यदि फ़ाइल नाम पूर्ण है, तो लौटा हुआ हैंडल मुख्य कार्यक्रम के लिए है। जब dlsym () को दिया जाता है, तो यह संभाल मुख्य प्रोग्राम में एक प्रतीक के लिए खोज का कारण बनता है, उसके बाद प्रोग्राम स्टार्टअप पर लोड की गई सभी साझा ऑब्जेक्ट्स और फिर फ्लैग RTLD_GLOBAL के साथ dlopen () द्वारा लोड की गई सभी साझा ऑब्जेक्ट्स का कारण बनता है

      • मुख्य (वर्तमान) प्रोग्राम ( पायथन ) libc के खिलाफ जुड़ा हुआ है, इसलिए इसके प्रतीक ( access सहित) लोड हो जाएंगे
      • इसे देखभाल के साथ संभाला जाना है, क्योंकि main , Py_Main और (सभी) अन्य कार्यों जैसे कार्य उपलब्ध हैं; उन्हें बुलाकर विनाशकारी प्रभाव हो सकते हैं (वर्तमान कार्यक्रम पर)
      • यह विन पर भी लागू नहीं होता है (लेकिन यह इतना बड़ा सौदा नहीं है, क्योंकि msvcrt.dll "% SystemRoot% \ System32" में स्थित है जो डिफ़ॉल्ट रूप से % PATH% में है)। मैं चीजों को आगे ले जाना चाहता था और Win (और एक पैच सबमिट करना) पर इस व्यवहार को दोहराना चाहता था, लेकिन जैसा कि यह पता चला है, [एमएसडीएन]: GetProcAddress फ़ंक्शन केवल निर्यात किए गए प्रतीकों को "देखता है", इसलिए जब तक कोई मुख्य निष्पादन योग्य में __declspec(dllexport) रूप में कार्य घोषित नहीं करता __declspec(dllexport) (क्यों पृथ्वी पर नियमित व्यक्ति ऐसा करेगा?), मुख्य कार्यक्रम लोड करने योग्य है लेकिन काफी ज्यादा उपयोग करने योग्य
  5. फाइल सिस्टम क्षमताओं के साथ कुछ 3 डी पार्टी मॉड्यूल स्थापित करें

    सबसे अधिक संभावना है, उपरोक्त तरीकों में से एक पर निर्भर करेगा (शायद मामूली अनुकूलन के साथ)।
    एक उदाहरण होगा (फिर से, विन विशिष्ट) [गिटहब]: विंडोज़ के लिए पायथन (पायविन 32) एक्सटेंशन , जो विनीपी पर पाइथन रैपर है।

    लेकिन, चूंकि यह एक कामकाज की तरह है, मैं यहां रोक रहा हूं।

  6. एक और (लंगड़ा) वर्कअराउंड ( gainarie ) है (जैसा कि मैं इसे कॉल करना चाहता हूं) sysadmin दृष्टिकोण: शैल कमांड निष्पादित करने के लिए पायथन को एक रैपर के रूप में उपयोग करें

    • विन :

      (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
      
    • एलएनएक्स ( उबतु ):

      [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 ब्लॉक का उपयोग try , क्योंकि वे आपको खराब समस्याओं की श्रृंखला में भागने से रोक सकते हैं। एक काउंटर-उदाहरण जिसे मैं सोच सकता हूं, प्रदर्शन है: ऐसे ब्लॉक महंगे हैं, इसलिए उन्हें कोड में न रखने की कोशिश करें कि यह प्रति सेकंड सैकड़ों हजार बार चलाना है (लेकिन अधिकांश मामलों में) इसमें डिस्क एक्सेस शामिल है, यह मामला नहीं होगा)।

अंतिम नोट :

  • मैं इसे अद्यतित रखने की कोशिश करूंगा, किसी भी सुझाव का स्वागत है, मैं कुछ उपयोगी भी शामिल करूंगा जो उत्तर में आ जाएगा



If the file is for opening you could use one of the following techniques:

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



import os
os.path.exists(path) # returns whether the path (dir or file) exists or not
os.path.isfile(path) # returns whether the file exists or not



Additionally, os.access() :

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

Being R_OK , W_OK , and X_OK the flags to test for permissions ( doc ).




पायथन 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.')

पाथलिब मॉड्यूल में इसमें बहुत सी अच्छी चीजें हैं: सुविधाजनक ग्लोबिंग, फ़ाइल के मालिक की जांच करना, आसान पथ शामिल होना आदि। यह जांचना उचित है। यदि आप पुराने पायथन (संस्करण 2.6 या बाद में) पर हैं, तो आप अभी भी पाइप के साथ पाथलिब स्थापित कर सकते हैं:

# 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



Here's a 1 line Python command for the Linux command line environment. I find this VERY HANDY since I'm not such a hot Bash guy.

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

I hope this is helpful.




You can use the "OS" library of Python:

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



I'm the author of a package that's been around for about 10 years, and it has a function that addresses this question directly. Basically, if you are on a non-Windows system, it uses Popen to access find . However, if you are on Windows, it replicates find with an efficient filesystem walker.

The code itself does not use a try block… except in determining the operating system and thus steering you to the "Unix"-style find or the hand-buillt find . Timing tests showed that the try was faster in determining the OS, so I did use one there (but nowhere else).

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

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

>>>

The implementation, if you care to look, is here: https://github.com/uqfoundation/pox/blob/89f90fb308f285ca7a62eabe2c38acb87e89dad9/pox/shutils.py#L190




import os.path

if os.path.isfile(filepath):



आप इसे (सुरक्षित) आज़मा सकते हैं:

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

फिर, परिणाम के आधार पर, आपका प्रोग्राम केवल वहां से चल रहा है या यदि आप चाहें तो इसे रोकने के लिए कोड कर सकते हैं।




import os
path = /path/to/dir

root,dirs,files = os.walk(path).next()
if myfile in files:
   print "yes it exists"

This is helpful when checking for several files. Or you want to do a set intersection/ subtraction with an existing list.




Links