जांच करें कि पथ के लक्ष्य पर फ़ाइल बनाए बिना पायथन में कोई पथ मान्य है या नहीं

Question 1

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

पथ के निर्देशिका सेगमेंट को मान्य और पहुंच योग्य मान लेना सुरक्षित है ( ^{मैं प्रश्न को और अधिक प्रभावी रूप से लागू करने का प्रयास कर रहा था, और जाहिर है कि मैं बहुत दूर जा चुका हूं} )।

मैं बहुत ज्यादा कुछ भी से बचने के लिए जब तक मेरे पास है नहीं करना चाहती है करने के लिए।

मैं उदाहरण के कुछ पात्रों के साथ काम कर रहा हूँ, लेकिन जाहिरा तौर पर वे स्टैक-एक्सचेंज सिस्टम द्वारा स्वचालित रूप से हटा दिए जाते हैं। वैसे भी, मैं मानक यूनिकोड संस्थाओं को रखना चाहता हूं ö, और केवल उन चीजों से बचना चाहिए जो एक फ़ाइलनाम में अमान्य हैं।

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

मूल रूप से मैं यह जांचना चाहता हूं कि क्या मैं वास्तव में लिखने के लिए पथ को खोलने के बिना एक पथ पर लिख सकता हूं (और स्वचालित रूप से फ़ाइल सृजन / फ़ाइल क्लॉबरिंग जो आमतौर पर जोर देता है)।

जैसे की:

try:
    open(filename, 'w')
except OSError:
    # handle error here

यहां से

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

मुझे पता है मैं कर सकता हूँ:

if not os.access(filePath, os.W_OK):
    try:
        open(filePath, 'w').close()
        os.unlink(filePath)
    except OSError:
        # handle error here

लेकिन यह फ़ाइल को उस पर बनाएगाfilePath , जिसे मुझे फिर बनाना होगा os.unlink।

अंत में, ऐसा लगता है कि यह कुछ करने के लिए 6 या 7 लाइनें खर्च कर रहा है जो कि os.isvalidpath(filePath)समान या समान होना चाहिए ।

एक तरफ के रूप में, मुझे विंडोज़ (और कम से कम) पर चलने के लिए इसकी आवश्यकता है, इसलिए मैं प्लेटफ़ॉर्म-विशिष्ट सामान से बचना चाहूंगा।

``

Question 2

tl; डॉ

is_path_exists_or_creatable()नीचे परिभाषित फ़ंक्शन को कॉल करें।

कड़ाई से पायथन 3. कि हम कैसे रोल करते हैं।

ए टेल ऑफ़ टू क्वेश्चन

"मैं पथनाम वैधता का परीक्षण कैसे करूं और वैध पथनामों के लिए, उन रास्तों के अस्तित्व या लेखन क्षमता का परीक्षण कैसे करूं?" स्पष्ट रूप से दो अलग-अलग प्रश्न हैं। दोनों दिलचस्प हैं, और न ही यहां वास्तव में संतोषजनक जवाब मिला है ... या, ठीक है, कहीं भी मुझे पकड़ना चाहिए।

विक्की का जवाब शायद निकटतम है, लेकिन इसके उल्लेखनीय नुकसान हैं:

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

हम सब ठीक कर रहे हैं।

प्रश्न # 0: फिर से पथनाम वैधता क्या है?

हमारे नाजुक मांस सूट को दर्द के अजगर-चिड़चिड़े moshpits में चोट पहुंचाने से पहले, हमें शायद यह परिभाषित करना चाहिए कि "पथनाम वैधता" से हमारा क्या मतलब है। क्या वैधता को परिभाषित करता है, बिल्कुल?

"Pathname वैधता," से हमारा तात्पर्य है, pathname के सेनेटिकली सही होने के संबंध में मौजूदा सिस्टम रूट फाइल सिस्टम के है - चाहे वह पथ या माता-पिता की निर्देशिका शारीरिक रूप से मौजूद हो या नहीं। एक रूटनाम इस परिभाषा के तहत वाक्यविन्यास रूप से सही है यदि यह रूट फाइल सिस्टम की सभी सिंटैक्टिक आवश्यकताओं का अनुपालन करता है।

