tryප්‍රකාශය භාවිතා නොකර ගොනුවක් තිබේද නැද්ද යන්න පරීක්ෂා කරන්නේ කෙසේද?

ඔබ පරික්ෂා කිරීමට හේතුව ඔබට එවැනි දෙයක් කළ හැකි නම් if file_exists: open_it(), එය භාවිතා කිරීම ආරක්ෂිත වේtry විවෘත කිරීමේ උත්සාහය වටා . පරීක්ෂා කිරීම සහ විවෘත කිරීම ගොනුව මකාදැමීම හෝ ගෙනයාම හෝ ඔබ පරීක්ෂා කරන විට සහ එය විවෘත කිරීමට උත්සාහ කරන විට අතර යම් අවදානමක් ඇත.

ගොනුව වහාම විවෘත කිරීමට ඔබ අදහස් නොකරන්නේ නම්, ඔබට භාවිතා කළ හැකිය os.path.isfile

Trueමාර්ගය දැනට පවතින සාමාන්‍ය ගොනුවක් නම් ආපසු යන්න . මෙය සංකේතාත්මක සබැඳි අනුගමනය කරයි, එබැවින් islink () සහ isfile () යන දෙකම එකම මාර්ගයක් සඳහා සත්‍ය විය හැකිය.

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

ඔබට එය ගොනුවක් බව සහතික කිරීමට අවශ්‍ය නම්.

