Syntaxis: os.path.realpath(pad) Parameter: pad: Een pad-achtige object dat het pad van het bestandssysteem vertegenwoordigt. Een padachtig object is een tekenreeks of een bytes-object dat een pad vertegenwoordigt. Return Type: Deze methode retourneert een tekenreekswaarde die het canonieke pad vertegenwoordigt.
Maak een zachte link of symbolische link
Op Unix of Linux kan een zachte link of symbolische link worden gemaakt met behulp van het ln-commando. Hieronder volgt de syntaxis voor het maken van een symbolische link op de opdrachtregel:$ ln -s {source-filename} {symbolic-filename} Voorbeeld 1
def realpath(self, spec, key): """ Los de padsleutel in de specificatie op met zijn realpath, gebaseerd op de werkdirectory. """ indien sleutel niet in spec: # niets doen voor keer nu terug indien niet spec[key]: logger.warning( "cannot resolve realpath van `%s ` zoals het niet is gedefinieerd", key) return check = realpath(join(spec.get( WORKING_DIR, ``), spec[key])) if check != spec[key]: spec[key] = check logger.warning( "realpath van `%s` omgezet in `%s`, specificatie is bijgewerkt", key, check ) return che ck # Setup-gerelateerde methoden
Voorbeeld 2
def get_rp_stripper(strip_path): """ Retourfunctie naar strip ``realpath`` van `strip_path` van string Parameters ---------- strip_path: str pad naar strip vanaf het begin van strings. Verwerkt tot ``strip_prefix`` door ``realpath(strip_path) + os.path.sep` `. Retourneert ------- stripper: func functie zodanig dat ``stripper(a_string)`` ``strip_prefix`` zal strippen van ``a_string`` indien aanwezig, anders ``a_string`` ongewijzigd doorgeven """ return get_prefix_stripper(realpath(strip_path) + os.path.sep)
Voorbeeld 3
def test_toolchain_standard_not_implemented(self): spec = Spec() met self.assetRaises(NotImplementedError): self.toolchain(spec) met self.assetRaises(NotImplementedError): self.toolchain.assemble(spec) with self.assetRaises(NotImplementedError): self.toolchain.link(spec) # Controleer of de build_dir is ingesteld op de specificatie op basis van het tijdelijke bestand self.assetTrue(spec[`build_dir`].startswith( realpath(tempfile.gettempdir()))) # Ook dat het correct werd verwijderd. self.assetFalse(exists(spec[`build_dir`] ))
Voorbeeld 4
def find_system_jdks(): """ Retourneert een set geldige JD K-mappen door standaardlocaties te zoeken. """ bases = [ `/Bibliotheek/Java/JavaVirtualMachines`, `/usr/lib/jvm`, `/usr/java`, `/usr/jdk/instances`, r`C:Program FilesJava` ] jdks = set() voor base in bases: if isdir(base): voor n in os.listdir(base): jdk = join(base, n) mac_jdk = join(jdk, `Contents`, `Home`) if isdir(mac_jdk ): jdk = mac_jdk if is_valid_jdk(jdk): jdks.add(realpath(jdk)) return jdks
Voorbeeld 5
def _expand_dirs_to_files(files_or_dirs, recursive=False): files = [] files_or_dirs = _ensure_list(files_or_dirs) voor file_or_dir in files_or_dirs = file_or_dirs = file_or_dirs = file_or_dirs "https://python.engineering/python-os-path-realpath-method/">realpath(file_or_dir) if op.isdir(file_or_dir): # Sla dirnamen over die beginnen met `.` if _to_skip(file_or_dir): doorgaan # Recursief de mappen bezoeken en de bestanden toevoegen.indien recursief: files.extend(_expand_dirs_to_files([op.join(file_or_dir, file) for file in os.listdir(file_or_dir)], recursive=recursive) ) else: files.extend([op.join(file_or_dir, file) voor bestand in os.listdir(file_or_dir)]) elif `*` in file_or_dir: files.extend(glob.glob(file_or_dir)) else: files.append (file_or_dir) retourneer bestanden
Voorbeeld 6
def getSubdirs(path, baseNamesOnly=True, sluitPythonModulesDirs=True): """Biedt een lijst met submappen voor het opgegeven pad"" " subdirs = [] probeer: path = realpath(pad) + sep voor item in os.listdir (pad): kandidaat = pad + item als isdir(kandidaat): indien exclusiefPythonModulesDirs: modFile = kandidaat + sep + "__init__.py" indien bestaat(modFile): doorgaan als baseNamesOnly: subdirs.append(item) else: subdirs.append (kandidaat) behalve: pass return subdirs
Voorbeeld 7
def get_dataset(num_points): name = `ModelNet10` path = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, name) pre_transform = T.NormalizeScale() transform = T.SamplePoints(num_points) train_dataset = ModelNet( path, name=`10`, train=True, transform=transform, pre_transform=pre_transform) test_dataset = ModelNet( path, name=`10`, train=False, transform=transform, pre_transform=pre_transform) return train_dataset, test_dataset
Voorbeeld 8
def getParameters(self): """Biedt een woordenboek met de zoekparameters""" parameters = {`term`: self.findCombo.currentText(), `case`: self.caseCheckBox.isChecked( ), `whole`: self.wordCheckBox.isChecked(), `regexp`: self.regexpCheckBox.isChecked()} if self.projectRButton.isChecked(): parameters[`in-project`] = True parameters[`in- geopend`] = Valse parameters[`in-dir`] = `` elif self.openFilesRButton.isChecked(): parameters[`in-project`] = F alse parameters[`in-opened`] = True parameters[`in-dir`] = `` else: parameters[`in-project`] = False parameters[`in-opened`] = False parameters[`in-dir `] = realpath( self.dirEditCombo.currentText().strip()) parameters[`file -filter`] = self.filterCombo.currentText().strip() return parameters Voorbeeld 9
def _check_if_pyc(fname): """Retourneer True als de extensie . pyc, False indien .py en Geen indien anders""" van imp import find_module van os.path import realpath, dirname, basename, splitext # Normaliseer het bestandspad voor de find_module() filepath = realpath(fname) dirpath = dirname(filepath) module_name = splitext(basename(filepath))[0] # Valideren en ophalen proberen: fileobj, fullpath, (_, _, pytype) = find_module(module_name, [dirpath]) behalve ImportError : raise IOError("Kan het configuratiebestand niet vinden. " "Pad is misschien onjuist!: {0}".format(filepath)) return pytype, fileobj, fullpath
Voorbeeld 10
def get_planetoid_dataset(name, normalize_features=False, transform= Geen): path = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, naam) dataset = Planetoid(pad, naam) als transformatie niet Geen is en normalize_features: dataset.transform = T.Compose([T.NormalizeFeatures(), transform]) elif normalize_features: dataset. transform = T.NormalizeFeatures() elif transform is niet Geen: dataset.transform = transform return dataset
Voorbeeld 11
def _setup_logger(cls, log_file=None): formatter = logging. Formatter( fmt="%(asctime)s %(levelname)-8s %(message)s", datefmt="%Y-%m-%d %H:%M:%S") screen_handler = logging.StreamHandler( stream=sys.stdout) screen_handler.setFormatter(formatter) logger = logging.getLogger(cls.__name__) logger.setLevel(logging.DEBUG) logger.addHandler(screen_handl er) if log_file: file_handler = logging.FileHandler(realpath(log_file), mode="w" ) file_handler.setFormatter(formatter) logger.addHandler(file_handler) return logger
Voorbeeld 12
def bro_server(bro_file, interface="eth0", bro_path="/usr/local/ bro/bin/bro"): u""" 跑bro服务进程 """ # 获取绝对路径 bro_file = pad.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 {interface} {bro_scripts}" cmd = cmd.format(bro_path=bro_path, interface=interface, bro_scripts=bro_scripts) msg = "de cmd is: %s" % cmd logging.info(msg) # verander pwd naar /tmp tmp_dir = path.join(path.dirname(path.realpath(__file__)), `../../tmp/`) chdir(tmp_dir) resultaat = r un(cmd) logging.info(result.__dict__)
Voorbeeld 13
def ProcessFlags(env, vlaggen): voor f in vlaggen: if f: env.MergeFlags(str( f)) # repareer relatieve CPPPATH voor i, p in enumerate(env.get("CPPPATH", [])): if isdir(p): env[`CPPPATH`][i] = realpath(p) # Annuleer elke eerdere definitie van naam, ingebouwd of # voorzien van een -D-optie // Issue #191 undefines = [u voor u in env.get("CCFLAGS", []) if u.startswith("-U")] if undefines: for undef in undefines: env[`CCFLAGS`].remove(undef) env. Append(_CPPDEFFLAGS=" %s" % " ".join(unddefines)) Voorbeeld 14
def _get_settings_helper(self): main_dir = path.dirname(path.realpath(__file__)) main_dir = pad.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() if args.settings_path: user_filepath = args.settings_path # open het standaardbestand en krijg versie-informatie met open(default_filepath) als default_filestream : default_filesettings = yaml.load(default_filestream) # FIXME: niet gebruikt current_version = default_filesettings[`version`].split(`.`) # flake8: noqa if path.exists(user_filepath): filepath = user_filepath else: filepath = default_filepath with open(filepath) as setting_file: self.settings = yaml.load(setting_file, _OrderedLoader) return SpecialDict(**self.settings)
Voorbeeld 15
def resolve_rpath(lib_path, rpaths ): """ Retourneert `lib_path` met zijn `@rpath` opgelost Als het `lib_path` geen `@rpath` heeft, wordt het geretourneerd zoals het is. Als `lib_path` `@rpath` heeft, wordt de eerste gevonden combinatie `rpaths`/`lib_path` geretourneerd. Als de bibliotheek niet kan worden gevonden in `rpaths`, wordt een gedetailleerde waarschuwing afgedrukt en wordt `lib_path` geretourneerd zoals het is. Parameters ---------- lib_path: str Het pad naar een bibliotheekbestand, al dan niet beginnend met `@rpath`. rpaths: sequence of str Een reeks zoekpaden, meestal verkregen van een aanroep naar `get_rpaths`. Retourneert ------- lib_path: str Een str met de opgeloste bibliotheken realpath. """ indien niet lib_path.startswith(`@rpath/`): return lib_path lib_rpath = lib_path.split(`/`, 1)[1] voor rpath in rpaths: rpath_lib = realpath(pjoin(rpath, lib_rpath)) if os.path.exists(rpath_lib): return rpath_lib warnings.warn( "Kon { niet vinden 0} op paden: {1}".format( lib_path, ` `.join(realpath( path) voor pad in rpaths), ) ) return lib_path
Voorbeeld 16
def wheel_libs(wheel_fname, filt_func=None): """ Retourneer analyse van bibliotheekafhankelijkheden met een Python-wiel Gebruik deze routine voor een dump van de afhankelijkheidsboom. Parameters ---------- wheel_fname: str Bestandsnaam van wheel filt_func: Geen of oproepbaar, optioneel Indien Geen, inspecteer alle bestanden op bibliotheekafhankelijkheden. Indien oproepbaar, accepteert bestandsnaam als argument, retourneert True als we het bestand moeten inspecteren, anders False. Retourneert ------- lib_dict: dict woordenboek met (sleutel, waarde) paren van (``libpath``, ``dependings_dict``). ``libpath`` is de bibliotheek waarvan afhankelijk is, relatief aan het wielwortelpad als het zich binnen de wielboom bevindt. ``dependings_dict`` is (sleutel, waarde) van (``depending_lib_path``, ``install_name``). Nogmaals, ``depending_lib_path`` is een bibliotheek ten opzichte van het wielwortelpad, indien binnen de wielboom. """ met TemporaryDirectory() als tmpdir: zip2dir(wheel_fname, tmpdir) lib_dict = tree_libs(tmpdir, filt_func) return stripped_lib_dict(lib_dict, realpath(tmpdir) + os.path.sep)
Voorbeeld 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="Toon alle afhankelijkheden , inclusief systeembibliotheken"), Option ("-d", "--depending", action="store_true", help="Toon bibliotheken afhankelijk van afhankelijkheden")]) (opts, paths) = parser.parse_args() if len(paden) < 1: parser.print_help() sys.exit(1) multi = len(paden) > 1 voor pad in paden: if multi: print(pad + `:`) indent = ` ` else: indent = `` if isdir(pad): lib_dict = tree_libs(pad) lib_dict = stripped_lib_dict(lib_dict, realpath (getcwd()) + psep) e lse: lib_dict = wheel_libs(pad) toetsen = gesorteerd(lib_dict) indien niet opts.all: toetsen = [sleutel voor sleutel in sleutels indien filter_system_libs(sleutel)] indien niet opts.depending: indien len(sleutels): print(indent + (` ` + inspringen).join(keys)) ga verder i2 = indent + ` ` for key in keys: print(indent + key + `:`) libs = lib_dict[key] if len(libs): print(i2 + (` ` + i2).join(libs)) Voorbeeld 18
def test_given_directory(): # Test InGivenDirectory cwd = getcwd() met InGivenDirectory() als tmpdir: assert_equal( tmpdir, abspath(cwd)) assert_equal(tmpdir, abspath(getcwd())) met InGivenDirectory(MY_DIR) als tmpdir: assert_equal(tmpdir, MY_DIR) assert_equal(realpath(MY_DIR), realpath(abspath (getcwd()))) # We waren de Given-directory aan het verwijderen! Controleer nu niet zo. assert_true(isfile(MY_PATH))
Voorbeeld 19
def decisionClean(workDir, architecture, agressiefCleanup): """ Bepaalt wat te verwijderen, zonder het daadwerkelijk te doen: - Vind alle symlinks in "BUILD" - Vind alle mappen in "BUILD" - Plan een map voor verwijdering als deze geen symbolische link """ heeft symlinksBuild = [os.readlink(x) voor x in glob.glob("%s/ BUILD/*-latest*" % workDir)] # $WORK_DIR/TMP moet altijd worden opgeschoond. Dit gebeurt niet alleen # als we tijdens het uitpakken geen ruimte meer hebben. # $WORK_DIR//store kan ook worden opgeschoond, omdat # we de eigenlijke tarballs niet nodig hebben nadat ze zijn gebouwd. toDelete = ["%s/TMP" % workDir] indien agressiefOpschonen: toDelete += ["%s/TAS/%s/store" % (workDir, architectuur), "%s/SOURCES" % (workDir)] allBuildStuff = glob.glob("%s/BUILD/*" % workDir) toDelete += [x voor x in allBuildStuff indien niet path.islink(x) en niet basename(x) in symlinksBuild] installGlob ="%s/%s/ */" % (werkmap, architectuur) installedPackages = set([dirname(x) for x in glob.glob(installGlob)]) symlinksInstall = [] for x in installedPackages: symlinksInstall += [path.realpath(y) voor y in glob.glob(x + "/latest*")] toDelete += [x for x in glob.glob(installGlob+ "*") indien niet path.islink(x) en niet path.realpath(x) in symlinksInstall] toDelete = [x for x in toDelete if path.exists(x)] return toDelete Voorbeeld 20
def _get_script_dir(follow_symlinks: bool = True ) -> Pad: # Het pad naar de trust stores vinden is lastig vanwege subtiele verschillen op OS X, Linux en Windows if getattr(sys, "frozen", False): # py2exe, PyInstaller, cx_Freeze path = Path(sys.executable).absolute() else: path = Path(inspect.getabsfile (_get_script_dir)) if follow_symlinks: path = Path(realpath(path)) return path.parent
Archief
os.path.realpath() in Python wordt gebruikt om het canonieke pad van een opgegeven bestandsnaam te krijgen door eventuele symbolische links in het pad te verwijderen.
Syntaxis: os.path.realpath (pad)
Parameter:
pad : A padachtig object dat het pad van het bestandssysteem vertegenwoordigt.
Een pad-achtig object is een string of bytes object dat een pad vertegenwoordigt.Retourtype: Deze methode retourneert een tekenreekswaarde die het canonieke pad vertegenwoordigt.
Maak een zachte link of symbolische link
Op Unix of Linux kan een zachte link of symbolische link worden gemaakt met behulp van het ln-commando. Volgende is de syntaxis voor het maken van een symbolische link op de opdrachtregel:
$ ln -s {source-filename} {symbolic-filename} Voorbeeld:
Voorbeeld:
In de bovenstaande uitvoer, " / home / ihritik / Desktop / bestand (snelkoppeling) .txt " is een symbolische link.
Code: met os.path.realpath () methode om symbolische links naar canoniek pad en resolutie te krijgen.
|                                 |
Afsluiten:
/ home / ihritik / Documenten / bestand (origineel) .txt /GeeksForGeeks/sample.py /home/ihritik/file.txt /home/ihritik/Downloads /file.txt