python - मैं जांच कैसे करूं कि फ़ाइल अपवाद के बिना मौजूद है या नहीं?




file file-exists (25)

यदि आप जिस कारण की जांच कर रहे हैं, तो आप कुछ ऐसा कर सकते हैं जैसे if file_exists: open_it() , इसे खोलने के प्रयास के आसपास प्रयास करने के लिए सुरक्षित है। फ़ाइल को हटाया जा रहा है या स्थानांतरित किया जा रहा है या जब आप जांचते हैं और जब आप इसे खोलने का प्रयास करते हैं तो कुछ जोखिम खुलता है।

यदि आप तुरंत फ़ाइल खोलने की योजना नहीं बना रहे हैं, तो आप os.path.isfile उपयोग कर सकते हैं

यदि पथ एक नियमित नियमित फ़ाइल है तो True वापस लौटें। यह प्रतीकात्मक लिंक का पालन करता है, इसलिए दोनों islink() और os.path.isfile एक ही पथ के लिए सच हो सकते हैं।

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

अगर आपको यह सुनिश्चित करने की ज़रूरत है कि यह एक फाइल है।

पाइथन 3.4 से शुरू होने पर, pathlib मॉड्यूल एक ऑब्जेक्ट उन्मुख दृष्टिकोण प्रदान करता है (पायथन 2.7 में pathlib2 बैकपोर्टेड):

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

आप try ब्लॉक में resolve() का भी उपयोग कर सकते हैं:

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

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


2016 में सबसे अच्छा तरीका अभी भी os.path.isfile का उपयोग कर os.path.isfile :

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

या पायथन 3 में आप pathlib उपयोग कर सकते हैं:

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

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

अब पाइथन 3.4 के बाद उपलब्ध है, फ़ाइल नाम के साथ एक Path ऑब्जेक्ट आयात और तत्काल करें, और is_file विधि की जांच करें (ध्यान दें कि यह नियमित फाइलों को इंगित करने वाले is_file लिए भी सही है):

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

यदि आप पाइथन 2 पर हैं, तो आप pypi, pathlib2 से pathlib मॉड्यूल का बैकपोर्ट कर सकते हैं, या अन्यथा os.path मॉड्यूल से isfile जांच सकते हैं:

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

अब उपरोक्त शायद सबसे अच्छा व्यावहारिक प्रत्यक्ष उत्तर है, लेकिन दौड़ की स्थिति (जो आप पूरा करने की कोशिश कर रहे हैं उसके आधार पर) की संभावना है, और तथ्य यह है कि अंतर्निहित कार्यान्वयन एक try का उपयोग करता है, लेकिन पाइथन हर जगह try करता है कार्यान्वयन।

चूंकि पाइथन हर जगह try करता है, इसका उपयोग करने वाले कार्यान्वयन से बचने के लिए वास्तव में कोई कारण नहीं है।

लेकिन बाकी का जवाब इन चेतावनियों पर विचार करने का प्रयास करता है।

लंबा, बहुत अधिक pedantic जवाब

पाइथन 3.4 के बाद उपलब्ध, pathlib में नई Path वस्तु का pathlib । ध्यान दें कि .exists बिल्कुल सही नहीं है, क्योंकि निर्देशिका फ़ाइलें नहीं हैं (यूनिक्स को छोड़कर कि सबकुछ एक फ़ाइल है)।

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

तो हमें is_file का उपयोग करने की आवश्यकता है:

>>> root.is_file()
False

is_file पर सहायता यहां दी 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 उपयोग करता है:

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 संदर्भ प्रबंधक का उपयोग करके एक try कथन का मूल्य प्राप्त कर सकते हैं।

कोशिश कथन के बिना दौड़ की स्थिति से बचें: suppress

पायथन 3.4 हमें suppress संदर्भ प्रबंधक (पहले संदर्भ प्रबंधक को ignore है) देता है, जो कम लाइनों में समान रूप से वही चीज़ करता है, जबकि मूल कथन से बचने के लिए मूल पूछताछ (कम से कम सतही रूप से)

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

पहले पायथन के लिए, आप अपना खुद का suppress रोल कर सकते हैं, लेकिन try किए बिना अधिक वर्बोज़ होगा। मेरा मानना ​​है कि यह वास्तव में एकमात्र उत्तर है जो पायथन में किसी भी स्तर पर try नहीं करता है जिसे पायथन 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)