පයිතන් 3.4 සිට pathlibමොඩියුලය වස්තු-නැඹුරු ප්‍රවේශයක් ඉදිරිපත් කරයි ( pathlib2පයිතන් 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(strict=True)දී tryවාරණ:

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

ඔබට os.path.existsශ්‍රිතය ඇත:

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

මෙය Trueලිපිගොනු සහ නාමාවලි සඳහා නැවත පැමිණෙන නමුත් ඔබට ඒ වෙනුවට භාවිතා කළ හැකිය

os.path.isfile(file_path)

එය විශේෂයෙන් ගොනුවක් දැයි පරීක්ෂා කිරීමට. එය සිම්ලින්ක් අනුගමනය කරයි.

මෙන් නොව isfile(), නාමාවලි සඳහා exists()නැවත පැමිණේ True. ඔබ සරල ගොනු හෝ ද බහලුම් පමණක් අවශ්ය නම්, ඔබ භාවිතා කරන්නේ මත පදනම්ව එසේ isfile()හෝ exists(). මෙන්න සරල REPL ප්‍රතිදානය කිහිපයක්:

>>> os.path.isfile("/etc/password.txt")
True
>>> os.path.isfile("/etc")
False
>>> os.path.isfile("/does/not/exist")
False
>>> os.path.exists("/etc/password.txt")
True
>>> os.path.exists("/etc")
True
>>> os.path.exists("/does/not/exist")
False

import os.path

if os.path.isfile(filepath):

os.path.isfile()සමඟ භාවිතා කරන්න os.access():

import os

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

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

හැකි සෑම ක්‍රමයක්ම පාහේ (අවම වශයෙන් එකක්) පවතින පිළිතුරු වල ලැයිස්තුගත කර ඇතත් (උදා: පයිතන් 3.4 විශේෂිත දේවල් එකතු කරන ලදි), මම සියල්ල එකට කාණ්ඩ කිරීමට උත්සාහ කරමි.

සටහන : මම පළ කිරීමට යන පයිතන් සම්මත පුස්තකාල කේතයේ සෑම කොටසක්ම 3.5.3 අනුවාදයට අයත් වේ .

ගැටළු ප්රකාශය :

1. ගොනුව පරීක්ෂා කරන්න ( තර්ක කළ හැකි : ෆෝල්ඩරය ("විශේෂ" ගොනුව)?) පැවැත්ම
2. උත්සාහ කිරීම / හැර / වෙනත් / අවසාන වාරණ භාවිතා නොකරන්න

හැකි විසඳුම් :

1. [පයිතන් 3]: os.path. පවතී ( ලොගින් වන්න ) (ද වැනි අනෙකුත් කාර්යය පවුලේ සාමාජිකයන් පරීක්ෂා os.path.isfile, os.path.isdir, os.path.lexistsතරමක් වෙනස් හැසිරීම් සඳහා)

   os.path.exists(path)

   මාර්ගය යනු පවතින මාර්ගයක් හෝ විවෘත ගොනු විස්තරයක් Trueනම් ආපසු යන්න . බිඳුණු සංකේතාත්මක සම්බන්ධතා සඳහා ප්‍රතිලාභ . සමහර වේදිකාවල, ඉල්ලූ ගොනුවේ os.stat () ක්‍රියාත්මක කිරීමට අවසර ලබා නොදුනහොත්, මාර්ගය භෞතිකව පැවතියද , මෙම ශ්‍රිතය නැවත පැමිණිය හැකිය .FalseFalse

   සියල්ල හොඳයි, නමුත් ආනයන ගස අනුගමනය කරන්නේ නම්:

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

     • genericpath.py , line # 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

   ඒක තියෙන්නේ උත්සාහක / හැර පමණ වාරණ [Python 3]: os. stat ( මාර්ගය, *, dir_fd = කිසිවක් නැත, follow_symlinks = සත්‍ය ) . එබැවින්, ඔබේ කේතය නොමිලේ / හැරෙන්නට උත්සාහ කරන්න , නමුත් රාමුවේ පහළින් (අවම වශයෙන්) එවැනි එක් වාරණයක් ඇත . මෙය වෙනත් විනෝද ක්‍රීඩා සඳහාද අදාළ වේ ( ඇතුළුව ). os.path.isfile

   1.1. [පයිතන් 3]: මාර්ගය. is_file ()

   • එය මාර්ග හැසිරවීමේ රසික (සහ තවත් පයිතන් අයිසී) ක්‍රමයකි, නමුත්

   • කබාය යටතේ, එය හරියටම එකම දේ කරයි ( pathlib.py , line # 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. [පයිතන් 3]: ප්‍රකාශන සන්දර්භය කළමනාකරුවන් සමඟ . එක්කෝ:

   • එකක් නිර්මාණය:

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

     • සහ එහි භාවිතය - මම ප්රතිනිර්මානය කරන්නම් os.path.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 3] භාවිතා කරන්න : contextlib. මර්දනය ( * ව්‍යතිරේක ) - විශේෂයෙන් නිර්මාණය කර ඇත්තේ ව්‍යතිරේකයන් තෝරා බේරා ගැනීම සඳහා ය

   
   එහෙත්, ඔවුන් වැඩි දවටන බව පෙනී උත්සාහක / හැර / වෙන / අවසානයේ ලෙස, කුට්ටි [Python 3]: මෙම සමඟ ප්රකාශයක් රාජ්යයන්:

   මෙය පොදු උත්සාහයට ඉඩ දෙයි ... හැර ... අවසානයේ භාවිත රටා පහසු නැවත භාවිතා කිරීම සඳහා සංයුක්ත කිරීමට.

3. ගොනු පද්ධති ගමන් කිරීමේ කාර්යයන් (සහ ගැලපෙන අයිතම (ය) සඳහා ප්‍රති results ල සොයන්න)

   • [පයිතන් 3]: os. listdir ( ලොගින් වන්න = '.' ) (හෝ [Python 3]:. os scandir ( ලොගින් වන්න = '.' ) පිළිබඳ Python v 3.5 + සපයනු: [PyPI]: scandir )

     • කබාය යටතේ, දෙකම භාවිතා කරයි:

       • Nix : [man7]: OPENDIR (3) / [man7]: READDIR (3) / [man7]: CLOSEDIR (3)
       • ජය : [MS.Docs]: FindFirstFileW ශ්‍රිතය / [MS.Docs]: FindNextFileW ශ්‍රිතය / [MS.Docs]: FindClose ශ්‍රිතය

       [GitHub] හරහා : python / cpython - (මාස්ටර්) cpython / මොඩියුල / posixmodule.c

     භාවිතා scandir () වෙනුවට listdir () සැලකිය යුතු නිසා ද, ගොනු වර්ගය හෝ ගොනුව විශේෂණය තොරතුරු අවශ්ය බව කේතය කාර්ය සාධනය වැඩි විය හැකි os.DirEntry මෙහෙයුම් පද්ධතිය නාමාවලියක් ස්කෑන් විට එය මඟින් නම් මෙම තොරතුරු හෙළිදරව් විරුද්ධව සිටී. සියළුම os.DirEntry ක්‍රම මඟින් පද්ධති ඇමතුමක් ලබා දිය හැකි නමුත් is_dir () සහ is_file () සඳහා සාමාන්‍යයෙන් අවශ්‍ය වන්නේ සංකේතාත්මක සම්බන්ධතා සඳහා පද්ධති ඇමතුමක් පමණි; os.DirEntry.stat () සෑම විටම යුනික්ස් හි පද්ධති ඇමතුමක් අවශ්‍ය නමුත් වින්ඩෝස් හි සංකේතාත්මක සම්බන්ධතා සඳහා එකක් පමණක් අවශ්‍ය වේ.

   • [පයිතන් 3]: os. walk ( ඉහළ, topdown = සත්‍ය, onerror = කිසිවක් නැත, followlinks = අසත්‍යය )
     • එය භාවිතා කරයි os.listdir( os.scandirලබා ගත හැකි විට)
   • [පයිතන් 3]: ග්ලෝබ්. iglob ( pathname , *, recursive = False ) (හෝ එහි පූර්වගාමියා:glob.glob )
     • එය රථයක කාර්යය බවක් පෙනෙන්නට නැත අවතක්සේරුවට (අවම වශයෙන් සමහර අවස්ථා වලදී), නමුත් එය තවමත් භාවිතාos.listdir

   
   , ෆෝල්ඩර පුරා මෙම අවංකව (බොහෝ සිදුවීම් තුල දී) සිට ඔවුන් (එහි නොවන wildcarded මෙන් ව්යතිරේකයන් අපගේ ප්රශ්නය සඳහා අකාර්යක්ෂම වේ glob මම ඔවුන් මත අවධාරනය යන්නේ නෑ, - @ShadowRanger පෙන්වා දී ඇති පරිදි Bing). සමහර අවස්ථාවල ගොනු නාම සැකසීම අවශ්‍ය විය හැකි බව සඳහන් නොකල යුතුය.

4. [පයිතන් 3]: os. ප්රවේශ ( ලොගින් වන්න, ක්රමය, *, dir_fd = කිසිවක්, effective_ids = අසත්ය, follow_symlinks = සැබෑ ) ලැබූ චර්යාව සමීප කිරීමට os.path.exists(ඇත්තෙන්ම එය ප්රධාන වශයෙන් නිසා 2, පුළුල් ය ^වන තර්කය)

   • ලේඛනයේ සඳහන් පරිදි පරිශීලක අවසරයන් ගොනුව "දෘශ්‍යතාව" සීමා කරයි:

     ... ආයාචනා කරන පරිශීලකයාට නිශ්චිත ප්‍රවේශ මාර්ගයක් තිබේදැයි පරීක්ෂා කරන්න . මාර්ගයෙහි පැවැත්ම පරීක්ෂා කිරීම සඳහා මාදිලිය F_OK විය යුතුය ...

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

   මම C හි ද වැඩ කරන බැවින් , මම මෙම ක්‍රමය ද භාවිතා කරමි, මන්ද යත්, එය ස්වදේශීය API s ලෙස හැඳින්වේ (නැවතත්, "$ {PYTHON_SRC_DIR} /Modules/posixmodule.c" හරහා ), නමුත් එය හැකි පරිශීලකයෙකුට දොරටුවක් විවෘත කරයි. දෝෂ , එය වෙනත් ප්‍රභේද මෙන් පයිතන් අයිස් නොවේ . @AaronHall නිවැරදිව පෙන්වා දුන් පරිදි, ඔබ කරන්නේ කුමක්දැයි ඔබ දන්නේ නැත්නම් එය භාවිතා නොකරන්න:

   • Nix : [man7]: ACCESS (2) (!!! එහි භාවිතය හඳුන්වා දිය හැකි ආරක්ෂක කුහරය පිළිබඳ සටහනට අවධානය යොමු කරන්න !!!)
   • ජය : [MS.Docs]: GetFileAttributesW ශ්‍රිතය

   සටහන : ස්වදේශික ඒපීඅයි ඇමතීම [පයිතන් 3] හරහා ද කළ හැකිය : ctypes - පයිතන් සඳහා විදේශීය ශ්‍රිත පුස්තකාලයක් , නමුත් බොහෝ විට එය වඩාත් සංකීර්ණ වේ.

   ( වින් විශේෂිත): බැවින් vcruntime * ( msvcr * ) .dll අපනයන [MS.Docs]: _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.notexist", os.F_OK)
   -1

   සටහන් :

   • එය හොඳ පුහුණුවක් නොවූවත්, මම os.F_OKඇමතුම භාවිතා කරමි , නමුත් එය පැහැදිලි බව සඳහා පමණි (එහි වටිනාකම 0 )
   • මම භාවිතා කරනවා _waccess එම කේතය මත ක්රියා කරන නිසා Python3 හා Python2 තිබියදීත් ( යුනිකෝඩ් ඔවුන් අතර අදාළ වෙනස්කම්)
   • මෙය ඉතා නිශ්චිත ප්‍රදේශයක් ඉලක්ක කළද, එය පෙර කිසිදු පිළිතුරක සඳහන් නොවීය

   
   මෙම 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"/tmp.notexist", os.F_OK)
   -1

   සටහන් :

   • ඒ වෙනුවට hardcoding libc ගේ මාර්ගය ( "/lib/x86_64-linux-gnu/libc.so.6" විය හැක (හා බොහෝ දුරට ඉඩ, ඇත) පද්ධති, පුරා වෙනස් වන) කිසිවක් (හෝ හිස් අගයක්) වෙත ලබාදිය හැක CDLL ඉදිකිරීමටත් ( ctypes.CDLL(None).access(b"/tmp", os.F_OK)). [Man7] ට අනුව : DLOPEN (3) :

     නම් ගොනු NULL වේ, පසුව නැවත හසුරුව ප්රධාන වැඩසටහන සඳහා වේ. ලබා විට dlsym (), මෙම හසුරුව සියලු හවුල් වස්තූන් විසින් අනුගමනය, ප්රධාන වැඩසටහන සංකේතයක් සඳහා සෙවුම් හේතු වැඩසටහන ආරම්භයේදී පටවා, පසුව සියලු හවුල් වස්තූන් ලෙස රුවා dlopen ධජ සමග) ( RTLD_GLOBAL .

     • ප්‍රධාන (වත්මන්) වැඩසටහන ( පයිතන් ) libc සමඟ සම්බන්ධ වී ඇති බැවින් එහි සංකේත ( ප්‍රවේශය ඇතුළුව) ) පටවනු ලැබේ
     • ප්‍රධාන , Py_Main වැනි ක්‍රියාකාරකම් නිසා මෙය ප්‍රවේශමෙන් හැසිරවිය යුතුය සහ (අනෙක් සියල්ලම) ; ඒවා ඇමතීමෙන් විනාශකාරී බලපෑම් ඇති විය හැකිය (වත්මන් වැඩසටහනට)
     • මෙය වින් සඳහා ද අදාළ නොවේ (නමුත් එය එතරම් විශාල ගනුදෙනුවක් නොවේ, මන්ද msvcrt.dll පිහිටා ඇත්තේ "% SystemRoot% \ System32" හි වන අතර එය පෙරනිමියෙන් % PATH% වේ ). මට තව දුරටත් දේවල් ගෙන මෙම හැසිරීම වින් (සහ පැච් එකක් ඉදිරිපත් කිරීමට) අවශ්‍ය විය, නමුත් පෙනෙන පරිදි, [MS.Docs]: GetProcAddress ශ්‍රිතය අපනයනය කරන ලද සංකේත "දකින්නේ" පමණි , එබැවින් යමෙකු ප්‍රධාන ක්‍රියාත්මක කළ හැකි කාර්යයන් ප්‍රකාශ නොකරන්නේ නම් ලෙස __declspec(dllexport)(ඇයි පෘථිවිය මත ඇති නිත්ය පුද්ගලයා එහෙම කරන්නේ?), ප්රධාන වැඩසටහන loadable නමුත් එච්චරමයි මෙවිට වේ

