Syntax: os.path.realpath(path) Parameter: path: A path-like Objekt, das den Dateisystempfad darstellt. Ein pfadähnliches Objekt ist entweder ein String- oder ein Bytes-Objekt, das einen Pfad darstellt. Rückgabetyp: Diese Methode gibt einen Zeichenfolgenwert zurück, der den kanonischen Pfad darstellt.
Softlink oder symbolischen Link erstellen
Unter Unix oder Linux kann ein Softlink oder symbolischer Link mit dem ln-Befehl erstellt werden. Im Folgenden finden Sie die Syntax zum Erstellen eines symbolischen Links auf der Befehlszeile:$ ln -s {Name der Quelldatei} {Name der symbolischen Datei} Beispiel 1
def realpath(self, spec, key): """ Lösen und aktualisieren Sie den Pfadschlüssel in der Spezifikation mit seiner realpath, basierend auf dem Arbeitsverzeichnis. """ if key not in spec: # do nothing for jetzt zurückgeben, wenn nicht spec[key]: logger.warning( "cannot resolve realpath of `%s ` da es nicht definiert ist", key) return check = realpath(join(spec.get( WORKING_DIR, ``), spec[key])) if check != spec[key]: spec[key] = check logger.warning( "realpath von `%s` in `%s` aufgelöst, Spezifikation wird aktualisiert", Schlüssel, check ) return che ck # Setze verwandte Methoden ein
Beispiel 2
def get_rp_stripper(strip_path): """ Rückgabefunktion zum Strip ``realpath`` of `strip_path` from string Parameters ---------- strip_path: str Pfad zum Strippen vom Anfang der Strings. Verarbeitet zu ``strip_prefix`` von ``realpath(strip_path) + os.path.sep` `. Rückgabe ------- stripper: func-Funktion, so dass ``stripper(a_string)`` ``strip_prefix`` von ``a_string`` entfernen wird, falls vorhanden, andernfalls wird ``a_string`` unverändert """ zurückgegeben get_prefix_stripper(realpath(strip_path) + os.path.sep)
Beispiel 3
def test_toolchain_standard_not_implemented(self): spec = Spec() with self.assertRaises(NotImplementedError): self.toolchain(spec) with self.assertRaises(NotImplementedError): self.toolchain.assemble(spec) with self.assertRaises(NotImplementedError): self.toolchain.link(spec) # Überprüfen Sie, ob build_dir auf der Spezifikation basierend auf tempfile festgelegt ist self.assertTrue(spec[`build_dir`].startswith( realpath(tempfile.gettempdir()))) # Auch, dass es ordnungsgemäß gelöscht wurde. self.assertFalse(exists(spec[`build_dir`] ))
Beispiel 4
def find_system_jdks(): """ Gibt eine Menge gültiger JD zurück K-Verzeichnisse durch Durchsuchen von Standardspeicherorten. """ bases = [ `/Library/Java/JavaVirtualMachines`, `/usr/lib/jvm`, `/usr/java`, `/usr/jdk/instances`, r`C:Program FilesJava` ] jdks = set() für base in bases: if isdir(base): for 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
Beispiel 5
def _expand_dirs_to_files(files_or_dirs, recursive=False): files = [] files_or_dirs = _ensure_list(files_or_dirs) for file_or_dir in files_or_dirs: file_or_dir = op.realpath(file_or_dir) if op.isdir(file_or_dir): # Überspringe dirnames beginnend mit `.` if _to_skip(file_or_dir): Continue # Besuche rekursiv die Verzeichnisse und füge die Dateien hinzu if recursive: 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) for file in os.listdir(file_or_dir)]) elif `*` in file_or_dir: files.extend(glob.glob(file_or_dir)) else: files.append (file_or_dir) gibt Dateien zurück
Beispiel 6
def getSubdirs(path, baseNamesOnly=True, excludePythonModulesDirs=True): """Liefert eine Liste von Unterverzeichnissen für den angegebenen Pfad"" " subdirs = [] try: path = realpath(path) + sep for item in os.listdir (Pfad): Kandidat = Pfad + Element, wenn isdir(Kandidat): wenn ausschließenPythonModulesDirs: modFile = Kandidat + sep + "__init__.py" wenn vorhanden (modFile): fortfahren, wenn baseNamesOnly: subdirs.append(item) sonst: subdirs.append (Kandidat) außer: pass return subdirs
Beispiel 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
Beispiel 8
def getParameters(self): """Stellt ein Wörterbuch mit den Suchparametern bereit""" parameters = {`term`: self.findCombo.currentText(), `case`: self.caseCheckBox.isChecked( ), `ganz`: self.wordCheckBox.isChecked(), `regexp`: self.regexpCheckBox.isChecked()} if self.projectRButton.isChecked(): parameters[`in-project`] = True parameters[`in- geöffnet`] = Falsch 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() Rückgabeparameter Beispiel 9
def _check_if_pyc(fname): """Gib True zurück, wenn die Erweiterung . pyc, False, wenn .py und None, wenn sonst""" from imp import find_module from os.path import realpath, dirname, basename, splitext # Den Dateipfad für find_module() normalisieren filepath = realpath(fname) dirpath = dirname(filepath) module_name = splitext(basename(filepath))[0] # Validiere und hole try: fileobj, fullpath, (_, _, pytype) = find_module(module_name, [dirpath]) außer ImportError : raise IOError("Kann Konfigurationsdatei nicht finden. " "Pfad möglicherweise falsch!: {0}".format(filepath)) return pytype, fileobj, fullpath
Beispiel 10
def get_planetoid_dataset(name, normalize_features=False, transform= Keine): path = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, name) dataset = Planetoid(path, name) if transform is not None und normalize_features: dataset.transform = T.Compose([T.NormalizeFeatures(), transform]) elif normalize_features: dataset. transform = T.NormalizeFeatures() elif transform ist nicht None: dataset.transform = Transform Rückgabedatensatz
Beispiel 11
def _setup_logger(cls, log_file=None): formatter = Protokollierung. 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) Protokollierung zurückgeben
Beispiel 12
def bro_server(bro_file, interface="eth0", bro_path="/usr/local/ bro/bin/bro"): u""" Ë∑ëbroÊúçÂä°ËøõÁ®ã """ # Ëé∑ÂèñÁªùÂØπË∑ØÂæÑ bro_file = path.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 = "der cmd ist: %s" % cmd logging.info(msg) # pwd in /tmp ändern tmp_dir = path.join(path.dirname(path.realpath(__file__)), `../../tmp/`) chdir(tmp_dir) result = r un(cmd) logging.info(result.__dict__)
Beispiel 13
def ProcessFlags(env, flags): for f in flags: if f: env.MergeFlags(str( f)) # relativen CPPPATH für i, p in enumerate(env.get("CPPPATH", [])) korrigieren: if isdir(p): env[`CPPPATH`][i] = realpath(p) # Irgendeine vorherige Definition des Namens aufheben, entweder eingebaut oder # mit einer Option -D versehen // Issue #191 undefines = [u für u in env.get("CCFLAGS", []) if u.startswith("-U")] if undefines: for undef in undefines: env[`CCFLAGS`].remove(undef) env. Append(_CPPDEFFLAGS=" %s" % " ".join(undefines)) Beispiel 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() if args.settings_path: user_filepath = args.settings_path # öffne die Standarddatei und erhalte Versionsinformationen mit open(default_filepath) als default_filestream : default_filesettings = yaml.load(default_filestream) # FIXME: not used 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)
Beispiel 15
def resolve_rpath(lib_path, rpaths ): """ Gibt `lib_path` mit aufgelöstem `@rpath` zurück. Wenn der `lib_path` kein `@rpath` hat, wird er so zurückgegeben, wie er ist. Wenn „lib_path“ „@rpath“ enthält, wird die erste gefundene „rpaths“/„lib_path“-Kombination zurückgegeben. Wenn die Bibliothek nicht in „rpaths“ gefunden werden kann, wird eine detaillierte Warnung ausgegeben und „lib_path“ unverändert zurückgegeben. Parameter ---------- lib_path: str Der Pfad zu einer Bibliotheksdatei, die mit `@rpath` beginnen kann oder nicht. rpaths: Sequenz von str Eine Sequenz von Suchpfaden, die normalerweise von einem Aufruf von `get_rpaths` erhalten wird. Rückgabe ------- lib_path: str Ein str mit den aufgelösten Bibliotheken realpath. """ wenn nicht lib_path.startswith(`@rpath/`): gebe lib_path lib_rpath = lib_path.split(`/`, 1)[1] für rpath in rpaths zurück: rpath_lib = realpath(pjoin(rpath, lib_rpath)) if os.path.exists(rpath_lib): return rpath_lib warnings.warn( "Konnte { nicht finden 0} auf Pfaden: {1}".format( lib_path, ` `.join(realpath( path) für path in rpaths), ) ) return lib_path
Example 16
def wheel_libs(wheel_fname, filt_func=None): """ Rückgabeanalyse von Bibliotheksabhängigkeiten mit einem Python-Wheel Verwenden Sie diese Routine für einen Dump des Abhängigkeitsbaums. Parameter ---------- wheel_fname: str Dateiname des Rads filt_func: Keiner oder aufrufbar, optional Wenn keiner, alle Dateien auf Bibliotheksabhängigkeiten untersuchen. Wenn aufrufbar, akzeptiert Dateiname als Argument, gibt True zurück, wenn wir die Datei untersuchen sollen, andernfalls False. Rückgabe ------- lib_dict: Diktatwörterbuch mit (Schlüssel, Wert) Paaren von (``libpath``, ``dependings_dict``). ``libpath`` ist die Bibliothek, von der abhängig ist, relativ zum Wurzelpfad des Rads, falls innerhalb des Radbaums. ``dependings_dict`` ist (Schlüssel, Wert) von (``depending_lib_path``, ``install_name``). Auch hier ist „depending_lib_path“ eine Bibliothek relativ zum Wurzelpfad des Rads, falls innerhalb des Radbaums. """ mit 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)
Beispiel 17
def main(): parser = OptionParser( usage="%s WHEEL_OR_PATH_TO_ANALYZE " % sys.argv[0] + __doc__, version="%prog " + __version__) parser.add_options([ Option("-a", "--all", action="store_true", help="Alle Abhängigkeiten anzeigen , einschließlich Systembibliotheken"), Option("-d", "--depending", action="store_true", help="Bibliotheken abhängig von Abhängigkeiten anzeigen")]) (opts, paths) = parser.parse_args() if len(Pfade) < 1: parser.print_help() sys.exit(1) multi = len(Pfade) > 1 für Pfade in Pfaden: if multi: print(path + `:`) indent = ` ` else: indent = `` if isdir(path): lib_dict = tree_libs(path) lib_dict = stripped_lib_dict(lib_dict, realpath (getcwd()) + psep) e lse: lib_dict = wheel_libs(path) keys = sorted(lib_dict) if not opts.all: keys = [key for key in keys if filter_system_libs(key)] if not opts.depending: if len(keys): print(indent + (` ` + indent).join(keys)) Continue i2 = indent + ` ` for key in keys: print(indent + key + `:`) libs = lib_dict[key] if len(libs): print(i2 + (` ` + i2).join(libs)) Beispiel 18
def test_given_directory(): # Teste InGivenDirectory cwd = getcwd() mit InGivenDirectory() als tmpdir: assert_equal( tmpdir, abspath(cwd)) assert_equal(tmpdir, abspath(getcwd())) mit InGivenDirectory(MY_DIR) als tmpdir: assert_equal(tmpdir, MY_DIR) assert_equal(realpath(MY_DIR), realpath(abspath (getcwd()))) # Wir haben das gegebene Verzeichnis gelöscht! Überprüfen Sie nicht so jetzt. assert_true(isfile(MY_PATH))
Beispiel 19
def believeClean(workDir, architecture, aggressiveCleanup): """ Entscheidet, was gelöscht werden soll, ohne es tatsächlich zu tun: - Finden Sie alle Symlinks in „BUILD“ – Finde alle Verzeichnisse in „BUILD“ – Plane ein Verzeichnis zum Löschen, wenn es keinen Symlink „““ hat symlinksBuild = [os.readlink(x) for x in glob.glob(“%s/ BUILD/*-latest*" % workDir)] # $WORK_DIR/TMP sollte immer bereinigt werden. Dies passiert nicht nur # wenn uns beim Entpacken der Platz ausgeht. # $WORK_DIR//store kann ebenfalls bereinigt werden, da # wir die eigentlichen Tarballs nicht benötigen, nachdem sie erstellt wurden. toDelete = ["%s/TMP" % workDir] if aggressiveCleanup: toDelete += ["%s/TARS/%s/store" % (workDir, architecture), "%s/SOURCES" % (workDir)] allBuildStuff = glob.glob("%s/BUILD/*" % workDir) toDelete += [x für x in allBuildStuff if not path.islink(x) and not basename(x) in symlinksBuild] installGlob ="%s/%s/ */" % (workDir, architecture) installedPackages = set([dirname(x) for x in glob.glob(installGlob)]) symlinksInstall = [] for x in installedPackages: symlinksInstall += [path.realpath(y) for y in glob.glob(x + "/latest*")] toDelete += [x for x in glob.glob(installGlob+ "*") wenn nicht path.islink(x) und nicht path.realpath(x) in symlinksInstall] toDelete = [x für x in toDelete if path.exists(x)] return toDelete
Beispiel 20
def _get_script_dir(follow_symlinks: bool = True ) -> Pfad: # Es ist schwierig, den Pfad zu den Vertrauensspeichern zu ermitteln aufgrund geringfügiger Unterschiede unter OS X, Linux und 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
Archiv
os.path.realpath() wird in Python verwendet, um den kanonischen Pfad eines angegebenen Dateinamens zu erhalten, indem alle im Pfad gefundenen symbolischen Links entfernt werden.
Syntax: os.path.realpath (path)
Parameter:
path : A pfadähnliches Objekt, das den Dateisystempfad darstellt.
Ein pfadähnliches Objekt ist entweder ein String - oder ein Byte -Objekt, das einen Pfad darstellt.Rückgabetyp: Diese Methode gibt einen Zeichenfolgenwert zurück, der den kanonischen Pfad darstellt.
Softlink oder symbolischen Link erstellen
Unter Unix oder Linux kann ein Softlink oder symbolischer Link mit dem ln-Befehl erstellt werden. Folgend ist die Syntax zum Erstellen eines symbolischen Links auf der Befehlszeile:
$ ln -s {Name der Quelldatei} {Name der symbolischen Datei} Beispiel:
Beispiel:
In der obigen Ausgabe " / home / ihritik / Desktop / file (shortcut) .txt " ist ein symbolischer Link.
Code: unter Verwendung von os.path.realpath () Methode, um symbolische Links mit kanonischem Pfad und Auflösung zu erhalten.
|                                 |
Beenden:
/ home / ihritik / Documents / file (original) .txt /GeeksForGeeks/sample.py /home/ihritik/file.txt /home/ihritik/Downloads /file.txt