जांचें कि क्या कोई निर्देशिका मौजूद है और यदि आवश्यक हो तो इसे बनाएं?

इसका सीधा जवाब, एक साधारण स्थिति मानना ​​है जहां आप अन्य उपयोगकर्ताओं या प्रक्रियाओं को अपनी निर्देशिका के साथ गड़बड़ करने की उम्मीद नहीं करते हैं:

if not os.path.exists(d):
    os.makedirs(d)

या यदि निर्देशिका बनाना दौड़ की स्थिति के अधीन है (यानी यदि पथ की जांच करने के बाद, कुछ और हो सकता है) यह करें:

import errno
try:
    os.makedirs(d)
except OSError as exception:
    if exception.errno != errno.EEXIST:
        raise

लेकिन शायद tempfile के माध्यम से अस्थायी निर्देशिकाओं का उपयोग करके, संसाधन विवाद समस्या को दूर करने का एक बेहतर तरीका है:

import tempfile

d = tempfile.mkdtemp()

ऑनलाइन दस्तावेज़ से आवश्यक आवश्यक है:

mkdtemp(suffix='', prefix='tmp', dir=None)
    User-callable function to create and return a unique temporary
    directory.  The return value is the pathname of the directory.

    The directory is readable, writable, and searchable only by the
    creating user.

    Caller is responsible for deleting the directory when done with it.

पायथन 3.5 में नया: pathlib.Path साथ

एक नई Path वस्तु (3.4 के रूप में) है जिसमें कई विधियां पथ के साथ उपयोग करना चाहती हैं - जिनमें से एक mkdir ।

(संदर्भ के लिए, मैं अपने साप्ताहिक प्रतिनिधि को एक स्क्रिप्ट के साथ ट्रैक कर रहा हूं। यहां स्क्रिप्ट से कोड के प्रासंगिक भाग हैं जो मुझे उसी डेटा के लिए दिन में एक से अधिक बार स्टैक ओवरफ़्लो से टकराने से बचने की अनुमति देते हैं।)

पहले प्रासंगिक आयात:

from pathlib import Path
import tempfile

हमें os.path.join से निपटने की ज़रूरत नहीं है - बस पथ भागों में शामिल हों /

directory = Path(tempfile.gettempdir()) / 'sodata'

तब मैं exist_ok से निर्देशिका सुनिश्चित करता हूं - exist_ok तर्क पायथन 3.5 में दिखाया गया है:

directory.mkdir(exist_ok=True)

pathlib.Path.mkdir का प्रासंगिक हिस्सा यहां दिया गया pathlib.Path.mkdir :

यदि exist_ok सत्य है, तो FileExistsError अपवादों को अनदेखा कर दिया जाएगा ( POSIX mkdir -p कमांड के समान व्यवहार), लेकिन केवल तभी अंतिम पथ घटक मौजूदा गैर-निर्देशिका फ़ाइल नहीं है।

यहां कुछ और स्क्रिप्ट है - मेरे मामले में, मैं दौड़ की स्थिति के अधीन नहीं हूं, मेरे पास केवल एक प्रक्रिया है जो निर्देशिका (या निहित फाइलें) होने की अपेक्षा करती है, और मेरे पास हटाने की कोशिश करने की कोई चीज़ नहीं है निर्देशिका।

todays_file = directory / str(datetime.datetime.utcnow().date())
if todays_file.exists():
    logger.info("todays_file exists: " + str(todays_file))
    df = pd.read_json(str(todays_file))

Path ऑब्जेक्ट्स को अन्य एपीआई से पहले str को मजबूर होना पड़ता है जो उम्मीद करते हैं कि str पथ उनका उपयोग कर सकते हैं।

शायद os.PathLike को अमूर्त बेस क्लास, os.PathLike । os.PathLike उदाहरणों को स्वीकार करने के लिए अद्यतन किया जाना चाहिए।

इस स्थिति के विनिर्देशों पर अंतर्दृष्टि

आप एक निश्चित फ़ाइल पर एक निश्चित फ़ाइल देते हैं और आप निर्देशिका को फ़ाइल पथ से खींचते हैं। फिर यह सुनिश्चित करने के बाद कि आपके पास निर्देशिका है, आप पढ़ने के लिए फ़ाइल खोलने का प्रयास करते हैं। इस कोड पर टिप्पणी करने के लिए:

filename = "/my/directory/filename.txt"
dir = os.path.dirname(filename)

हम बिल्टिन फ़ंक्शन को ओवरराइट करने से बचना चाहते हैं, dir । साथ ही, filepath या शायद fullfilepath शायद filename नाम से बेहतर अर्थपूर्ण नाम है, इसलिए यह बेहतर लिखा जाएगा:

import os
filepath = '/my/directory/filename.txt'
directory = os.path.dirname(filepath)

आपका अंतिम लक्ष्य इस फ़ाइल को खोलना है, आरंभ में आप लिखने के लिए कहते हैं, लेकिन आप अनिवार्य रूप से इस लक्ष्य (आपके कोड के आधार पर) के पास आ रहे हैं, जो पढ़ने के लिए फ़ाइल खोलता है:

if not os.path.exists(directory):
    os.makedirs(directory)
f = file(filename)

पढ़ने के लिए खोलने का मानना

आप उस फाइल के लिए निर्देशिका क्यों बनायेंगे जहां आप वहां रहने की उम्मीद करते हैं और पढ़ सकते हैं?

बस फ़ाइल खोलने का प्रयास करें।

with open(filepath) as my_file:
    do_stuff(my_file)

यदि निर्देशिका या फ़ाइल नहीं है, तो आपको एक संबंधित त्रुटि संख्या के साथ errno.ENOENT मिलेगा: errno.ENOENT आपके प्लेटफॉर्म पर ध्यान दिए बिना सही त्रुटि संख्या को इंगित करेगा। यदि आप चाहें तो आप इसे पकड़ सकते हैं, उदाहरण के लिए:

import errno
try:
    with open(filepath) as my_file:
        do_stuff(my_file)
except IOError as error:
    if error.errno == errno.ENOENT:
        print 'ignoring error because directory or file is not there'
    else:
        raise

मान लीजिए कि हम लेखन के लिए खुल रहे हैं

यह शायद आप जो चाहते हैं।

इस मामले में, हम शायद किसी भी दौड़ की स्थिति का सामना नहीं कर रहे हैं। तो बस जैसे ही आप थे, लेकिन ध्यान दें कि लिखने के लिए, आपको w मोड (या a संलग्न करने के लिए) खोलना होगा। फ़ाइलों को खोलने के लिए संदर्भ प्रबंधक का उपयोग करने के लिए यह एक पायथन सर्वोत्तम अभ्यास भी है।

import os
if not os.path.exists(directory):
    os.makedirs(directory)
with open(filepath, 'w') as my_file:
    do_stuff(my_file)

हालांकि, कहें कि हमारे पास कई पायथन प्रक्रियाएं हैं जो अपने सभी डेटा को एक ही निर्देशिका में रखने का प्रयास करती हैं। फिर हम निर्देशिका के निर्माण पर विवाद हो सकता है। उस स्थिति में makedirs को लपेटने के लिए सबसे अच्छा makedirs ब्लॉक को छोड़कर कोशिश करें।

import os
import errno
if not os.path.exists(directory):
    try:
        os.makedirs(directory)
    except OSError as error:
        if error.errno != errno.EEXIST:
            raise
with open(filepath, 'w') as my_file:
    do_stuff(my_file)

आप mkpath उपयोग कर सकते हैं

# Create a directory and any missing ancestor directories. 
# If the directory already exists, do nothing.

from distutils.dir_util import mkpath
mkpath("test")    

ध्यान दें कि यह पूर्वजों की निर्देशिका भी बनाएगा।

यह पायथन 2 और 3 के लिए काम करता है।

आप इसके लिए os.listdir उपयोग कर सकते हैं:

import os
if 'dirName' in os.listdir('parentFolderPath')
    print('Directory Exists')

कोशिश करने का प्रयास करना और इरनो मॉड्यूल से सही त्रुटि कोड दौड़ की स्थिति से छुटकारा पाता है और क्रॉस-प्लेटफार्म है:

import os
import errno

def make_sure_path_exists(path):
    try:
        os.makedirs(path)
    except OSError as exception:
        if exception.errno != errno.EEXIST:
            raise