5. ගොනු පද්ධති හැකියාවන් සහිත තෙවන පාර්ශවීය මොඩියුලයක් ස්ථාපනය කරන්න

   බොහෝ දුරට, ඉහත එක් ක්‍රමයක් මත රඳා පවතිනු ඇත (සමහර විට සුළු අභිරුචිකරණයන් සහිතව).
   එක් උදාහරණයක් වනුයේ (නැවතත්, වින් විශේෂිත) [GitHub]: mhammond / pywin32 - වින්ඩෝස් සඳහා පයිතන් (pywin32) දිගු , එය 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

   • නික්ස් ( එල්එන්එක්ස් ( උබ්ටු )):

     [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

පහළ පේළිය :

• කරන්න භාවිතා උත්සාහක / 'වශයෙන් / වෙන / අවසානයේ ඔවුන් මොහොත, ප්රශ්න මාලාවක් බවට ධාවනය ඔබ වළක්වා ගත හැකි නිසා, කුට්ටි. මට සිතිය හැකි ප්‍රති-උදාහරණයක් වන්නේ කාර්ය සාධනයයි: එවැනි කොටස් මිල අධිකයි, එබැවින් ඒවා තත්පරයට සිය දහස් වාරයක් ධාවනය කළ යුතු කේතයට ඇතුළත් නොකිරීමට උත්සාහ කරන්න (නමුත් (බොහෝ අවස්ථාවලදී) එයට තැටි ප්‍රවේශය ඇතුළත් බැවින්, එය එසේ නොවේ).

අවසාන සටහන (ය) :

• මම එය යාවත්කාලීනව තබා ගැනීමට උත්සාහ කරමි, ඕනෑම යෝජනා පිළිගනු ලැබේ, පිළිතුරට එන ප්‍රයෝජනවත් ඕනෑම දෙයක් මම ඇතුළත් කරමි

ගොනුවක් තිබේදැයි පරීක්ෂා කිරීමට ඇති සරලම ක්‍රමය මෙයයි. යන්තම් නිසා ඔබ පරීක්ෂා කරන විට ගොනු පැවති නැත සහතික ඔබ එය විවෘත කිරීමට අවශ්ය වන විට එය ද ඇති කළ හැකි වෙනවා.

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

පයිතන් 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

උත්සාහ ප්‍රකාශයට මනාප දෙන්න. එය වඩා හොඳ ශෛලියක් ලෙස සලකන අතර තරඟ තත්වයන් මඟහරවා ගනී.

ඒ සඳහා මගේ වචනය ගන්න එපා. මෙම සිද්ධාන්තයට ඕනෑ තරම් සහාය තිබේ. මෙන්න යුවළක්:

• විලාසය: http://allendowney.com/sd/notes/notes11.txt හි "අසාමාන්‍ය තත්වයන් හැසිරවීම" කොටස
• තරඟ කොන්දේසි මග හැරීම

උත්සාහ කිරීමේ ප්‍රකාශයක් භාවිතා නොකර පයිතන් භාවිතා කරමින් ගොනුවක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

පයිතන් 3.4 සිට දැන් ලබා ගත හැකිය Path, ගොනුවේ නම සහිත වස්තුවක් ආනයනය කර ස්ථාපනය කරන්න , සහ is_fileක්‍රමය පරීක්ෂා කරන්න (මෙය සාමාන්‍ය ලිපිගොනු වෙත යොමු කරන සමමුහුර්ත සඳහා සත්‍ය බව නැවත ලබා දෙන බව සලකන්න):

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

ඔබ Python 2 දා නම්, ඔබ, pypi සිට pathlib මොඩියුලය සපයනු හැකි pathlib2, හෝ වෙනත් ආකාරයකින් පරීක්ෂා isfileසිට os.pathමොඩියුලය:

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

දැන් ඉහත බොහෝ විට මෙහි ඇති හොඳම direct ජු පිළිතුර විය හැකිය, නමුත් තරඟ තත්වයක් ඇතිවීමේ හැකියාව ඇත (ඔබ ඉටු කිරීමට උත්සාහ කරන දේ අනුව), සහ යටින් ක්‍රියාත්මක කිරීම a භාවිතා කරයි try, නමුත් පයිතන් tryඑය ක්‍රියාත්මක කිරීමේදී සෑම තැනකම භාවිතා කරයි .

පයිතන් tryසෑම තැනකම භාවිතා කරන නිසා , එය භාවිතා කරන ක්‍රියාවලියක් වළක්වා ගැනීමට ඇත්ත වශයෙන්ම හේතුවක් නැත.

නමුත් මෙම පිළිතුරේ ඉතිරි කොටස මෙම අවවාද සලකා බැලීමට උත්සාහ කරයි.

දිගු, වඩා බොහෝ සෙයින් පිළිතුරු

පයිතන් 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, ඔබ හුදෙක් ඔබගේ ගොනුව කියවීමට උත්සාහ කරයි, එය එහි පවතිනු ඇතැයි අපේක්‍ෂා කරන අතර එසේ නොවේ නම්, ඔබ ව්‍යතිරේකය අල්ලාගෙන පසුබෑමේ හැසිරීම අර්ථවත් කරයි.

ඔබ එය කියවීමට උත්සාහ කිරීමට පෙර ගොනුවක් තිබේදැයි පරීක්ෂා කර බැලීමට අවශ්‍ය නම්, ඔබ එය මකා දමමින් පසුව ඔබ බහු නූල් හෝ ක්‍රියාවලි භාවිතා කරමින් සිටිය හැකිය, නැතහොත් වෙනත් වැඩසටහනක් එම ගොනුව ගැන දන්නා අතර එය මකා දැමිය හැකිය - ඔබ අවදානමට ලක්වීමේ අවදානම එය ජාතිය තත්ත්වය ඔබ පරීක්ෂා නම් එය පසුව ඔබට ලැබෙන අතර, පවතින ධාවන එහි පෙර එය විවෘත කිරීම සඳහා කොන්දේසියක් (එහි පැවැත්ම) වෙනස් වේ.

ධාවන කොන්දේසි නිදොස් කිරීම ඉතා අසීරු ය, මන්ද ඔබේ වැඩසටහන අසාර්ථක වීමට හේතු විය හැකි ඉතා කුඩා කවුළුවක් ඇති බැවිනි.

නමුත් මෙය ඔබගේ අභිප්‍රේරණය නම්, භාවිතා කිරීමෙන් ප්‍රකාශයක වටිනාකම ලබා ගත හැකියtrysuppress සන්දර්භය කළමනාකරු .

උත්සාහ කිරීමේ ප්‍රකාශයකින් තොරව තරඟ කොන්දේසි මඟහරවා ගැනීම: suppress

පයිතන් 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()
... 
>>> 

පෙර පයිතන් සඳහා, ඔබට ඔබේම දෑ රෝල් කළ හැකිය suppress, නමුත් කැමැත්තකින් තොරව tryවඩා වාචික වනු ඇත. පයිතන් 3.4 ට පෙර යෙදිය හැකි පයිතන් හි කිසිදු මට්ටමකින් භාවිතා නොකරන එකම පිළිතුර මෙය බවtry මම විශ්වාස කරමි .

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)