"रूट फाइल सिस्टम" से हमारा मतलब है:

POSIX- संगत सिस्टम पर, फ़ाइल सिस्टम रूट डायरेक्टरी में आरोहित होता है (/ ) ।
विंडोज पर, फाइलसिस्टम माउंट किया गया है %HOMEDRIVE%, बृहदान्त्र-प्रत्यय ड्राइव अक्षर जिसमें वर्तमान विंडोज इंस्टॉलेशन है (आमतौर पर जरूरी नहींC: )।

"वाक्यविन्यास शुद्धता" का अर्थ, बदले में रूट फाइलसिस्टम के प्रकार पर निर्भर करता है। के लिए ext4(और सबसे लेकिन नहीं सभी POSIX संगत) फ़ाइल सिस्टम, एक पथ नाम वाक्य रचना सही है तभी उस पथ नाम हैं:

कोई शून्य बाइट्स शामिल नहीं है (यानी, \x00पायथन में)।यह सभी POSIX- संगत फाइल सिस्टम के लिए एक कठिन आवश्यकता है।
255 बाइट्स (जैसे, 'a'*256पायथन में) से अधिक लंबा कोई घटक नहीं होता है । एक रास्ता घटक एक पथ नाम नहीं होने के सबसे लंबे समय तक सबस्ट्रिंग है /चरित्र (जैसे, bergtatt, ind, i, और fjeldkamreneपथ नाम में /bergtatt/ind/i/fjeldkamrene)।

संश्लिष्ट शुद्धता। रूट फाइलसिस्टम। बस।

प्रश्न # 1: अब हम क्या करेंगे?

पायथन में पैथनामों का सत्यापन करना आश्चर्यजनक रूप से गैर-सहज है। मैं यहां नकली नाम के साथ दृढ़ समझौता कर रहा हूं : आधिकारिक os.pathपैकेज को इसके लिए एक आउट-ऑफ-द-बॉक्स समाधान प्रदान करना चाहिए। अज्ञात के लिए (और शायद बिना किसी कारण के), यह नहीं है। सौभाग्य से, अपने स्वयं के तदर्थ समाधान अनियंत्रित नहीं है कि आंत- wrenching ...

ठीक है, यह वास्तव में है। यह बालों वाली है; वो बहुत बेकार है; यह संभवतः चमकता है क्योंकि यह चमकता है और इसे बढ़ता है। लेकिन तुम क्या करने वाले हो? Nuthin '।

हम जल्द ही निम्न-स्तरीय कोड के रेडियोधर्मी रसातल में उतरेंगे। लेकिन पहले, उच्च स्तरीय दुकान की बात करते हैं। मानक os.stat()और os.lstat()फ़ंक्शंस निम्नलिखित अपवादों को उठाते हैं जब अमान्य मार्गनाम पास किए जाते हैं:

गैर-मौजूदा निर्देशिकाओं में रहने वाले मार्ग के लिए, के उदाहरण FileNotFoundError ।
मौजूदा निर्देशिका में रहने वाले पथनामों के लिए:
- विंडोज के तहत, WindowsErrorकिसकी winerrorविशेषता के उदाहरण हैं 123(जैसे,ERROR_INVALID_NAME )।
- अन्य सभी ओएस के तहत:
- Null बाइट्स (यानी, '\x00'), के उदाहरण वाले पथनाम के लिएTypeError ।
- 255 बाइट्स से अधिक लंबे पथ घटकों वाले पथनाम के लिए, OSErrorजिनके उदाहरणerrcode विशेषता है:
  - SunOS और OSes के * BSD परिवार के तहत, errno.ERANGE । (यह एक OS-level बग प्रतीत होता है, अन्यथा POSIX मानक की "चयनात्मक व्याख्या" के रूप में जाना जाता है।)
  - अन्य सभी OSes के तहत, errno.ENAMETOOLONG।

महत्वपूर्ण रूप से, इसका तात्पर्य है कि केवल मौजूदा निर्देशिका में रहने वाले मार्गनाम मान्य हैं। os.stat()और os.lstat()कार्यों सामान्य बढ़ाFileNotFoundError अपवाद पारित कर दिया pathnames गैर मौजूदा निर्देशिका में रहने वाले, की परवाह किए बिना उन pathnames अमान्य हैं या नहीं। निर्देशिका का अस्तित्व pathname अमान्यता पर पूर्वता लेता है।