दूसरे शब्दों में, हम निर्देशिका बनाने की कोशिश करते हैं, लेकिन यदि वे पहले से मौजूद हैं तो हम त्रुटि को अनदेखा करते हैं। दूसरी ओर, किसी भी अन्य त्रुटि की सूचना मिली है। उदाहरण के लिए, यदि आप पहले से ही 'ए' बनाते हैं और इससे सभी अनुमतियां हटाते हैं, तो आपको errno.EACCES (अनुमति अस्वीकार, त्रुटि 13) के साथ उठाए गए OSError मिलेगा।

पायथन 3.4 में आप ब्रांड नए pathlib मॉड्यूल का भी उपयोग कर सकते हैं:

from pathlib import Path
path = Path("/my/directory/filename.txt")
try:
    if not path.parent.exists():
        path.parent.mkdir(parents=True)
except OSError:
    # handle error; you can also catch specific errors like
    # FileExistsError and so on.

मुझे यह क्यू / ए मिला और मैं शुरुआत में कुछ विफलताओं और त्रुटियों से परेशान था। मैं पाइथन 3 में काम कर रहा हूं (v.3.5 आर्क लिनक्स x86_64 सिस्टम पर एनाकोंडा आभासी वातावरण में)।

इस निर्देशिका संरचना पर विचार करें:

└── output/         ## dir
   ├── corpus       ## file
   ├── corpus2/     ## dir
   └── subdir/      ## dir

यहां मेरे प्रयोग / नोट्स हैं, जो चीजों को स्पष्ट करते हैं:

# ----------------------------------------------------------------------------
# [1] https://.com/questions/273192/how-can-i-create-a-directory-if-it-does-not-exist

import pathlib

""" Notes:
        1.  Include a trailing slash at the end of the directory path
            ("Method 1," below).
        2.  If a subdirectory in your intended path matches an existing file
            with same name, you will get the following error:
            "NotADirectoryError: [Errno 20] Not a directory:" ...
"""
# Uncomment and try each of these "out_dir" paths, singly:

# ----------------------------------------------------------------------------
# METHOD 1:
# Re-running does not overwrite existing directories and files; no errors.

# out_dir = 'output/corpus3'                ## no error but no dir created (missing tailing /)
# out_dir = 'output/corpus3/'               ## works
# out_dir = 'output/corpus3/doc1'           ## no error but no dir created (missing tailing /)
# out_dir = 'output/corpus3/doc1/'          ## works
# out_dir = 'output/corpus3/doc1/doc.txt'   ## no error but no file created (os.makedirs creates dir, not files!  ;-)
# out_dir = 'output/corpus2/tfidf/'         ## fails with "Errno 20" (existing file named "corpus2")
# out_dir = 'output/corpus3/tfidf/'         ## works
# out_dir = 'output/corpus3/a/b/c/d/'       ## works

# [2] https://docs.python.org/3/library/os.html#os.makedirs

# Uncomment these to run "Method 1":

#directory = os.path.dirname(out_dir)
#os.makedirs(directory, mode=0o777, exist_ok=True)

# ----------------------------------------------------------------------------
# METHOD 2:
# Re-running does not overwrite existing directories and files; no errors.

# out_dir = 'output/corpus3'                ## works
# out_dir = 'output/corpus3/'               ## works
# out_dir = 'output/corpus3/doc1'           ## works
# out_dir = 'output/corpus3/doc1/'          ## works
# out_dir = 'output/corpus3/doc1/doc.txt'   ## no error but creates a .../doc.txt./ dir
# out_dir = 'output/corpus2/tfidf/'         ## fails with "Errno 20" (existing file named "corpus2")
# out_dir = 'output/corpus3/tfidf/'         ## works
# out_dir = 'output/corpus3/a/b/c/d/'       ## works

# Uncomment these to run "Method 2":

#import os, errno
#try:
#       os.makedirs(out_dir)
#except OSError as e:
#       if e.errno != errno.EEXIST:
#               raise
# ----------------------------------------------------------------------------

निष्कर्ष: मेरी राय में, "विधि 2" अधिक मजबूत है।

[1] यदि मैं अस्तित्व में नहीं हूं तो मैं निर्देशिका कैसे बना सकता हूं?

[2] os.makedirs

मैं os.path.exists() उपयोग करता os.path.exists() , here एक पायथन 3 स्क्रिप्ट है जिसका उपयोग यह जांचने के लिए किया जा सकता है कि कोई निर्देशिका मौजूद है या नहीं, अगर यह अस्तित्व में नहीं है, तो इसे बनाएं और इसे हटा दें (यदि वांछित है)।