මාර්ගය දැනට පවතින සාමාන්‍ය ගොනුවක් නම් සත්‍යය වෙත ආපසු යන්න. මෙම සංකේතාත්මක ඈඳියන් පහත, ඒ නිසා දෙදෙනාම islink()හා isfile()එම මාවතේ සඳහා සත්ය විය හැකිය.

නමුත් ඔබ මෙම ශ්‍රිතයේ ප්‍රභවය පරීක්ෂා කළහොත් , එය සත්‍ය වශයෙන්ම උත්සාහ ප්‍රකාශයක් භාවිතා කරන බව ඔබට පෙනෙනු ඇත:

# 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

යුනික්ස් සහ වින්ඩෝස් සඳහා ලබා ගත හැකිය os.access, නමුත් භාවිතා කිරීමට ඔබ කොඩි සමත් විය යුතු අතර එය ගොනු සහ නාමාවලි අතර වෙනසක් නොදක්වයි. සැබෑ ආයාචනා කරන පරිශීලකයාට ඉහළ වරප්‍රසාද සහිත පරිසරයක ප්‍රවේශය තිබේදැයි පරීක්ෂා කිරීමට මෙය වඩාත් භාවිතා කරයි:

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

එසේම එය එකම ධාවන තත්වයේ ගැටලුවලින් පීඩා විඳිති isfile. සිට ලේඛන :

