सिंटैक्स: os.path.realpath(path) पैरामीटर: पथ: एक पथ जैसा फ़ाइल सिस्टम पथ का प्रतिनिधित्व करने वाली वस्तु। पथ जैसी वस्तु या तो एक स्ट्रिंग या बाइट्स ऑब्जेक्ट है जो पथ का प्रतिनिधित्व करता है। वापसी प्रकार: यह विधि एक स्ट्रिंग मान देता है जो विहित पथ का प्रतिनिधित्व करता है।
सॉफ्ट लिंक या प्रतीकात्मक लिंक बनाएं
यूनिक्स या लिनक्स पर, ln कमांड का उपयोग करके एक सॉफ्ट लिंक या प्रतीकात्मक लिंक बनाया जा सकता है। कमांड लाइन पर प्रतीकात्मक लिंक बनाने के लिए सिंटैक्स निम्नलिखित है:$ ln -s {source-filename} {symbolic-filename} उदाहरण 1
def realpath(self, spec, key): """ इसके साथ spec में पथ कुंजी को हल करें और अपडेट करें realpath, कार्यशील निर्देशिका पर आधारित है। अब वापस आएं यदि विशिष्ट नहीं है [कुंजी]: logger.warning ("%s का realpath हल नहीं कर सकता ` क्योंकि यह परिभाषित नहीं है", कुंजी) वापसी की जांच = realpath(join(spec.get( WORKING_DIR, ``), युक्ति [कुंजी])) यदि जाँच करें != युक्ति [कुंजी]: युक्ति [कुंजी] = जाँच लकड़हारा.चेतावनी ("realpath को `%s` में हल किया गया, कल्पना अपडेट की गई", कुंजी, चेक) रिटर्न चे सीके # सेटअप से संबंधित तरीके
उदाहरण 2
def get_rp_stripper(strip_path): """ स्ट्रिप ``realpath```strip_path` of `strip_path` from string Parameters ---------- strip_path: str path to strip to start of string. ``strip_prefix`` पर ``realpath(strip_path) + os.path.sep` द्वारा संसाधित किया गया `। रिटर्न -------- स्ट्रिपर: func फ़ंक्शन जैसे कि `` स्ट्रिपर (a_string) `` `` स्ट्रिप_प्रीफिक्स `` को `` a_string `` से अलग कर देगा, यदि मौजूद है, अन्यथा `` a_string `` अनमॉडिफाइड """ रिटर्न पास करें get_prefix_stripper(realpath(strip_path) + os.path.sep)
उदाहरण 3
def test_toolchain_standard_not_implemented(self): spec = Spec() with self.assertRaises(NotImplementedError): self.toolchain(spec) with self.assertRaises(NotImplementedError): self.toolchain.aumble(spec) with self.assertRaises(NotImplementedError): self.toolchain.link(spec) # जांचें कि build_dir tempfile self.assertTrue(spec[`build_dir`].startswith( realpath(tempfile.gettempdir())) # साथ ही इसे ठीक से मिटा दिया गया है। self.assertFalse(exists(spec[`build_dir`]) ))
उदाहरण 4
def find_system_jdks(): """ मान्य JD का एक सेट लौटाता है मानक स्थानों की खोज करके K निर्देशिकाएँ। """ आधार = [`/ लाइब्रेरी/जावा/जावावर्चुअल मशीन्स`, `/ usr/lib/jvm`, `/ usr/java`, `/ usr/jdk/इंस्टेंस`, r`C: प्रोग्राम फाइल्सजावा`] jdks = आधार में आधार के लिए सेट (): यदि isdir (आधार): os.listdir (आधार) में n के लिए: jdk = शामिल हों (आधार, n) mac_jdk = join(jdk, `Contents`, `Home`) if isdir(mac_jdk) ): jdk = mac_jdk अगर is_valid_jdk(jdk): jdks.add(realpath(jdk)) वापसी jdks
उदाहरण 5
def _expand_dirs_to_files(files_or_dirs, पुनरावर्ती=गलत): files = [] files_or_dirs = _ensure_list(files_or_dirs) file_or_dir के लिए files_or_dirs में: op.realpath(file_or_dir) if op.isdir(file_or_dir): # `.` से शुरू होने वाले dirnames को छोड़ें। अगर _to_skip(file_or_dir): जारी रखें # पुनरावर्ती रूप से निर्देशिकाओं पर जाएँ और फ़ाइलें जोड़ें। यदि पुनरावर्ती: files.extend(_expand_dirs_to_files([op.join(file_or_dir, file) for file in os.listdir(file_or_dir)], पुनरावर्ती=पुनरावर्ती) ) और: files.extend([op.join(file_or_dir, file) for file in os.listdir(file_or_dir)]) elif `*` in file_or_dir: files.extend(glob.glob(file_or_dir)) और: files.append (file_or_dir) रिटर्न फाइल
उदाहरण 6
def getSubdirs(path, baseNamesOnly=True, outPythonModulesDirs=True): """दिए गए पथ के लिए उप निर्देशिकाओं की सूची प्रदान करता है"" " subdirs = [] कोशिश करें: पथ = realpath(path) + os.listdir में आइटम के लिए सितंबर (पथ): उम्मीदवार = पथ + आइटम अगर isdir (उम्मीदवार): अगर बहिष्कृत करेंPythonModulesDirs: modFile = उम्मीदवार + sep + "__init__.py" यदि मौजूद है (modFile): जारी रखें यदि baseNamesOnly: subdirs.append(item) अन्य: subdirs.append (उम्मीदवार) को छोड़कर: रिटर्न सबडिर्स पास करें
उदाहरण 7
<पूर्व> def get_dataset(num_points): नाम = `ModelNet10` पथ = osp.join(osp.dirname(osp.रियलपाथ(__file__)), `..`, `डेटा`, नाम) pre_transform = T.NormalizeScale() ट्रांसफॉर्म = T.SamplePoints(num_points) train_dataset = ModelNet(path, name=`10`, ट्रेन = ट्रू, ट्रांसफॉर्म = ट्रांसफॉर्म, प्री_ट्रांसफॉर्म = प्री_ट्रांसफॉर्म) टेस्ट_डेटासेट = मॉडलनेट (पथ, नाम = `10`, ट्रेन = गलत, ट्रांसफॉर्म = ट्रांसफॉर्म, प्री_ट्रांसफॉर्म = प्री_ट्रांसफॉर्म) रिटर्न ट्रेन_डेटासेट, टेस्ट_डेटासेटउदाहरण 8
def getParameters(self): """खोज पैरामीटर के साथ एक शब्दकोश प्रदान करता है"""पैरामीटर = {`टर्म`: self.findCombo.currentText(), `case`: self.caseCheckBox.ischecked( ), `संपूर्ण`: self.wordCheckBox.ischecked(), `regexp`: self.regexpCheckBox.ischecked ()} अगर self.projectRButton.ischecked (): पैरामीटर [`इन-प्रोजेक्ट`] = सही पैरामीटर [`इन- open`] = गलत पैरामीटर [`in-dir`] = `` elif self.openFilesRButton.ischecked (): पैरामीटर [`इन-प्रोजेक्ट`] = F अन्य पैरामीटर [`इन-ओपन`] = सही पैरामीटर [`इन-डीआईआर`] = `` अन्य: पैरामीटर [`इन-प्रोजेक्ट`] = गलत पैरामीटर [`इन-ओपन`] = गलत पैरामीटर [`इन-डीआईआर` `] = realpath(self.dirEditCombo.currentText().strip()) पैरामीटर्स[`फाइल -filter`] = self.filterCombo.currentText().strip() रिटर्न पैरामीटर उदाहरण 9
def _check_if_pyc(fname): """यदि एक्सटेंशन . pyc, False if .py और कोई नहीं अगर अन्यथा""" imp आयात से os.path आयात से find_module realpath a>, dirname, basename, splitext # find_module() filepath = realpath(fname) dirpath = dirname(filepath) module_name = splitext(basename(filepath))[0] # मान्य करें और कोशिश करें: fileobj, fullpath, (_, _, pytype) = Find_module(module_name, [dirpath]) ImportError को छोड़कर : IOError बढ़ाएँ ("कॉन्फ़िगरेशन फ़ाइल नहीं ढूँढ सकता। " "पथ शायद गलत है!: {0}.format(filepath)) वापसी pytype, fileobj, fullpath
उदाहरण 10
def get_planetoid_dataset(name, normalize_features=False,Transform= कोई नहीं): पथ = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `डेटा`, नाम) डेटासेट = प्लैनेटॉइड (पथ, नाम) यदि ट्रांसफ़ॉर्म कोई नहीं है और normalize_features: डेटासेट.ट्रांसफ़ॉर्म = T.Compose ([T.NormalizeFeatures (), ट्रांसफ़ॉर्म]) elif normalize_features: डेटासेट। ट्रांसफ़ॉर्म = T.NormalizeFeatures() elif ट्रांसफ़ॉर्म कोई नहीं है: डेटासेट.ट्रांसफ़ॉर्म = ट्रांसफ़ॉर्म रिटर्न डेटासेट
उदाहरण 11
def _setup_logger(cls, log_file=None): फ़ॉर्मेटर = लॉगिंग। फॉर्मेटर(fmt="%(asctime)s%(levelname)-8s%(message)s", datefmt="%Y-%m-%d %H:%M:%S") Screen_handler = logging.StreamHandler( स्ट्रीम = sys.stdout) स्क्रीन_हैंडलर.सेटफॉर्मेटर (फॉर्मेटर) लकड़हारा = logging.getLogger(cls.__name__) logger.setLevel(logging.DEBUG) logger.addHandler(screen_handl एर) अगर log_file: file_handler = logging.FileHandler(realpath(log_file), mode="w" ) file_handler.setFormatter(formatter) logger.addHandler(file_handler) रिटर्न लॉगर
उदाहरण 12
def bro_server(bro_file, interface="eth0", bro_path="/usr/local/ bro/bin/bro"): u""" broÊúçÂä°ËøõÁ®ã """ # é∑ÂèñÁªùÂØπË∑ØÂæÑ bro_file = पथ।realpath(bro_file) http_file = "/usr/local/bro/share/bro/base/protocols/http/main.bro" bro_scripts = ` `.join([bro_file, http_file ]) cmd = "sudo {bro_path} -C -b -i {इंटरफ़ेस} {bro_scripts}" cmd = cmd.format (bro_path=bro_path, इंटरफ़ेस=इंटरफ़ेस, bro_scripts=bro_scripts) msg = "cmd is: %s" % cmd logging.info(msg) # pwd को /tmp tmp_dir = path.join(path.dirname(path.वास्तविकपथ(__file__)), `../../tmp/`) chdir(tmp_dir) परिणाम = r un(cmd) logging.info(result.__dict__)
उदाहरण 13
def ProcessFlags(env, flags): f के लिए फ्लैग में: if f: env.MergeFlags(str( f)) # एन्यूमरेट में i, p के लिए सापेक्ष CPPPATH को ठीक करें (env.get("CPPPATH", [])): if isdir(p): env[`CPPPATH`][i] = realpath(p) # नाम की किसी भी पिछली परिभाषा को रद्द करें, या तो बिल्ट-इन या # -D विकल्प के साथ प्रदान किया गया // मुद्दा # 191 undefines = [u for u in env.get("CCFLAGS", []) if u.startswith("-U")] if undefines: undefin in undefines: env[`CCFLAGS`].remove(undef) env. संलग्न करें(_CPPDEFLAGS=" %s" % " ".join(undefines)) उदाहरण 14
def _get_settings_helper(self): main_dir = path.dirname(path.realpath(__file__)) main_dir = path.realpath(path.join(main_dir, `..`, `..`)) default_filepath = path.join(main_dir, `default_settings. yml`) user_filepath = path.join(main_dir, `settings.yml`) args = self._get_args() अगर args.settings_path: user_filepath = args.settings_path # डिफॉल्ट फाइल खोलें और डिफॉल्ट_फाइलस्ट्रीम के रूप में ओपन (डिफॉल्ट_फाइलपाथ) के साथ वर्जन की जानकारी प्राप्त करें : default_filesettings = yaml.load(default_filestream) # FIXME: उपयोग नहीं किया गया current_version = default_filesettings[`version`].split(`.`) #flake8: noqa if path.exists(user_filepath): filepath = user_filepath अन्य: filepath = default_filepath के साथ open(filepath) as Setting_file: self.settings = yaml.load(setting_file, _OrderedLoader) return SpecialDict(**self.settings)
उदाहरण 15
def संकल्प_rpath(lib_path, rpaths) ): """ अपने `@rpath` के साथ `lib_path` लौटाएं यदि `lib_path` में `@rpath` नहीं है तो इसे वापस कर दिया जाता है। यदि `lib_path` में `@rpath` है तो पहला `rpaths`/`lib_path` संयोजन लौटाता है। यदि पुस्तकालय `rpaths` में नहीं पाया जा सकता है तो एक विस्तृत चेतावनी मुद्रित की जाती है और `lib_path` को वैसे ही वापस कर दिया जाता है। पैरामीटर्स ---------- lib_path: str लाइब्रेरी फ़ाइल का पथ, जो `@rpath` से शुरू हो भी सकता है और नहीं भी। rpaths: str का अनुक्रम खोज पथों का एक क्रम, जिसे आमतौर पर `get_rpaths` पर कॉल से प्राप्त किया जाता है। रिटर्न ------- lib_path: str A str हल की गई लाइब्रेरी के साथ realpath। """ अगर नहीं तो lib_path.startswith(`@rpath/`): वापसी lib_path lib_rpath = lib_path.split(`/`, 1)[1] rpath में rpath के लिए: rpath_lib = realpath(pjoin(rpath, lib_rpath)) अगर os.path.exists(rpath_lib): वापसी rpath_lib चेतावनियां। चेतावनी ("नहीं मिल सका { 0} पथों पर: {1}.format( lib_path, `` `.join(realpath( पथ) rpaths में पथ के लिए), ) ) वापसी lib_path
उदाहरण 16
def Wheel_libs(wheel_fname, filt_func=None): """ पायथन व्हील के साथ लाइब्रेरी निर्भरता का विश्लेषण लौटाएं निर्भरता के पेड़ के डंप के लिए इस दिनचर्या का प्रयोग करें। पैरामीटर्स ---------- Wheel_fname: str व्हील का फ़ाइल नाम filt_func: कोई नहीं या कॉल करने योग्य, वैकल्पिक यदि कोई नहीं, लाइब्रेरी निर्भरता के लिए सभी फाइलों का निरीक्षण करें। यदि कॉल करने योग्य है, तो फ़ाइल नाम को तर्क के रूप में स्वीकार करता है, अगर हमें फ़ाइल का निरीक्षण करना चाहिए तो सही है, अन्यथा गलत है। रिटर्न ------- lib_dict: डिक्शनरी डिक्शनरी (कुंजी, मान) जोड़े (``libpath``, ``निर्भरता_डिक्ट``) के साथ। ``libpath`` पहिए के पेड़ के भीतर पहिया रूट पथ के सापेक्ष पुस्तकालय पर निर्भर है। ``dependings_dict`` (``निर्भर_lib_path``, ``install_name``) का (कुंजी, मान) है। फिर से, ``निर्भर_लिब_पथ`` व्हील रूट पथ के सापेक्ष पुस्तकालय है, यदि व्हील ट्री के भीतर है। """ अस्थायी निर्देशिका () के साथ tmpdir के रूप में: zip2dir(wheel_fname, tmpdir) lib_dict = tree_libs(tmpdir, filt_func) वापसी stripped_lib_dict(lib_dict, realpath(tmpdir) + os.path.sep)
उदाहरण 17
def main(): parser = OptionParser(use="%s WHEEL_OR_PATH_TO_ANALYZE "% sys.argv[0] + __doc__, version="%prog" + __version__) parser.add_options([ Option("-a", "--all", action="store_true", help="सभी निर्भरता दिखाएं , सिस्टम libs सहित"), विकल्प ("-d", "--निर्भर", क्रिया = "store_true", सहायता = "निर्भरता के आधार पर पुस्तकालय दिखाएं")]) (opts, पथ) = parser.parse_args() यदि लेन (पथ) <1: parser.print_help () sys.exit (1) बहु = लेन (पथ) > 1 पथ में पथ के लिए: यदि बहु: प्रिंट (पथ + `:`) इंडेंट = ` `अन्य: इंडेंट = `` if isdir(path): lib_dict = tree_libs(path) lib_dict = stripped_lib_dict(lib_dict, realpath (getcwd ()) + psep) e lse: lib_dict = Wheel_libs (पथ) कुंजियाँ = सॉर्ट किया गया (lib_dict) यदि ऑप्ट्स नहीं है। (`` + इंडेंट).जॉइन (कुंजी)) जारी रखें i2 = इंडेंट + `` `कुंजी में कुंजी के लिए: प्रिंट (इंडेंट + कुंजी + `:`) libs = lib_dict [कुंजी] अगर लेन (libs): प्रिंट (i2 + (` ` + i2).join(libs)) उदाहरण 18
def test_given_directory(): # टेस्ट InGivenDirectory cwd = getcwd() InGivenDirectory() के साथ tmpdir के रूप में: assert_equal( tmpdir, abspath(cwd)) assert_equal(tmpdir, abspath(getcwd())) InGivenDirectory(MY_DIR) के साथ tmpdir के रूप में: assert_equal(tmpdir, MY_DIR) assert_equal(realpath(MY_DIR), realpath(abspath) (getcwd ()))) # हम दी गई निर्देशिका को हटा रहे थे! अभी चेक करें ऐसा नहीं है। assert_true(isfile(MY_PATH))
उदाहरण 19
defdecyClean(workDir, आर्किटेक्चर, एग्रेसिवक्लीनअप): """ यह तय करता है कि वास्तव में इसे किए बिना क्या हटाना है: - सभी खोजें "बिल्ड" में सिम्लिंक - "बिल्ड" में सभी निर्देशिका खोजें - एक निर्देशिका को हटाने के लिए शेड्यूल करें यदि इसमें सिमलिंक नहीं है """ सिमलिंक्सबिल्ड = [os.readlink(x) x के लिए glob.glob("%s/ BUILD/*-latest*" % workDir)] # $WORK_DIR/TMP को हमेशा साफ करना चाहिए। ऐसा केवल # नहीं होता है जब अनपैक करते समय हमारे पास जगह खत्म हो जाती है। # $WORK_DIR/<आर्किटेक्चर>/स्टोर को भी साफ किया जा सकता है, क्योंकि # वास्तविक टारबॉल बनने के बाद हमें उनकी आवश्यकता नहीं होती है। toDelete = ["%s/TMP" % workDir] अगर आक्रामक सफाई: toDelete += ["%s/TARS/%s/store"% (workDir, आर्किटेक्चर), "%s/SOURCES"% (workDir)] allBuildStuff = glob.glob("%s/BUILD/*" % workDir) toDelete += [x for x in allBuildStuff यदि पथ नहीं है। */"% (workDir, आर्किटेक्चर) installPackages = set([dirname(x) for x in glob.glob(installGlob)]) symlinksInstall = [] for x in installPackages: symlinksInstall += [path.realpath(y) for y in glob.glob(x + "/latest*")] toDelete += [x for x in glob.glob(installGlob+ "*") अगर पथ नहीं है। a>(x) in symlinksInstall] toDelete = [x for x in toDelete if path.exists(x)] वापसी पर Delete उदाहरण 20
def _get_script_dir(follow_symlinks: bool = True ) -> पथ: # ट्रस्ट स्टोर के लिए पथ प्राप्त करना मुश्किल है OS X, Linux और Windows पर सूक्ष्म अंतर के कारण अगर getattr(sys, "frozen", False): # py2exe, PyInstaller, cx_Freeze path = Path(sys.executable).absolute() अन्य: पथ = पथ (inspect.getabsfile) (_get_script_dir)) अगर follow_symlinks: पथ = पथ(realpath(path)) वापसी पथ। माता-पिता
संग्रह
os.path.realpath() पायथन में पथ में पाए जाने वाले किसी भी सिम्लिंक को हटाकर एक निर्दिष्ट फ़ाइल नाम का विहित पथ प्राप्त करने के लिए उपयोग किया जाता है।
वाक्यविन्यास: os.path।वास्तविकपथ (पथ)
पैरामीटर:
पथ : A पथ-जैसी वस्तु फ़ाइल सिस्टम पथ का प्रतिनिधित्व करती है।
पथ जैसी वस्तु या तो स्ट्रिंग या बाइट्स पथ का प्रतिनिधित्व करने वाली वस्तु है।वापसी प्रकार: यह विधि एक स्ट्रिंग मान देता है जो विहित पथ का प्रतिनिधित्व करता है।
सॉफ्ट लिंक या प्रतीकात्मक लिंक बनाएं
यूनिक्स या लिनक्स पर, ln कमांड का उपयोग करके एक सॉफ्ट लिंक या प्रतीकात्मक लिंक बनाया जा सकता है।¬†निम्नलिखित कमांड लाइन पर एक प्रतीकात्मक लिंक बनाने के लिए सिंटैक्स है:
$ ln -s {source-filename} {symbolic-filename} उदाहरण:
उदाहरण:
उपरोक्त आउटपुट में, " / होम / इहृतिक / डेस्कटॉप / फाइल (शॉर्टकट) .txt " एक प्रतीकात्मक कड़ी है।
कोड: os.path का उपयोग करना।realpath () विहित पथ और संकल्प प्रतीकात्मक लिंक प्राप्त करने की विधि।
<तालिका सीमा = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0"> < tr>
# os.path को समझाने के लिए Python प्रोग्राम।realpath () विधि
  
ओएस मॉड्यूल का # आयात
<कोड वर्ग =" कीवर्ड "> आयात <कोड वर्ग = "सादा"> ओएस
 
<कोड वर्ग = "टिप्पणियां"> # पथ
<कोड वर्ग = ¬† "सादा"> पथ <कोड वर्ग = "कीवर्ड"> = <कोड क्लास = "स्ट्रिंग"> "/ होम / इह्रिटिक / डेस्कटॉप / फाइल (शॉर्टकट) .txt"
 
 
# विहित पथ प्राप्त करें
<कोड वर्ग = "टिप्पणियां"> # किसी भी प्रतीकात्मक लिंक को हटाकर
<कोड वर्ग = "टिप्पणियां"> # रास्ते में मिले
real_path = os.path.realpath (पथ)
 
# विहित पथ प्रिंट करें
Print ( real_path)
 
 
# Path
< कोड वर्ग = "सादा"> पथ <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "स्ट्रिंग"> "/../../ GeeksForGeeks / sample.py"
 
 
# विहित पथ प्राप्त करें
निर्दिष्ट पथ के #
<कोड वर्ग = "टिप्पणियां"> # किसी भी एस का उन्मूलन ymbolic लिंक
# पथ में मिले
real_path = <कोड वर्ग = "सादा"> ओएस पथ।realpath a> (पथ)
 
<कोड वर्ग = "टिप्पणियां"> # विहित पथ प्रिंट करें
<कोड वर्ग = "फ़ंक्शंस"> प्रिंट <कोड क्लास = "प्लेन"> (रियल_पाथ)
 
 
<कोड क्लास = "टिप्पणियां"> # पथ
<कोड वर्ग = "सादा"> पथ <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "स्ट्रिंग" > "file.txt"
<कोड वर्ग = "अपरिभाषित रिक्त स्थान">¬†¬†
<कोड वर्ग =" अपरिभाषित रिक्त स्थान ">¬†¬†
# विहित पथ प्राप्त करें
# निर्दिष्ट पथ
# किसी भी सांकेतिक लिंक को हटा दें
# मिले रास्ते में
real_path = os . पथ।realpath (पथ)
 
<कोड वर्ग = "टिप्पणियां"> # विहित पथ प्रिंट करें
<कोड वर्ग = "कीवर्ड"> प्रिंट <कोड वर्ग = "सादा"> (real_path)
 
os.chdir ( " / home / ihritik / डाउनलोड / " )
 
# पथ
<कोड वर्ग = "सादा"> पथ <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "स्ट्रिंग"> "file.txt"
 
# विहित पथ प्राप्त करें
# निर्दिष्ट पथ के
<कोड वर्ग = "टिप्पणियां"> # किसी भी प्रतीकात्मक लिंक का उन्मूलन
<कोड वर्ग = "commen ts"> # पथ में मिले
real_path = os.path।realpath (पथ)
<कोड वर्ग = "अपरिभाषित रिक्त स्थान">¬†¬†
<कोड वर्ग = "टिप्पणियां"> # विहित पथ प्रिंट करें
<कोड वर्ग = "फ़ंक्शंस"> प्रिंट <कोड क्लास = "सादा"> (real_path)
बाहर निकलें:
/ घर / ihritik / दस्तावेज़ / फ़ाइल (मूल) .txt /GeeksForGeeks/sample.py /home/ihritik/file.txt /home/ihritik/Downloads /file.txt