क्या इसका मतलब यह है कि गैर-मौजूदा निर्देशिका में रहने वाले मार्गनाम वैध नहीं हैं ? हां - जब तक हम मौजूदा निर्देशिकाओं में निवास करने के लिए उन मार्गों को संशोधित नहीं करते। यह भी सुरक्षित रूप से संभव है, हालांकि? एक पाथनाम को संशोधित नहीं करना चाहिए हमें मूल पथनाम को मान्य करने से रोकना चाहिए?

इस प्रश्न का उत्तर देने के लिए, ऊपर से याद करें कि ext4फाइल सिस्टम पर वाक्य-रचना संबंधी सही पथनामों में 255 बाइट्स से अधिक लंबाई वाले नल बाइट्स (B) वाले कोई पथ घटक (A) नहीं हैं । इसलिए, एक pathname वैध है अगर और केवल अगर उस pathname में सभी पथ घटक मान्य हैं। यह ब्याज की सबसे वास्तविक दुनिया filesystems का सच है ।ext4

क्या वह पांडित्य अंतर्दृष्टि वास्तव में हमारी मदद करती है? हाँ। यह पूर्ण पथनाम को मान्य करने की बड़ी समस्या को कम कर देता है, जो उस पथनाम में केवल सभी पथ घटकों को मान्य करने की छोटी समस्या को कम कर देता है। कोई भी मनमाना पथनाम मान्य है (चाहे वह मार्गनाम मौजूदा निर्देशिका में रहता हो या नहीं) निम्नलिखित एल्गोरिथ्म का पालन करके क्रॉस-प्लेटफॉर्म तरीके से:

पथ घटकों में उस पथनाम को विभाजित करें (उदाहरण के लिए, /troldskog/faren/vildसूची में पथनाम['', 'troldskog', 'faren', 'vild'] )।
ऐसे प्रत्येक घटक के लिए:
1. उस घटक के साथ एक नए अस्थायी पथनाम (जैसे, /troldskog) में मौजूद होने के लिए गारंटी वाली निर्देशिका के पथनाम से जुड़ें ।
2. उस पथनाम को पास os.stat()या os.lstat()। यदि वह पथनाम और इसलिए वह घटक अमान्य है, तो यह कॉल जनरेट किए गए अपवाद के बजाय अनौपचारिकता के प्रकार को उजागर करने वाले अपवाद को बढ़ाने की गारंटी FileNotFoundErrorहै। क्यों? क्योंकि वह पथनाम मौजूदा निर्देशिका में रहता है। (परिपत्र तर्क परिपत्र है।)

क्या कोई निर्देशिका मौजूद है? हां, लेकिन आम तौर पर केवल एक: रूट फाइलसिस्टम की सबसे ऊपरी निर्देशिका (जैसा कि ऊपर परिभाषित किया गया है)।

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

उपरोक्त दृष्टिकोण के साथ-साथ सुरक्षा के लिए पर्याप्त पक्ष लाभ मौजूद है । ( यह अच्छा नहीं है ?) विशेष रूप से:

फ्रंट-फेसिंग अनुप्रयोगों को ऐसे स्रोतों से गुजरने के लिए अविश्वसनीय स्रोतों से मनमाने तरीके से वैधता प्राप्त करने os.stat()या os.lstat()डेनियल ऑफ सर्विस (DoS) के हमलों और अन्य ब्लैक-हेट शेंनिगन्स के लिए अतिसंवेदनशील होते हैं। दुर्भावनापूर्ण उपयोगकर्ता बार-बार या अन्यथा धीमी गति से ज्ञात फाइल सिस्टम पर रहने वाले मार्गनामों को बार-बार मान्य करने का प्रयास कर सकते हैं (जैसे, एनएफएस सांबा शेयर); उस स्थिति में, आने वाले मार्ग को नेत्रहीन रूप से स्टेट करने के लिए उत्तरदायी है या तो कनेक्शन टाइमआउट के साथ विफल हो जाता है या बेरोजगारी का सामना करने के लिए आपकी कमजोर क्षमता से अधिक समय और संसाधनों का उपभोग करता है।