සටහන: විවෘත () භාවිතා කිරීමට පෙර පරිශීලකයෙකුට ගොනුවක් විවෘත කිරීමට අවසර දී ඇත්දැයි පරීක්ෂා කිරීම සඳහා ප්‍රවේශය () භාවිතා කිරීම ආරක්ෂක සිදුරක් නිර්මාණය කරයි, මන්ද පරිශීලකයා එය හැසිරවීම සඳහා ගොනුව පරීක්ෂා කිරීම සහ විවෘත කිරීම අතර කෙටි කාල පරතරය ගසාකනු ඇත. 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:

පුද්ගලිකව, මම මේකට වැඩි කැමැත්තක් දක්වන්නේ කබාය යටතේ, එය ස්වදේශීය ඒපීඅයි ("$ {PYTHON_SRC_DIR} / මොඩියුලස් / පොසික්ස් මොඩියුලය" හරහා) ලෙස හඳුන්වන නමුත් එය පරිශීලක දෝෂ සඳහා දොරටුවක් විවෘත කරන අතර එය වෙනත් ප්‍රභේද මෙන් පයිතොනික් නොවේ :

මෙම පිළිතුර පවසන්නේ එය සාධාරණීකරණයකින් තොරව පයිතොනික් නොවන, දෝෂ සහිත ක්‍රමවේදයකට වැඩි කැමැත්තක් දක්වන බවයි. ඒවා තේරුම් නොගෙන පහත් මට්ටමේ ඒපීඅයි භාවිතා කිරීමට පරිශීලකයින් උනන්දු කරන බව පෙනේ.