यह उपयोगकर्ताओं को निर्देशिका के इनपुट के लिए संकेत देता है और आसानी से संशोधित किया जा सकता है।

मैं व्यक्तिगत रूप से अनुशंसा करता हूं कि os.path.isdir() का उपयोग os.path.isdir() के बजाय परीक्षण करने के लिए करें।

>>> os.path.exists('/tmp/dirname')
True
>>> os.path.exists('/tmp/dirname/filename.etc')
True
>>> os.path.isdir('/tmp/dirname/filename.etc')
False
>>> os.path.isdir('/tmp/fakedirname')
False

यदि आपके पास है:

>>> dir = raw_input(":: ")

और एक मूर्ख उपयोगकर्ता इनपुट:

:: /tmp/dirname/filename.etc

... जब आप os.makedirs() साथ परीक्षण करते हैं तो आप os.makedirs() उस तर्क को पास करते समय filename.etc नामक निर्देशिका के साथ समाप्त होने जा रहे हैं।

मैंने नीचे दिया है। हालांकि यह पूरी तरह मूर्ख नहीं है।

import os

dirname = 'create/me'

try:
    os.makedirs(dirname)
except OSError:
    if os.path.exists(dirname):
        # We are nearly safe
        pass
    else:
        # There was an error on creation, so make sure we know about it
        raise

अब जैसा कि मैं कहता हूं, यह वास्तव में मूर्ख नहीं है, क्योंकि हमारे पास निर्देशिका बनाने में असफल होने की संभावना है, और उस अवधि के दौरान इसे बनाने वाली दूसरी प्रक्रिया है।

प्रासंगिक पायथन दस्तावेज ईएएफपी कोडिंग शैली (अनुमति से क्षमा के लिए पूछने के लिए आसान) के उपयोग का सुझाव देता है। इसका मतलब है कि कोड

try:
    os.makedirs(path)
except OSError as exception:
    if exception.errno != errno.EEXIST:
        raise
    else:
        print "\nBE CAREFUL! Directory %s already exists." % path

विकल्प से बेहतर है

if not os.path.exists(path):
    os.makedirs(path)
else:
    print "\nBE CAREFUL! Directory %s already exists." % path

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

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

os.path.exists फ़ंक्शन का प्रयास करें

if not os.path.exists(dir):
    os.mkdir(dir)

पायथन 3 में , os.makedirs सेटिंग का समर्थन करता है। डिफ़ॉल्ट सेटिंग False , जिसका अर्थ है कि यदि लक्ष्य निर्देशिका पहले से मौजूद है तो OSError उठाया जाएगा। exist_ok को True सेट करके, OSError (निर्देशिका मौजूद है) को अनदेखा कर दिया जाएगा और निर्देशिका नहीं बनाई जाएगी।

os.makedirs(path,exist_ok=True)

Python2 में , os.makedirs सेटिंग का समर्थन नहीं करता है। आप हेइककी-टिवोनोन के उत्तर में दृष्टिकोण का उपयोग कर सकते हैं:

import os
import errno

def make_sure_path_exists(path):
    try:
        os.makedirs(path)
    except OSError as exception:
        if exception.errno != errno.EEXIST:
            raise

इस कमांड का प्रयोग करें और डीआईआर बनाएं

 if not os.path.isdir(test_img_dir):
     os.mkdir(str("./"+test_img_dir))

यदि आप निम्नलिखित पर विचार करते हैं:

os.path.isdir('/tmp/dirname')

का मतलब है एक निर्देशिका (पथ) मौजूद है और एक निर्देशिका है। तो मेरे लिए इस तरह से मुझे क्या चाहिए। इसलिए मैं सुनिश्चित कर सकता हूं कि यह फ़ोल्डर है (फ़ाइल नहीं) और मौजूद है।

create_dir()अपने प्रोग्राम / प्रोजेक्ट के प्रवेश बिंदु पर फ़ंक्शन को कॉल करें ।

import os

def create_dir(directory):
    if not os.path.exists(directory):
        print('Creating Directory '+directory)
        os.makedirs(directory)

create_dir('Project directory')

import os
if os.path.isfile(filename):
    print "file exists"
else:
    "Your code here"

जहां आपका कोड यहां (स्पर्श) कमांड का उपयोग करता है

यह जांच करेगा कि फ़ाइल वहां है या नहीं, तो यह नहीं होगा।