docs :

os.path.isfile(path)

यदि पथ एक नियमित नियमित फ़ाइल है तो सत्य वापस लौटें। यह प्रतीकात्मक लिंक का पालन करता है, इसलिए दोनों islink() और isfile() एक ही पथ के लिए सच हो सकते हैं।

लेकिन अगर आप इस फ़ंक्शन के source की जांच करते हैं, तो आप देखेंगे कि यह वास्तव में एक कोशिश कथन का उपयोग करता है:

# 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 को पकड़ OSError और फिर जांच कर सकता है कि यह फ़ाइल है या नहीं, अगर यह अपवाद नहीं उठाता है।

यदि आप फ़ाइल के साथ कुछ करने का इरादा रखते हैं, तो मैं दौड़ की स्थिति से बचने के अलावा इसे सीधे प्रयास करने का सुझाव दूंगा:

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

os.access

यूनिक्स और विंडोज के लिए उपलब्ध os.access , लेकिन उपयोग करने के लिए आपको झंडे पास करना होगा, और यह फ़ाइलों और निर्देशिकाओं के बीच अंतर नहीं करता है। यह परीक्षण करने के लिए अधिक उपयोग किया जाता है कि वास्तविक आवेदक उपयोगकर्ता के पास एक उन्नत विशेषाधिकार वातावरण में पहुंच है या नहीं:

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

यह उसी दौड़ की स्थिति की समस्याओं से भी पीड़ित है। docs :

नोट: यह देखने के लिए एक्सेस () का उपयोग करना कि उपयोगकर्ता को अधिकृत करने के लिए अधिकृत किया गया है, उदाहरण के लिए खुले () का उपयोग करके वास्तव में ऐसा करने से पहले फ़ाइल खोलें, सुरक्षा सुरक्षा छेद बनाता है, क्योंकि उपयोगकर्ता फ़ाइल को जांचने और खोलने के बीच कम समय अंतराल का फायदा उठा सकता है। ईएएफपी तकनीकों का उपयोग करना बेहतर है। उदाहरण के लिए:

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 बारे में यह कहते हैं:

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

यह उत्तर कहता है कि यह एक गैर-पायथनिक, त्रुटि-प्रवण विधि पसंद करता है, बिना औचित्य के। ऐसा लगता है कि उपयोगकर्ताओं को समझने के बिना निम्न स्तर के एपीआई का उपयोग करने के लिए प्रोत्साहित किया जाता है।

यह एक संदर्भ प्रबंधक भी बनाता है, जो बिना शर्त रूप से True लौटता है, चुपचाप पारित करने के लिए सभी अपवाद ( KeyboardInterrupt SystemExit और SystemExit ! सहित) की अनुमति देता है, जो कि बग को छिपाने का एक अच्छा तरीका है।

ऐसा लगता है कि उपयोगकर्ताओं को खराब प्रथाओं को अपनाने के लिए प्रोत्साहित किया जाता है।


फ़ाइल मौजूद है या नहीं यह जांचने का सबसे आसान तरीका है। सिर्फ इसलिए कि फ़ाइल चेक होने पर मौजूद थी, यह गारंटी नहीं देता है कि जब आप इसे खोलने की आवश्यकता होगी तो यह वहां होगा।

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

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


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

अपवादों को बढ़ाने के लिए एक स्वीकार्य, और पायथनिक, आपके कार्यक्रम में प्रवाह नियंत्रण के लिए दृष्टिकोण माना जाता है। IOErrors के साथ लापता फ़ाइलों को संभालने पर विचार करें। इस स्थिति में, यदि फ़ाइल मौजूद है तो उपयोगकर्ता IOError अपवाद उठाया जाएगा लेकिन उपयोगकर्ता को पढ़ने की अनुमति नहीं है।

एसआरसी: http://www.pfinn.net/python-check-if-file-exists.html


ऐसा लगता है कि कोशिश / छोड़कर और 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'

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


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

कोशिश कथन का उपयोग किये बिना मैं कैसे जांचूं कि फ़ाइल मौजूद है या नहीं?

2016 में, यह अभी भी जांचने का सबसे आसान तरीका है कि दोनों फाइल मौजूद हैं या नहीं और यदि यह एक फ़ाइल है:

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