එය කොන්දේසි විරහිතව ආපසු යාමෙන් සන්දර්භ කළමනාකරුවෙකු ද නිර්මාණය කරයි True , සියලු ව්‍යතිරේකයන්ට (ඇතුළුව KeyboardInterruptසහ SystemExit!) නිහ ly ව ගමන් කිරීමට ඉඩ සලසයි , එය දෝෂ සැඟවීමට හොඳ ක්‍රමයකි.

මෙය දුර්වල පුරුදු අනුගමනය කිරීමට පරිශීලකයින් දිරිමත් කරන බවක් පෙනේ.

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 ඔබගේ මෙහෙයුම් පද්ධතිය සමඟ සැරිසැරීමට සහ සම්මත ක්‍රියා කිරීමට පහසු කරයි.

යොමු කිරීම සඳහා ද බලන්න පයිතන් භාවිතයෙන් ගොනුවක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

ඔබට ඉහළ මට්ටමේ මෙහෙයුම් අවශ්‍ය නම් භාවිතා කරන්න shutil.

සමඟ ලිපිගොනු සහ ෆෝල්ඩර සඳහා පරීක්ෂා කිරීම 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 දී හොඳම ක්‍රමය තවමත් භාවිතා කරයි 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():
    ...

උත්සාහ කිරීම / හැර සහ අර්ථවත් ක්‍රියාකාරී වෙනසක් ඇති බවක් නොපෙනේ 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'