उपरोक्त दृष्टिकोण रूट फाइल सिस्टम के रूट डायरेक्टरी के खिलाफ एक पाथनाम के पथ घटकों को केवल मान्य करके इसका पालन करता है। (अगर ऐसा है तो बासी, धीमा, या दुर्गम है, तो आपको pathname सत्यापन की तुलना में बड़ी समस्याएं मिली हैं।)

खो गया? महान। चलो शुरू करें। (पायथन 3 ने मान लिया। देखें "300 के लिए फ्रैगाइल होप क्या है, लिसेक ?"

import errno, os

# Sadly, Python fails to provide the following magic number for us.
ERROR_INVALID_NAME = 123
'''
Windows-specific error code indicating an invalid pathname.

See Also
----------
https://docs.microsoft.com/en-us/windows/win32/debug/system-error-codes--0-499-
    Official listing of all such codes.
'''

def is_pathname_valid(pathname: str) -> bool:
    '''
    `True` if the passed pathname is a valid pathname for the current OS;
    `False` otherwise.
    '''
    # If this pathname is either not a string or is but is empty, this pathname
    # is invalid.
    try:
        if not isinstance(pathname, str) or not pathname:
            return False

        # Strip this pathname's Windows-specific drive specifier (e.g., `C:\`)
        # if any. Since Windows prohibits path components from containing `:`
        # characters, failing to strip this `:`-suffixed prefix would
        # erroneously invalidate all valid absolute Windows pathnames.
        _, pathname = os.path.splitdrive(pathname)

        # Directory guaranteed to exist. If the current OS is Windows, this is
        # the drive to which Windows was installed (e.g., the "%HOMEDRIVE%"
        # environment variable); else, the typical root directory.
        root_dirname = os.environ.get('HOMEDRIVE', 'C:') \
            if sys.platform == 'win32' else os.path.sep
        assert os.path.isdir(root_dirname)   # ...Murphy and her ironclad Law

        # Append a path separator to this directory if needed.
        root_dirname = root_dirname.rstrip(os.path.sep) + os.path.sep

        # Test whether each path component split from this pathname is valid or
        # not, ignoring non-existent and non-readable path components.
        for pathname_part in pathname.split(os.path.sep):
            try:
                os.lstat(root_dirname + pathname_part)
            # If an OS-specific exception is raised, its error code
            # indicates whether this pathname is valid or not. Unless this
            # is the case, this exception implies an ignorable kernel or
            # filesystem complaint (e.g., path not found or inaccessible).
            #
            # Only the following exceptions indicate invalid pathnames:
            #
            # * Instances of the Windows-specific "WindowsError" class
            #   defining the "winerror" attribute whose value is
            #   "ERROR_INVALID_NAME". Under Windows, "winerror" is more
            #   fine-grained and hence useful than the generic "errno"
            #   attribute. When a too-long pathname is passed, for example,
            #   "errno" is "ENOENT" (i.e., no such file or directory) rather
            #   than "ENAMETOOLONG" (i.e., file name too long).
            # * Instances of the cross-platform "OSError" class defining the
            #   generic "errno" attribute whose value is either:
            #   * Under most POSIX-compatible OSes, "ENAMETOOLONG".
            #   * Under some edge-case OSes (e.g., SunOS, *BSD), "ERANGE".
            except OSError as exc:
                if hasattr(exc, 'winerror'):
                    if exc.winerror == ERROR_INVALID_NAME:
                        return False
                elif exc.errno in {errno.ENAMETOOLONG, errno.ERANGE}:
                    return False
    # If a "TypeError" exception was raised, it almost certainly has the
    # error message "embedded NUL character" indicating an invalid pathname.
    except TypeError as exc:
        return False
    # If no exception was raised, all path components and hence this
    # pathname itself are valid. (Praise be to the curmudgeonly python.)
    else:
        return True
    # If any other exception was raised, this is an unrelated fatal issue
    # (e.g., a bug). Permit this exception to unwind the call stack.
    #
    # Did we mention this should be shipped with Python already?

किया हुआ। उस कोड पर स्क्विंट न करें। ( यह काटता है। )

प्रश्न # 2: संभवतः अमान्य पथनाम अस्तित्व या रचनात्मकता, एह?

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

def is_path_creatable(pathname: str) -> bool:
    '''
    `True` if the current user has sufficient permissions to create the passed
    pathname; `False` otherwise.
    '''
    # Parent directory of the passed path. If empty, we substitute the current
    # working directory (CWD) instead.
    dirname = os.path.dirname(pathname) or os.getcwd()
    return os.access(dirname, os.W_OK)

def is_path_exists_or_creatable(pathname: str) -> bool:
    '''
    `True` if the passed pathname is a valid pathname for the current OS _and_
    either currently exists or is hypothetically creatable; `False` otherwise.

    This function is guaranteed to _never_ raise exceptions.
    '''
    try:
        # To prevent "os" module calls from raising undesirable exceptions on
        # invalid pathnames, is_pathname_valid() is explicitly called first.
        return is_pathname_valid(pathname) and (
            os.path.exists(pathname) or is_path_creatable(pathname))
    # Report failure on non-fatal filesystem complaints (e.g., connection
    # timeouts, permissions issues) implying this path to be inaccessible. All
    # other exceptions are unrelated fatal issues and should not be caught here.
    except OSError:
        return False

हो गया और हो गया। सिवाय काफी नहीं।

प्रश्न # 3: संभवतया अमान्य पथनाम अस्तित्व या विंडोज पर लेखन क्षमता

वहाँ एक चेतावनी मौजूद है। जरूर करता है।

जैसा कि आधिकारिक os.access()प्रलेखन स्वीकार करता है:

नोट: I / O संचालन तब भी विफल हो सकता है जब os.access()यह इंगित करता है कि वे सफल होंगे, विशेष रूप से नेटवर्क फाइलसिस्टम के संचालन के लिए, जिसमें सामान्य POSIX अनुमति-बिट मॉडल से परे अनुमत शब्दार्थक हो सकते हैं।

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

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

import os, tempfile

def is_path_sibling_creatable(pathname: str) -> bool:
    '''
    `True` if the current user has sufficient permissions to create **siblings**
    (i.e., arbitrary files in the parent directory) of the passed pathname;
    `False` otherwise.
    '''
    # Parent directory of the passed path. If empty, we substitute the current
    # working directory (CWD) instead.
    dirname = os.path.dirname(pathname) or os.getcwd()

    try:
        # For safety, explicitly close and hence delete this temporary file
        # immediately after creating it in the passed path's parent directory.
        with tempfile.TemporaryFile(dir=dirname): pass
        return True
    # While the exact type of exception raised by the above function depends on
    # the current version of the Python interpreter, all such types subclass the
    # following exception superclass.
    except EnvironmentError:
        return False

def is_path_exists_or_creatable_portable(pathname: str) -> bool:
    '''
    `True` if the passed pathname is a valid pathname on the current OS _and_
    either currently exists or is hypothetically creatable in a cross-platform
    manner optimized for POSIX-unfriendly filesystems; `False` otherwise.

    This function is guaranteed to _never_ raise exceptions.
    '''
    try:
        # To prevent "os" module calls from raising undesirable exceptions on
        # invalid pathnames, is_pathname_valid() is explicitly called first.
        return is_pathname_valid(pathname) and (
            os.path.exists(pathname) or is_path_sibling_creatable(pathname))
    # Report failure on non-fatal filesystem complaints (e.g., connection
    # timeouts, permissions issues) implying this path to be inaccessible. All
    # other exceptions are unrelated fatal issues and should not be caught here.
    except OSError:
        return False

हालाँकि, ध्यान दें कि यह भी है नहीं पर्याप्त हो सकता है।

उपयोगकर्ता अभिगम नियंत्रण (UAC), कभी-कभी अक्षम किए गए Windows Vista और उसके बाद के सभी पुनरावृत्तियों के लिए धन्यवाद, जो सिस्टम निर्देशिकाओं से संबंधित अनुमतियों के बारे में स्पष्ट रूप से झूठ बोलते हैं। जब गैर-प्रशासक उपयोगकर्ता या तो विहित C:\Windowsया C:\Windows\system32निर्देशिका में फाइलें बनाने का प्रयास करते हैं, तो UAC उपयोगकर्ता को वास्तव में ऐसा करने की अनुमति देता है सभी बनाई गई फ़ाइलों को उस उपयोगकर्ता के प्रोफ़ाइल में "वर्चुअल स्टोर" में अलग कर देता है। (कौन संभवतः कल्पना कर सकता है कि धोखा देने वाले उपयोगकर्ताओं के हानिकारक दीर्घकालिक परिणाम होंगे?)

यह पागलपन है। यह विंडोज है।

इसे साबित करो

हमारी हिम्मत? यह उपरोक्त परीक्षणों का परीक्षण करने का समय है।

चूंकि NULL UNIX- ओरिएंटेड फाइल सिस्टम पर पाथनेम्स में निषिद्ध एकमात्र पात्र है, इसलिए आइए इसका लाभ उठाएं कि ठंड, कठिन सत्य का प्रदर्शन करें - गैर-अज्ञानतापूर्ण विंडोज शेंनिगन्स को अनदेखा करना, जो स्पष्ट रूप से बोर करते हैं और मुझे बराबर मापते हैं

>>> print('"foo.bar" valid? ' + str(is_pathname_valid('foo.bar')))
"foo.bar" valid? True
>>> print('Null byte valid? ' + str(is_pathname_valid('\x00')))
Null byte valid? False
>>> print('Long path valid? ' + str(is_pathname_valid('a' * 256)))
Long path valid? False
>>> print('"/dev" exists or creatable? ' + str(is_path_exists_or_creatable('/dev')))
"/dev" exists or creatable? True
>>> print('"/dev/foo.bar" exists or creatable? ' + str(is_path_exists_or_creatable('/dev/foo.bar')))
"/dev/foo.bar" exists or creatable? False
>>> print('Null byte exists or creatable? ' + str(is_path_exists_or_creatable('\x00')))
Null byte exists or creatable? False

पवित्रता से परे। दर्द से परे। आप पायथन पोर्टेबिलिटी चिंताओं को मिल जाएगा।

Question 3

if os.path.exists(filePath):
    #the file is there
elif os.access(os.path.dirname(filePath), os.W_OK):
    #the file does not exists but write privileges are given
else:
    #can not write there

ध्यान दें कि path.existsअधिक कारणों से विफल हो सकते हैं, the file is not thereइसलिए आपको परीक्षण जैसे महीन परीक्षण करने पड़ सकते हैं यदि युक्त निर्देशिका मौजूद है और इसी तरह।

ओपी के साथ मेरी चर्चा के बाद यह पता चला कि मुख्य समस्या यह है कि फ़ाइल नाम में ऐसे वर्ण हो सकते हैं जिन्हें फ़ाइल सिस्टम द्वारा अनुमति नहीं है। बेशक उन्हें हटाए जाने की जरूरत है लेकिन ओपी उतना ही मानवीय रीडबेलिटी बनाए रखना चाहता है जितना कि फाइलसिस्टम अनुमति देता है।

अफसोस की बात है कि मुझे इसके लिए कोई अच्छा उपाय नहीं पता है। हालांकि सेसिल करी का जवाब समस्या का पता लगाने पर एक करीब से देखता है।

Question 4

पायथन 3 के साथ, कैसे के बारे में:

try:
    with open(filename, 'x') as tempfile: # OSError if file exists or is invalid
        pass
except OSError:
    # handle error here

'X' विकल्प के साथ हमें दौड़ की स्थिति के बारे में भी चिंता करने की आवश्यकता नहीं है। यहाँ प्रलेखन देखें ।

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

Question 5

open(filename,'r')   #2nd argument is r and not w

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

try:
    open(filename,'r')
    return True
except IOError:
    try:
        open(filename, 'w')
        return True
    except IOError:
        return False

इसके अलावा एक नजर है यहाँ खिड़कियों पर अनुमतियों के बारे में

Question 6

कोशिश करो कि os.path.existsयह रास्ते की जाँच करेगा और Trueअगर मौजूद है और Falseनहीं तो वापस लौटेगा ।