Sintassi: os.path.realpath(percorso) Parametro: percorso: un percorso simile oggetto che rappresenta il percorso del file system. Un oggetto simile a un percorso è un oggetto stringa o byte che rappresenta un percorso. Tipo restituito: questo metodo restituisce un valore stringa che rappresenta il percorso canonico.
Crea un collegamento software o un collegamento simbolico
Su Unix o Linux, è possibile creare un collegamento software o un collegamento simbolico utilizzando il comando ln. Di seguito è riportata la sintassi per creare un collegamento simbolico sulla riga di comando:$ ln -s {nome-file-origine} {nome-file-simbolico} Esempio 1
def realpath(self, spec, key): """ Risolvi e aggiorna la chiave del percorso nella specifica con la sua realpath, basato sulla directory di lavoro. """ se la chiave non è nelle specifiche: # non fare nulla per now return if not spec[key]: logger.warning( "cannot risolvere realpath di `%s ` come non è definito", key) return check = realpath(join(spec.get( DIR_LAVORO, ``), spec[chiave])) if check != spec[key]: spec[key] = check logger.warning( "realpath di `%s` risolto in `%s`, la specifica è stata aggiornata", chiave, controllo ) return che ck # Impostazione dei metodi relativi
Esempio 2
def get_rp_stripper(strip_path): """ Funzione di ritorno allo strip ``realpath`` di `strip_path` dalla stringa Parametri ---------- strip_path: str percorso da rimuovere dall`inizio delle stringhe. Elaborato in ``strip_prefix`` da ``realpath(strip_path) + os.path.sep` `. Restituisce ------- stripper: funzione func tale che ``stripper(a_string)`` elimini ``strip_prefix`` da ``a_string`` se presente, altrimenti passa ``a_string`` non modificata """ return get_prefix_stripper(realpath(strip_path) + os.path.sep)
Esempio 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) # Verifica che build_dir sia impostata sulla specifica in base al file temporaneo self.assertTrue(spec[`build_dir`].startswith( realpath(tempfile.gettempdir()))) # Inoltre è stato eliminato correttamente. self.assertFalse(exists(spec[`build_dir`] ))
Esempio 4
def find_system_jdks(): """ Restituisce un insieme di JD valido directory K ricercando posizioni standard. """ basi = [ `/Library/Java/JavaVirtualMachines`, `/usr/lib/jvm`, `/usr/java`, `/usr/jdk/instances`, r`C:Program FilesJava` ] jdks = set() for 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
Esempio 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): # Salta i nomi che iniziano con `.` if _to_skip(file_or_dir): continua # Visita ricorsivamente le directory e aggiungi i file se ricorsivo: 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) file di ritorno
Esempio 6
def getSubdirs(path, baseNamesOnly=True, excludePythonModulesDirs=True): """Fornisce un elenco di sottodirectory per il percorso specificato"" " subdirs = [] prova: percorso = realpath(percorso) + sep per l`elemento in os.listdir (percorso): candidato = percorso + elemento if isdir(candidate): if excludePythonModulesDirs: modFile = candidato + sep + "__init__.py" se esiste(modFile): continua se baseNamesOnly: subdirs.append(item) else: subdirs.append (candidato) eccetto: pass return subdirs
Esempio 7
def get_dataset(num_points): nome = `ModelNet10` percorso = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, name) pre_transform = T.NormalizeScale() transform = T.SamplePoints(num_points) train_dataset = ModelNet( percorso, nome=`10`, train=True, transform=transform, pre_transform=pre_transform) test_dataset = ModelNet( percorso, nome=`10`, train=False, transform=transform, pre_transform=pre_transform) return train_dataset, test_dataset
Esempio 8
def getParameters(self): """Fornisce un dizionario con i parametri di ricerca""" parametri = {`term`: self.findCombo.currentText(), `case`: self.caseCheckBox.isChecked( ), `intero`: self.wordCheckBox.isChecked(), `regexp`: self.regexpCheckBox.isChecked()} if self.projectRButton.isChecked(): parameters[`in-project`] = True parameters[`in- open`] = parametri falsi[`in-dir`] = `` elif self.openFilesRButton.isChecked(): parametri[`in-project`] = F alse parameters[`in-opened`] = True parameters[`in-dir`] = `` else: parameters[`in-project`] = Falsi parametri[`in-opened`] = Falsi parametri[`in-dir `] = realpath( self.dirEditCombo.currentText().strip()) parametri[`file -filter`] = self.filterCombo.currentText().strip() parametri di ritorno Esempio 9
def _check_if_pyc(fname): """Restituisce True se l`estensione è . pyc, False se .py e Nessuno in caso contrario""" da imp import find_module da os.path import realpath, dirname, basename, splitext # Normalizza il percorso del file per find_module() filepath = realpath(fname) dirpath = dirname(filepath) module_name = splitext(basename(filepath))[0] # Convalida e recupera try: fileobj, fullpath, (_, _, pytype) = find_module(module_name, [dirpath]) eccetto ImportError : raise IOError("Impossibile trovare il file di configurazione. " "Percorso forse errato!: {0}.format(filepath)) return pytype, fileobj, fullpath
Esempio 10
def get_planetoid_dataset(name, normalize_features=False, transform= Nessuno): percorso = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `data`, name) dataset = Planetoid(percorso, nome) se la trasformazione non è None e normalize_features: dataset.transform = T.Compose([T.NormalizeFeatures(), transform]) elif normalize_features: dataset. transform = T.NormalizeFeatures() elif transform non è None: dataset.transform = transform return dataset
Esempio 11
def _setup_logger(cls, log_file=None): formattatore = registrazione. 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 ehm) if log_file: file_handler = logging.FileHandler(realpath(log_file), mode="w" ) file_handler.setFormatter(formatter) logger.addHandler(file_handler) return logger
Esempio 12
def bro_server(bro_file, interface="eth0", bro_path="/usr/local/ bro/bin/bro"): u""" Ë∑ëbroÊúçÂä°ËøõÁ®ã """ # Ëé∑ÂèñÁªùÂØπË∑ØÂæÑ bro_file = percorso.realpath(file_bro) http_file = "/usr/local/bro/share/bro/base/protocols/http/main.bro" bro_scripts = ` `.join([file_bro, 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 = "il cmd è: %s" % cmd logging.info(msg) # cambia pwd in /tmp tmp_dir = path.join(path.dirname(path.percorso reale(__file__)), `../../tmp/`) chdir(tmp_dir) risultato = r un(cmd) logging.info(result.__dict__)
Esempio 13
def ProcessFlags(env, flags): for f in flags: if f: env.MergeFlags(str( f)) # fix relativo CPPPATH per i, p in enumerate(env.get("CPPPATH", [])): if isdir(p): env[`CPPPATH`][i] = realpath(p) # Annulla qualsiasi precedente definizione di nome, sia integrata che # fornita con un`opzione -D // Problema #191 undefines = [u for 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)) Esempio 14
def _get_settings_helper(self): main_dir = percorso.dirname(percorso.realpath(__file__)) main_dir = percorso.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 # apri il file predefinito e ottieni le informazioni sulla versione con open(default_filepath) come default_filestream : default_filesettings = yaml.load(default_filestream) # FIXME: non utilizzato 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)
Esempio 15
def resolve_rpath(lib_path, rpaths ): """ Restituisce `lib_path` con il suo `@rpath` risolto Se `lib_path` non ha `@rpath` allora viene restituito così com`è. Se `lib_path` ha `@rpath` restituisce la prima combinazione `rpaths`/`lib_path` trovata. Se la libreria non può essere trovata in `rpaths`, viene stampato un avviso dettagliato e `lib_path` viene restituito così com`è. Parametri ---------- lib_path: str Il percorso di un file di libreria, che può iniziare o meno con `@rpath`. rpaths: sequenza di str Una sequenza di percorsi di ricerca, generalmente ottenuti da una chiamata a `get_rpaths`. Restituisce ------- lib_path: str A str con le librerie risolte realpath. """ se non lib_path.startswith(`@rpath/`): return lib_path lib_rpath = lib_path.split(`/`, 1)[1] for rpath in rpaths: rpath_lib = realpath(pjoin(rpath, lib_rpath)) if os.path.exists(rpath_lib): return rpath_lib warnings.warn( "Impossibile trovare { 0} sui percorsi: {1}.format( lib_path, ` `.join(realpath( path) per il percorso in rpaths), ) ) return lib_path
Esempio 16
def wheel_libs(wheel_fname, filt_func=None): """ Restituisce l`analisi delle dipendenze della libreria con una ruota Python Utilizzare questa routine per un dump dell`albero delle dipendenze. Parametri ---------- wheel_fname: str Nome file di wheel filt_func: Nessuno o richiamabile, facoltativo Se Nessuno, controlla tutti i file per le dipendenze della libreria. Se richiamabile, accetta il nome del file come argomento, restituisce True se dobbiamo ispezionare il file, False in caso contrario. Restituisce ------- lib_dict: dizionario dict con (chiave, valore) coppie di (``libpath``, ``dependings_dict``). ``libpath`` è la libreria da cui dipende, rispetto al percorso root della ruota se all`interno dell`albero della ruota. ``dependings_dict`` è (chiave, valore) di (``depending_lib_path``, ``install_name``). Di nuovo, ``depending_lib_path`` è una libreria relativa al percorso root della ruota, se all`interno dell`albero della ruota. """ con TemporaryDirectory() come tmpdir: zip2dir(wheel_fname, tmpdir) lib_dict = tree_libs(tmpdir, filt_func) return stripped_lib_dict(lib_dict, realpath(tmpdir) + os.path.sep)
Esempio 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="Mostra tutte le dipendenze , incluse le librerie di sistema"), Option("-d", "--dipendente", action="store_true", help="Mostra le librerie in base alle dipendenze")]) (opts, percorsi) = parser.parse_args() if len(percorsi) < 1: parser.print_help() sys.exit(1) multi = len(percorsi) > 1 per percorso nei percorsi: if multi: print(percorso + `:`) indent = ` ` else: indent = `` if isdir(percorso): lib_dict = tree_libs(percorso) lib_dict = stripped_lib_dict(lib_dict, realpath (getcwd()) + psep) e lse: lib_dict = wheel_libs(percorso) keys = ordinato(lib_dict) se non opts.all: keys = [chiave per la chiave in keys if filter_system_libs(key)] se non 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)) Esempio 18
def test_given_directory(): # Prova InGivenDirectory cwd = getcwd() con InGivenDirectory() come tmpdir: assert_equal( tmpdir, abspath(cwd)) assert_equal(tmpdir, abspath(getcwd())) con InGivenDirectory(MY_DIR) come tmpdir: assert_equal(tmpdir, MY_DIR) assert_equal(realpath(MY_DIR), realpath(abspath (getcwd()))) # Stavamo eliminando la directory Given! Controlla non così ora. assert_true(isfile(MY_PATH))
Esempio 19
def decideClean(workDir, architecture, aggressiveCleanup): """ Decide cosa eliminare, senza farlo effettivamente: - Trova tutti i collegamenti simbolici in "BUILD" - Trova tutte le directory in "BUILD" - Pianifica una directory per l`eliminazione se non ha un collegamento simbolico """ symlinksBuild = [os.readlink(x) for x in glob.glob("%s/ BUILD/*-latest*" % workDir)] # $WORK_DIR/TMP dovrebbe sempre essere ripulito. Ciò non accade solo # nel caso in cui si esaurisca lo spazio durante il disimballaggio. # $WORK_DIR//store può anche essere ripulito, perché # non abbiamo bisogno dei tarball effettivi dopo che sono stati creati. toDelete = ["%s/TMP" % workDir] se aggressivoCleanup: toDelete += ["%s/TARS/%s/store" % (workDir, architettura), "%s/SOURCES" % (workDir)] allBuildStuff = glob.glob("%s/BUILD/*" % workDir) toDelete += [x for x in allBuildStuff if not path.islink(x) and not basename(x) in symlinksBuild] installGlob ="%s/%s/ */" % (workDir, architettura) installedPackages = set([dirname(x) for x in glob.glob(installGlob)]) symlinksInstall = [] for x in installedPackages: symlinksInstall += [percorso.realpath(y) per y in glob.glob(x + "/latest*")] toDelete += [x per x in glob.glob(installGlob+ "*") se non path.islink(x) e non path.realpath(x) in symlinksInstall] toDelete = [x for x in toDelete if path.exists(x)] return toDelete Esempio 20
def _get_script_dir(follow_symlinks: bool = True ) -> Percorso: # Ottenere il percorso per i truststore è complicato a causa di sottili differenze su OS X, Linux e Windows se getattr(sys, "congelato", False): # py2exe, PyInstaller, cx_Freeze path = Path(sys.executable).absolute() else: path = Path(inspect.getabsfile (_get_script_dir)) if follow_symlinks: path = Path(realpath(percorso)) return path.parent
Archivio
os.path.realpath() in Python viene utilizzato per ottenere il percorso canonico di un nome file specificato rimuovendo eventuali collegamenti simbolici trovati nel percorso .
Sintassi: os.path.percorso reale (percorso)
Parametro:
percorso : A oggetto simile a un percorso che rappresenta il percorso del file system.
Un oggetto simile a un percorso è un oggetto stringa o byte che rappresenta un percorso.Tipo restituito: Questo metodo restituisce un valore stringa che rappresenta il percorso canonico.
Crea soft link o link simbolico
Su Unix o Linux, è possibile creare un soft link o un link simbolico usando il comando ln.¬†Seguente è la sintassi per creare un collegamento simbolico sulla riga di comando:
$ ln -s {nome-file-origine} {nome-file-simbolico} Esempio:
Esempio:
Nell`output sopra, " / home / ihritik / Desktop / file (scorciatoia) .txt " è un collegamento simbolico.
Codice: using os.path.realpath () metodo per ottenere i collegamenti simbolici del percorso canonico e della risoluzione.
|                                 |
Esci:
/ home / ihritik / Documenti / file (originale) .txt /GeeksForGeeks/sample.py /home/ihritik/file.txt /home/ihritik/Downloads /file.txt