ඔබට ගොනු අගුළු දැමීම අවශ්‍ය නම් එය වෙනස් කාරණයකි.

ඔබට මෙය උත්සාහ කළ හැකිය (ආරක්ෂිත):

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] එවැනි ගොනුවක් හෝ නාමාවලියක් නොමැත: 'any.txt')

එවිට, ප්‍රති result ලය මත පදනම්ව, ඔබේ වැඩසටහනට එතැන් සිට දිගටම ක්‍රියාත්මක විය හැකිය, නැතහොත් ඔබට අවශ්‍ය නම් එය නැවැත්වීමට කේත කළ හැකිය.

භාවිතා කිරීම tryසහ exceptප්‍රකාශ කිරීම මම සැමවිටම නිර්දේශ කළද , මෙන්න ඔබට ඇති අවස්ථා කිහිපයක් (මගේ පුද්ගලික ප්‍රියතමය භාවිතා කරයි os.access):

1. ගොනුව විවෘත කිරීමට උත්සාහ කරන්න:

   ගොනුව විවෘත කිරීමෙන් සෑම විටම ගොනුවේ පැවැත්ම තහවුරු වේ. ඔබට ඒ ආකාරයටම ශ්‍රිතයක් කළ හැකිය:

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

   එය අසත්‍ය නම්, එය පයිතන්ගේ පසු සංස්කරණ වලදී නිරුපද්‍රිත IOError හෝ OSError සමඟ ක්‍රියාත්මක කිරීම නවත්වනු ඇත. ව්යතිරේකය අල්ලා ගැනීම සඳහා, ඔබට වගන්තිය හැර උත්සාහයක් භාවිතා කළ යුතුය. ඇත්ත වශයෙන්ම, ඔබට සැමවිටම tryඑවැනි ප්‍රකාශයක් භාවිතා කළ හැකිය ( මා සිතීමට සැලැස්වීම ගැන 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, එය මාර්ගයේ පැවැත්ම පරීක්ෂා කරනු ඇත. කෙසේ වෙතත්, මෙය භාවිතා කිරීම මඟින් ආරක්ෂක සිදුරක් නිර්මාණය වනු ඇත, මන්ද යමෙකුට අවසර පරීක්ෂා කිරීම සහ ගොනුව විවෘත කිරීම අතර කාලය භාවිතා කර ඔබේ ගොනුවට පහර දිය හැකිය. ගොනුවේ අවසරයන් පරීක්ෂා කිරීම වෙනුවට ඔබ කෙලින්ම ගොනුව විවෘත කිරීමට යා යුතුය. ( EAFP vs 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)එවිට ඔබට ඔබේ ගැටලුව තීරණය කළ හැකිය. එය උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි! :)