isfileवास्तव में केवल एक सहायक तरीका है जो आंतरिक रूप से उपयोग करता है os.statऔर stat.S_ISREG(mode)नीचे। यह os.statएक निम्न-स्तरीय विधि है जो आपको फ़ाइलों, निर्देशिकाओं, सॉकेट, बफर आदि के बारे में विस्तृत जानकारी प्रदान करेगी। ओएसस्टैट के बारे में अधिक जानकारी यहां

नोट: हालांकि, यह दृष्टिकोण फ़ाइल को किसी भी तरह से लॉक नहीं करेगा और इसलिए आपका कोड "उपयोग के समय के चेक के समय " ( ट्यूटटू ) कीड़े के लिए कमजोर हो सकता है ।

इसलिए अपवादों को बढ़ाने के लिए स्वीकार्य माना जाता है, और पाइथोनिक, आपके कार्यक्रम में प्रवाह नियंत्रण के लिए दृष्टिकोण। और किसी को ifबयान के बजाय गायब फाइलों को IOErrors के साथ संभालने पर विचार करना चाहिए ( केवल एक सलाह )।


कोशिश कथन पसंद करते हैं। इसे बेहतर शैली माना जाता है और दौड़ की स्थिति से बचा जाता है।

इसके लिए मेरा शब्द मत लो। इस सिद्धांत के लिए बहुत सारे समर्थन हैं। यहां एक जोड़ा है:


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

इसके अतिरिक्त os.access(),:

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

होने के नाते R_OK, W_OKऔर X_OKझंडे अनुमतियाँ (के लिए परीक्षण करने के लिए दस्तावेज़ )।


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

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

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


मैं ऐसे पैकेज का लेखक हूं जो लगभग 10 वर्षों तक रहा है, और इसमें एक ऐसा कार्य है जो इस प्रश्न को सीधे संबोधित करता है। असल में, यदि आप एक गैर-विंडोज सिस्टम पर हैं, तो यह Popenएक्सेस करने के लिए उपयोग करता है find। हालांकि, यदि आप विंडोज़ पर हैं, तो यह findएक कुशल फाइल सिस्टम वॉकर के साथ प्रतिलिपि बनाता है।

कोड स्वयं एक tryब्लॉक का उपयोग नहीं करता है ... ऑपरेटिंग सिस्टम को निर्धारित करने के अलावा और इस प्रकार आपको "यूनिक्स" 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


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

isfile() विपरीत, exists() निर्देशिकाओं के लिए True वापस आ जाएगा।
तो यदि आप केवल सादे फाइलों या निर्देशिकाओं को चाहते हैं, तो आप isfile() या exists() उपयोग करेंगे। यहां एक साधारण आरईपीएल आउटपुट है।

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

आप बिना ब्रायन के सुझाव लिख सकते हैं try:

from contextlib import suppress

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

suppressपायथन 3.4 का हिस्सा है। पुरानी रिलीज में आप जल्दी ही अपना दबदबा लिख ​​सकते हैं:

from contextlib import contextmanager

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

एक और मामूली बदलाव जोड़ना जो अन्य उत्तरों में बिल्कुल सही नहीं है।

यह 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):

os.path.isfile() उपयोग os.path.isfile() साथ करें:

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"

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

आप अन्य प्रयोजनों के लिए पहले से ही NumPy आयातित तो वहाँ की तरह अन्य पुस्तकालयों आयात करने के लिए कोई जरूरत नहीं है pathlib, os, paths, आदि

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

यह अपने अस्तित्व के आधार पर सही या गलत वापस आ जाएगा।


अगर फ़ाइल खोलने के लिए है तो आप निम्न तकनीकों में से एक का उपयोग कर सकते हैं:

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

अद्यतन करें

भ्रम से बचने के लिए और मुझे मिलने वाले उत्तरों के आधार पर, वर्तमान उत्तर या तो दिए गए नाम के साथ एक फ़ाइल या निर्देशिका पाता है ।


लिनक्स कमांड लाइन पर्यावरण के लिए यहां 1 लाइन पायथन कमांड है। मुझे यह बहुत अच्छा लगता है क्योंकि मैं इतना गर्म बैश लड़का नहीं हूं।

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

मुझे आशा है कि यह मददगार है।


import os.path

if os.path.isfile(filepath):

एक और आसान तरीका हो सकता है

a = []
if len(a) == 0:
  print("Empty")
else:
  print(" Not empty")




python file file-exists