Składnia: os.path.realpath(ścieżka) Parametr: ścieżka: podobna do ścieżki obiekt reprezentujący ścieżkę systemu plików. Obiekt podobny do ścieżki to ciąg znaków lub obiekt bajtów reprezentujący ścieżkę. Typ zwrotu: Ta metoda zwraca wartość ciągu, która reprezentuje ścieżkę kanoniczną.
Utwórz dowiązanie miękkie lub dowiązanie symboliczne
W systemach Unix lub Linux dowiązanie miękkie lub dowiązanie symboliczne można utworzyć za pomocą polecenia ln. Poniżej znajduje się składnia tworzenia dowiązania symbolicznego w wierszu poleceń:$ ln -s {nazwa-pliku-źródłowego} {nazwa-pliku-symbolicznego} Przykład 1
def realpath(self, spec, key): """ Rozwiąż i zaktualizuj klucz ścieżki w specyfikacji za pomocą jego realpath, na podstawie katalogu roboczego. """ jeśli klucz nie jest w specyfikacji: # nic nie rób dla teraz zwróć, jeśli nie spec[key]: logger.warning( "nie można rozwiązać ścieżka rzeczywista z `%s ` ponieważ nie jest zdefiniowany", klucz) return check = realpath(join(spec.get( WORKING_DIR, ``), spec[key])) if check != spec[key]: spec[key] = check logger.warning( "ścieżka rzeczywista `%s` rozwiązana na `%s`, specyfikacja jest zaktualizowana", klucz, sprawdź ) return che ck # Konfiguracja powiązanych metod
Przykład 2
def get_rp_stripper(strip_path): """ Funkcja powrotu do paska ``realpath`` z „strip_path” z ciągu Parametry ---------- strip_path: ciąg ścieżka do paska od początku ciągów. Przetworzony do „strip_prefix” przez „realpath(strip_path) + os.path.sep” „. Zwraca ------- stripper: funkcja func taka, że ``stripper(a_string)`` ściągnie ``strip_prefix`` z ``a_string``, jeśli jest obecny, w przeciwnym razie przekaże ``a_string`` niezmodyfikowane """ return get_prefix_stripper(realpath(strip_path) + os.path.sep)
Przykład 3
def test_toolchain_standard_not_implemented(self): spec = Spec() z self.assertRaises(NotImplementedError): self.toolchain(spec) z self.assertRaises(NotImplementedError): self.toolchain.assemble(spec) z self.assertRaises(NotImplementedError): self.toolchain.link(spec) # Sprawdź, czy katalog_kompilacji jest ustawiony na specyfikację na podstawie pliku tymczasowego self.assertTrue(spec[`build_dir`].startswith( realpath(tempfile.gettempdir()))) # Ponadto został usunięty poprawnie.self.assertFalse(exists(spec[`build_dir`]) ))
Przykład 4
def find_system_jdks(): """ Zwraca zestaw poprawnych JD Katalogi K, przeszukując standardowe lokalizacje. """ bases = [ `/Library/Java/JavaVirtualMachines`, `/usr/lib/jvm`, `/usr/java`, `/usr/jdk/instances`, r`C:Program FilesJava`] jdks = set() for base w bazach: 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
Przykład 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 op. "https://python.engineering/python-os-path-realpath-method/">realpath(file_or_dir) if op.isdir(file_or_dir): # Pomiń nazwy katalogów zaczynające się od `.` if _to_skip(file_or_dir): continue # Rekursywnie odwiedź katalogi i dodaj pliki.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(plik_lub_katalog, plik) dla pliku w os.listdir(plik_lub_katalog)]) elif `*` w plik_lub_katalog: files.extend(glob.glob(plik_lub_katalog)) else: files.append (file_or_dir) zwracają pliki
Przykład 6
def getSubdirs(path, baseNamesOnly=True, excludePythonModulesDirs=True): """Zawiera listę podkatalogów dla podanej ścieżki"" " subdirs = [] try: path = realpath(ścieżka) + sep dla elementu w os.listdir (ścieżka): kandydat = ścieżka + element if isdir (kandydat): if excludePythonModulesDirs: modFile = kandydat + sep + "__init__.py" if existing(modFile): kontynuuj, jeśli baseNamesOnly: subdirs.append(item) else: subdirs.append (kandydat) z wyjątkiem: przekaż powrotne podkatalogi
Przykład 7
def get_dataset(num_points): name = ścieżka „ModelNet10” = osp.join(osp.dirname(osp.ścieżka rzeczywista(__file__)), `..`, `dane`, nazwa) pre_transform = T.NormalizeScale() transform = T.SamplePoints(num_points) train_dataset = ModelNet(ścieżka, nazwa=`10`, train=True, transform=transform, pre_transform=pre_transform) test_dataset = ModelNet(ścieżka, nazwa=`10`, train=False, transform=transform, pre_transform=pre_transform) return train_dataset, test_dataset
Przykład 8
def getParameters(self): """Dostarcza słownik z parametrami wyszukiwania""" Parametry = {`term`: self.findCombo.currentText(), `case`: self.caseCheckBox.isChecked( ), `whole`: self.wordCheckBox.isChecked(), `regexp`: self.regexpCheckBox.isChecked()} jeśli self.projectRButton.isChecked(): parametry[`in-project`] = True parameters[`in- open`] = Fałszywe parametry[`in-dir`] = `` elif self.openFilesRButton.isChecked(): parametry[`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()) parametry [`plik -filter`] = self.filterCombo.currentText().strip() zwraca parametry Przykład 9
def _check_if_pyc(fname): """Zwróć wartość True, jeśli rozszerzenie to . pyc, False, jeśli .py i None, jeśli inaczej """ z imp import find_module z os.path import realpath, dirname, basename, splitext # Normalizuj ścieżkę do pliku find_module() filepath = realpath(fname) dirpath = dirname(filepath) module_name = splitext(basename(filepath))[0] # Sprawdź poprawność i pobierz próbę: fileobj, fullpath, (_, _, pytype) = find_module(nazwa_modułu, [dirpath]) z wyjątkiem ImportError : raise IOError("Nie można znaleźć pliku konfiguracyjnego. " "Ścieżka może być nieprawidłowa!: {0}".format(ścieżka pliku)) return pytype, fileobj, fullpath
Przykład 10
def get_planetoid_dataset(name, normalize_features=False, transform= Brak): ścieżka = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, nazwa) dataset = Planetoid(ścieżka, nazwa) jeśli transform to nie None i normalize_features: dataset.transform = T.Compose([T.NormalizeFeatures(), transform]) elif normalize_features: dataset. transform = T.NormalizeFeatures() elif transform is not None: dataset.transform = transformacja zwraca zbiór danych
Przykład 11
def _setup_logger(cls, log_file=None): formatter = logowanie. 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
Przykład 12
def bro_server(bro_file, interface="eth0", bro_path="/usr/local/ bro/bin/bro"): u""" Ë∑ëbroÊúçÂä°ËøõÁ®ã """ # Ëé∑ÂèñÁªùÂØπË∑ØÂæÑ bro_file = ścieżka.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 = "polecenie to: %s" % cmd logging.info(msg) # zmień pwd na /tmp tmp_dir = path.join(path.dirname(path.ścieżka rzeczywista(__file__)), `../../tmp/`) chdir(tmp_dir) wynik = r un(cmd) logging.info(result.__dict__)
Przykład 13
def ProcessFlags(env, flags): for f in flags: if f: env.MergeFlags(str( f)) # napraw względną wartość CPPPATH dla i, p in enumerate(env.get("CPPPATH", [])): if isdir(p): env[`CPPPATH`][i] = realpath(p) # Anuluj poprzednią definicję nazwy, wbudowaną lub # z opcją -D // Problem #191 undefines = [u for u in env.get("CCFLAGS", []) if u.startswith("-U")] if undefines: for undef w undefines: env[`CCFLAGS`].remove(undef) env. Append(_CPPDEFFLAGS=" %s" % " ".join(undefines)) Przykład 14
def _get_settings_helper(self): main_dir = path.dirname(path.realpath(__file__)) main_dir = ścieżka.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 # otwórz domyślny plik i uzyskaj informacje o wersji za pomocą open(default_filepath) jako default_filestream : default_filesettings = yaml.load(default_filestream) # FIXME: nieużywane bieżąca_wersja = default_filesettings[`wersja`].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)
Przykład 15
def resolve_rpath(lib_path, rpaths ): """ Zwróć `lib_path` z rozwiązanym `@rpath` Jeśli `lib_path` nie ma `@rpath`, to jest zwracana bez zmian. Jeśli „lib_path” ma „@rpath”, zwraca pierwszą znalezioną kombinację „rpaths”/„lib_path”. Jeśli biblioteki nie można znaleźć w `rpaths`, wyświetlane jest szczegółowe ostrzeżenie i zwracana jest `lib_path` bez zmian. Parametry ---------- lib_path: str Ścieżka do pliku biblioteki, która może, ale nie musi zaczynać się od `@rpath`. rpaths: sekwencja str Sekwencja ścieżek wyszukiwania, zwykle uzyskiwana z wywołania funkcji `get_rpaths`. Zwraca ------- lib_path: str A str z rozwiązanymi bibliotekami realpath. """ jeśli nie lib_path.startswith(`@rpath/`): zwróć lib_path lib_rpath = lib_path.split(`/`, 1) [1] dla rpath w rpaths: rpath_lib = realpath(pjoin(rpath, lib_rpath)) jeśli os.path.exists(rpath_lib): return rpath_lib warnings.warn( "Nie można znaleźć { 0} na ścieżkach: {1}.format( lib_path, ` `.join(realpath( path) dla ścieżki w ścieżkach rpath), ) ) return lib_path
Przykład 16
def wheel_libs(wheel_fname, filt_func=None): """ Zwróć analizę zależności bibliotek za pomocą koła Pythona Użyj tej procedury do zrzutu drzewa zależności. Parametry ---------- wheel_fname: str Nazwa pliku wheel filt_func: Brak lub wywoływalny, opcjonalny Jeśli Brak, sprawdza wszystkie pliki pod kątem zależności bibliotecznych. Jeśli można go wywoływać, akceptuje nazwę pliku jako argument, zwraca True, jeśli powinniśmy sprawdzić plik, w przeciwnym razie False. Zwraca ------- lib_dict: słownik dict z parami (klucz, wartość) (``libpath``, ``dependings_dict``). ``libpath`` to biblioteka, na której jest zależna, w stosunku do ścieżki głównej koła, jeśli znajduje się w drzewie koła. ``dependings_dict`` to (klucz, wartość) z (``depending_lib_path``, ``install_name``). Ponownie, „depending_lib_path” jest biblioteką odnoszącą się do ścieżki głównej koła, jeśli znajduje się w drzewie koła. „”” z TemporaryDirectory() jako tmpdir: zip2dir(wheel_fname, tmpdir) lib_dict = tree_libs(tmpdir, filt_func) return stripped_lib_dict(lib_dict, ścieżka rzeczywista(tmpdir) + os.path.sep)
Przykład 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="Pokaż wszystkie zależności , w tym biblioteki systemowe"), Option("-d", "--depending", action="store_true", help="Pokaż biblioteki w zależności od zależności")]) (opts, paths) = parser.parse_args() if len(paths) < 1: parser.print_help() sys.exit(1) multi = len(paths) > 1 dla ścieżki w ścieżkach: if multi: print(path + `:`) indent = ` ` else: wcięcie = `` if isdir (ścieżka): lib_dict = tree_libs (ścieżka) lib_dict = stripped_lib_dict(lib_dict, realpath (getcwd()) + psep) e lse: lib_dict = wheel_libs(ścieżka) keys = sorted(lib_dict) jeśli nie opts.all: keys = [klucz do klucza w kluczach jeśli filter_system_libs(klucz)] jeśli nie opts.depending: if len(keys): print(indent + (` ` + wcięcie).join(keys)) continue i2 = wcięcie + ` ` dla klucza w kluczach: print(wcięcie + klucz + `:`) libs = lib_dict[klucz] if len(libs): print(i2 + (` ` + i2).join(libs)) Przykład 18
def test_given_directory(): # Testuj InGivenDirectory cwd = getcwd() z InGivenDirectory() jako tmpdir: attach_equal( tmpdir, abspath(cwd)) attach_equal(tmpdir, abspath(getcwd())) z InGivenDirectory(MY_DIR) jako tmpdir:asser_equal(tmpdir, MY_DIR)asser_equal(realpath(MY_DIR), realpath(abspath (getcwd()))) # Usuwaliśmy podany katalog! Sprawdź nie tak teraz. attach_true(isfile(MY_PATH))
Przykład 19
defdecyClean(workDir, architecture, assistantCleanup): """ Decyduje, co usunąć, nie robiąc tego: - Znajdź wszystkie dowiązania symboliczne w "BUILD" - Znajdź wszystkie katalogi w "BUILD" - Zaplanuj usunięcie katalogu, jeśli nie ma dowiązania symbolicznego """ symlinksBuild = [os.readlink(x) for x in glob.glob("%s/ BUILD/*-latest*" % workDir)] # $WORK_DIR/TMP należy zawsze wyczyścić. Nie dzieje się tak tylko # w przypadku, gdy podczas rozpakowywania zabraknie nam miejsca. # $WORK_DIR//store również można wyczyścić, ponieważ # nie potrzebujemy rzeczywistych tarballi po ich zbudowaniu. toDelete = ["%s/TMP" %katalogroboczy] if dangerousCleanup: toDelete += ["%s/TARS/%s/store" % (katalog roboczy, architektura), "%s/SOURCES" % (katalog roboczy)] allBuildStuff = glob.glob("%s/BUILD/*" % WorkDir) toDelete += [x for x in allBuildStuff jeśli nie path.islink(x) i not basename(x) in symlinksBuild] installGlob ="%s/%s/ */" % (katalog roboczy, architektura) installedPackages = set([dirname(x) for x in glob.glob(installGlob)]) symlinksInstall = [] for x in installedPackages: symlinksInstall += [ścieżka.realpath(y) dla y w glob.glob(x + "/latest*")] toDelete += [x for x w glob.glob(installGlob+ "*"), jeśli nie path.islink(x), a nie path.realpath(x) in symlinksInstall] toDelete = [x for x in toDelete if path.exists(x)] return toDelete Przykład 20
def _get_script_dir(follow_symlinks: bool = True ) -> Ścieżka: # Uzyskanie ścieżki do sklepów zaufania jest trudne ze względu na subtelne różnice w systemach OS X, Linux i 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
Archiwum
os.path.realpath() w Pythonie służy do uzyskania kanonicznej ścieżki określonej nazwy pliku poprzez usunięcie wszelkich dowiązań symbolicznych znalezionych w ścieżce .
Składnia: os.path.realpath (ścieżka)
Parametr:
ścieżka : A obiekt podobny do ścieżki reprezentujący ścieżkę systemu plików.
Obiekt podobny do ścieżki to albo ciąg albo bytes obiekt reprezentujący ścieżkę.Typ zwrotu: Ta metoda zwraca wartość ciągu, która reprezentuje ścieżkę kanoniczną.
Utwórz dowiązanie miękkie lub symboliczne
W systemach Unix lub Linux dowiązanie miękkie lub symboliczne można utworzyć za pomocą polecenia ln. jest składnią tworzenia dowiązania symbolicznego w wierszu poleceń:
$ ln -s {nazwa-pliku-źródłowego} {nazwa-pliku-symbolicznego} Przykład:
Przykład:
W powyższym wyniku " / home / ihritik / Desktop / file (skrót) .txt " to dowiązanie symboliczne.
Kod: przy użyciu os.path.realpath () metoda uzyskiwania kanonicznej ścieżki i dowiązań symbolicznych rozdzielczości.
|                                 |
Wyjście:
/ home / ihritik / Dokumenty / plik (oryginalny) .txt /GeeksForGeeks/sample.py /home/ihritik/file.txt /home/ihritik/Downloads /file.txt