දිනය: 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']}

ගොනුව විවෘත කිරීම සඳහා නම් ඔබට පහත සඳහන් ක්‍රම වලින් එකක් භාවිතා කළ හැකිය:

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

යාවත්කාලීන කරන්න

ව්යාකූලත්වය වළක්වා ගැනීම සඳහා සහ මට ලැබී ඇති පිළිතුරු මත පදනම්ව, වර්තමාන පිළිතුර මඟින් ලබා දී ඇති නම සහිත ගොනුවක් හෝ නාමාවලියක් සොයා ගනී .

මීට අමතරව , os.access():

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

වීම R_OK, W_OKසහ X_OKඅවසරයන් පරීක්ෂා කිරීම සඳහා කොඩි ( doc ).

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

ව්‍යතිරේකයන් මතු කිරීම ඔබේ වැඩසටහනේ ප්‍රවාහ පාලනය සඳහා පිළිගත හැකි සහ පයිතොනික් ප්‍රවේශයක් ලෙස සැලකේ. නැතිවූ ලිපිගොනු IOErrors සමඟ හැසිරවීම සලකා බලන්න. මෙම තත්වය තුළ, ගොනුව පවතින නමුත් පරිශීලකයාට කියවීමේ අවසර නොමැති නම් IOError ව්‍යතිරේකයක් මතු වේ.

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

ඔබ වෙනත් අරමුණු සඳහා මේ වන විටත් NumPy ආනයනය නම් වැනි අනෙකුත් පුස්තකාල ආනයනය කිරීමට අවශ්යතාවයක් නැත pathlib, os, pathsආදිය,

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

මෙය එහි පැවැත්ම මත පදනම්ව සත්‍ය හෝ අසත්‍යය නැවත ලබා දෙනු ඇත.

ඔබට බ්‍රයන් ගේ යෝජනාව නොමැතිව ලිවිය හැකිය 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

මම වසර 10 ක පමණ කාලයක් තිස්සේ පවතින පැකේජයක කතුවරයා වන අතර එයට මෙම ප්‍රශ්නය කෙලින්ම ආමන්ත්‍රණය කරන ශ්‍රිතයක් ඇත. මූලික වශයෙන්, ඔබ වින්ඩෝස් නොවන පද්ධතියක සිටී නම්, එය Popenප්‍රවේශ වීමට භාවිතා කරයි find. කෙසේ වෙතත්, ඔබ වින්ඩෝස් හි සිටී නම්, එය අනුරූප වේfind කාර්යක්ෂම ගොනු පද්ධති ඇවිදින්නෙකු සමඟ වේ.

මෙම කේතය ම භාවිතා නොකරන tryමෙහෙයුම් පද්ධතිය තීරණය හා ඒ නිසා "යුනික්ස්" -style ඔබ හුදෙකලා හැර වාරණ ... findහෝ අතින් buillt 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

චෙක් ගොනුව හෝ නාමාවලිය පවතී

ඔබට මෙම ක්‍රම තුන අනුගමනය කළ හැකිය:

සටහන 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()

අනෙක් පිළිතුරු වල හරියටම පිළිබිඹු නොවන තවත් සුළු විචලනයක් එක් කිරීම.

මෙය 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):

මෙන්න ලිනක්ස් විධාන රේඛා පරිසරය සඳහා පේළි 1 ක පයිතන් විධානයක්. මම මේ තරම් උණුසුම් බැෂ් මිනිහෙක් නොවන නිසා මට මේ ඉතා හුරුබුහුටි බවක් පෙනේ.

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

මෙය ප්‍රයෝජනවත් වේ යැයි මම බලාපොරොත්තු වෙමි.

ඔබට පයිතන්ගේ "ඕඑස්" පුස්තකාලය භාවිතා කළ හැකිය:

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

උත්සාහ කිරීමේ ප්‍රකාශය භාවිතා නොකර ගොනුවක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

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) ගොදුරු විය හැකිය. ) දෝෂ .

එබැවින් ව්‍යතිරේක ඉහළ නැංවීම ඔබේ වැඩසටහනේ ප්‍රවාහ පාලනය සඳහා පිළිගත හැකි සහ පයිතොනික් ප්‍රවේශයක් ලෙස සැලකේ. නැතිවූ ලිපිගොනු ප්‍රකාශවලට වඩා IOErrors සමඟ හැසිරවීම ගැන සලකා බැලිය යුතුය if( උපදෙස් පමණක් ).

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)