Sintaxis: os.path.realpath(ruta) Parámetro: ruta: similar a una ruta objeto que representa la ruta del sistema de archivos. Un objeto similar a una ruta es una cadena o un objeto de bytes que representa una ruta. Tipo de devolución: este método devuelve un valor de cadena que representa la ruta canónica.
Crear enlace suave o enlace simbólico
En Unix o Linux, se puede crear un enlace suave o enlace simbólico usando el comando ln. La siguiente es la sintaxis para crear un enlace simbólico en la línea de comando:$ ln -s {nombre de archivo fuente} {nombre de archivo simbólico} Ejemplo 1
def realpath(self, spec, key): """ Resuelva y actualice la clave de ruta en la especificación con su realpath, según el directorio de trabajo. """ si la clave no está en las especificaciones: # no hacer nada por ahora regrese si no especifica [clave]: logger.warning( "no se puede resolver realpath de `%s ` ya que no está definido", clave) return check = realpath(join(spec.get( WORKING_DIR, ``), especificación[clave])) si marca != especificación[clave]: especificación[clave] = verificar registrador.advertencia( "realpath de `%s` resuelto a `%s`, se actualizan las especificaciones", clave, verificar) devuelve che ck # Configuración de métodos relacionados
Ejemplo 2
def get_rp_stripper(strip_path): """ Función de retorno para eliminar ``realpath`` de `strip_path` de los parámetros de cadena ---------- strip_path: str ruta para quitar desde el principio de las cadenas. Procesado a ``strip_prefix`` por ``realpath(strip_path) + os.path.sep` `. Devuelve ------- stripper: func función tal que ``stripper(a_string)`` quitará ``strip_prefix`` de ``a_string`` si está presente, de lo contrario pasará ``a_string`` sin modificar """ return get_prefix_stripper(realpath(strip_path) + os.path.sep)
Ejemplo 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) # Verifique que build_dir esté establecido en la especificación basada en el archivo temporal self.assertTrue(spec[`build_dir`].startswith( realpath(tempfile.gettempdir()))) # También que se eliminó correctamente. self.assertFalse(exists(spec[`build_dir`] ))
Ejemplo 4
def find_system_jdks(): """ Devuelve un conjunto de JD válidos K directorios buscando ubicaciones estándar. """ bases = [ `/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 si es_valid_jdk(jdk): jdks.add(realpath(jdk)) return jdks
Ejemplo 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): # Saltar nombres de directorio que comiencen con `.` if _to_skip(file_or_dir): continue # Visite recursivamente los directorios y agregue los archivos. ) 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) devolver archivos
Ejemplo 6
def getSubdirs(ruta, baseNamesOnly=True, excludePythonModulesDirs=True): """Proporciona una lista de subdirectorios para la ruta dada"" " subdirs = [] try: ruta = realpath(ruta) + sep para elemento en os.listdir (ruta): candidato = ruta + elemento si esdir(candidato): si excluirPythonModulesDirs: modFile = candidato + sep + "__init__.py" si existe(modFile): continuar si baseNamesOnly: subdirs.append(elemento) else: subdirs.append (candidato) excepto: pasar subdirectorios de retorno
Ejemplo 7
def get_dataset(num_points): nombre = `ModelNet10` ruta = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `datos`, nombre) pre_transform = T.NormalizeScale() transform = T.SamplePoints(num_points) train_dataset = ModelNet( ruta, nombre=`10`, train=True, transform=transform, pre_transform=pre_transform) test_dataset = ModelNet( ruta, nombre=`10`, train=False, transform=transform, pre_transform=pre_transform) return train_dataset, test_dataset
Ejemplo 8
def getParameters(self): """Proporciona un diccionario con los parámetros de búsqueda""" parámetros = {`term`: self.findCombo.currentText(), `case`: self.caseCheckBox.isChecked( ), `todo`: self.wordCheckBox.isChecked(), `regexp`: self.regexpCheckBox.isChecked()} if self.projectRButton.isChecked(): parámetros[`en-proyecto`] = Parámetros verdaderos[`en- abierto`] = Falso parámetros[`en-dir`] = `` elif self.openFilesRButton.isChecked(): parámetros[`en-proyecto`] = F alse parámetros[`en-abierto`] = Parámetros verdaderos[`en-dir`] = `` else: parámetros[`en-proyecto`] = Falso parámetros[`en-abierto`] = Parámetros falsos[`en-dir `] = realpath( self.dirEditCombo.currentText().strip()) parámetros[`archivo -filter`] = self.filterCombo.currentText().strip() devolver parámetros Ejemplo 9
def _check_if_pyc(fname): """Return True si la extensión es . pyc, Falso si .py y Ninguno si es lo contrario""" from imp import find_module from os.path import realpath, dirname, basename, splitext # Normalizar la ruta del archivo para find_module() ruta del archivo = realpath(fname) dirpath = dirname(filepath) module_name = splitext(basename(filepath))[0] # Validate and fetch try: fileobj, fullpath, (_, _, pytype) = find_module(module_name, [dirpath]) excepto ImportError : raise IOError("No se puede encontrar el archivo de configuración. " "La ruta puede ser incorrecta: {0}".format(filepath)) return pytype, fileobj, fullpath
Ejemplo 10
def get_planetoid_dataset(name, normalize_features=False, transform= Ninguno): ruta = osp.join(osp.dirname(osp.realpath(__file__)), `..`, `datos`, nombre) dataset = Planetoid(ruta, nombre) si transform no es None y normalize_features: dataset.transform = T.Compose([T.NormalizeFeatures(), transform]) elif normalize_features: dataset. transform = T.NormalizeFeatures() elif transform no es Ninguno: dataset.transform = transform return dataset
Ejemplo 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) si log_file: file_handler = logging.FileHandler(realpath(log_file), mode="w" ) file_handler.setFormatter(formatter) logger.addHandler(file_handler) return logger
Ejemplo 12
def bro_server(bro_file, interface="eth0", bro_path="/usr/local/ bro/bin/bro"): u""" 跑bro服务进程 """ # 获取绝对路径 bro_file = ruta.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 {interfaz} {bro_scripts}" cmd = cmd.format(bro_path=bro_path, interface=interface, bro_scripts=bro_scripts) msg = "el cmd es: %s" % cmd logging.info(msg) # cambiar pwd a /tmp tmp_dir = path.join(path.dirname(path.rutareal(__archivo__)), `../../tmp/`) chdir(tmp_dir) resultado = r un(cmd) logging.info(result.__dict__)
Ejemplo 13
def ProcessFlags(env, flags): for f in flags: if f: env.MergeFlags(str( f)) # arreglar el CPPPATH relativo para i, p en enumerate(env.get("CPPPATH", [])): if isdir(p): env[`CPPPATH`][i] = realpath(p) # Cancelar cualquier definición anterior de nombre, ya sea integrada o # provista con una opción -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)) Ejemplo 14
def _get_settings_helper(self): main_dir = ruta.dirname(ruta.realpath(__file__)) main_dir = ruta.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 # abrir el archivo predeterminado y obtener información de la versión con open(default_filepath) como default_filestream : default_filesettings = yaml.load(default_filestream) # FIXME: no se usa 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)
Ejemplo 15
def resolve_rpath(lib_path, rpaths ): """ Devuelve `lib_path` con su `@rpath` resuelto. Si `lib_path` no tiene `@rpath`, se devuelve tal cual. Si `lib_path` tiene `@rpath`, devuelve la primera combinación encontrada de `rpaths`/`lib_path`. Si no se puede encontrar la biblioteca en `rpaths`, se imprime una advertencia detallada y se devuelve `lib_path` tal como está. Parámetros ---------- lib_path: str La ruta a un archivo de biblioteca, que puede o no comenzar con `@rpath`. rpaths: secuencia de str Una secuencia de rutas de búsqueda, generalmente obtenida de una llamada a `get_rpaths`. Devuelve ------- lib_path: str Una cadena con las bibliotecas resueltas realpath. """ si no es lib_path.startswith(`@rpath/`): devuelve lib_path lib_rpath = lib_path.split(`/`, 1)[1] para rpath en rpaths: rpath_lib = realpath(pjoin(rpath, lib_rpath)) if os.path.exists(rpath_lib): return rpath_lib advertencias.warn( "No se pudo encontrar { 0} en las rutas: {1}".format( lib_path, ` `.join(realpath( path) for path in rpaths), ) ) return lib_path
Ejemplo 16
def wheel_libs(wheel_fname, filt_func=None): """ Devuelve el análisis de las dependencias de la biblioteca con una rueda de Python Utilice esta rutina para un volcado del árbol de dependencia. Parámetros ---------- wheel_fname: str Nombre de archivo de la rueda filt_func: Ninguno o invocable, opcional Si no hay ninguno, inspeccione todos los archivos en busca de dependencias de la biblioteca. Si se puede llamar, acepta el nombre del archivo como argumento, devuelve True si debemos inspeccionar el archivo, False en caso contrario. Devuelve ------- lib_dict: diccionario dict con (clave, valor) pares de (``libpath``, ``dependings_dict``). ``libpath`` es una biblioteca de la que se depende, en relación con la ruta raíz de la rueda si está dentro del árbol de la rueda. ``dependings_dict`` es (clave, valor) de (``depending_lib_path``, ``install_name``). Nuevamente, ``depending_lib_path`` es una biblioteca relativa a la ruta raíz de la rueda, si está dentro del árbol de la rueda. """ con TemporaryDirectory() como tmpdir: zip2dir(wheel_fname, tmpdir) lib_dict = tree_libs(tmpdir, filt_func) return stripped_lib_dict(lib_dict, realpath(tmpdir) + os.path.sep)
Ejemplo 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="Mostrar todas las dependencias , incluidas las bibliotecas del sistema"), Option("-d", "--depending", action="store_true", help="Mostrar bibliotecas dependiendo de las dependencias")]) (opts, rutas) = parser.parse_args() if len(rutas) < 1: parser.print_help() sys.exit(1) multi = len(rutas) > 1 for ruta en rutas: if multi: print(ruta + `:`) sangría = ` ` else: sangría = `` if isdir(ruta): lib_dict = tree_libs(ruta) 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 + (` ` + sangría).join(keys)) continuar i2 = sangría + ` ` for key in keys: print(indent + key + `:`) libs = lib_dict[key] if len(libs): print(i2 + (` ` + i2).join(libs)) Ejemplo 18
def test_given_directory(): # Probar InGivenDirectory cwd = getcwd() con InGivenDirectory() como tmpdir: assert_equal( tmpdir, abspath(cwd)) afirmar_equal(tmpdir, abspath(getcwd())) con InGivenDirectory(MI_DIR) como tmpdir: afirmar_igual(tmpdir, MI_DIR) afirmar_igual(realpath(MY_DIR), realpath(abspath (getcwd()))) # ¡Estábamos eliminando el directorio Dado! Compruebe que no es así ahora. assert_true(isfile(MY_PATH))
Ejemplo 19
def decideClean(workDir, architecture, agresivaCleanup): """ Decide qué eliminar, sin hacerlo realmente: - Encuentra todos los enlaces simbólicos en "BUILD" - Encuentra todos los directorios en "BUILD" - Programa la eliminación de un directorio si no tiene un enlace simbólico """ symlinksBuild = [os.readlink(x) for x in glob.glob("%s/ BUILD/*-latest*" % workDir)] # $WORK_DIR/TMP siempre debe limpiarse. Esto no sucede solo # en el caso de que nos quedemos sin espacio mientras desempacamos. # $WORK_DIR//store también se puede limpiar, porque # no necesitamos los tarballs reales después de que se hayan construido. toDelete = ["%s/TMP" % workDir] if agresiveCleanup: toDelete += ["%s/TARS/%s/store" % (workDir, arquitectura), "%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, arquitectura) paquetes instalados = set ([dirname (x) para x en glob.glob (installGlob)]) symlinksInstall = [] para x en paquetes instalados: symlinksInstall += [ruta.realpath(y) for y in glob.glob(x + "/latest*")] toDelete += [x for x en glob.glob(installGlob+ "*") si no es path.islink(x) y no es path.realpath(x) en symlinksInstall] toDelete = [x for x in toDelete if path.exists(x)] return toDelete Ejemplo 20
def _get_script_dir(follow_symlinks: bool = True ) -> Ruta: # Obtener la ruta a las tiendas de confianza es complicado debido a sutiles diferencias en OS X, Linux y Windows if getattr(sys, "frozen", False): # py2exe, PyInstaller, cx_Freeze ruta = Ruta(sys.executable).absolute() else: ruta = Ruta(inspeccionar.getabsfile (_get_script_dir)) if follow_symlinks: path = Path(realpath(path)) return path.parent
Archivo
os.path.realpath() en Python se usa para obtener la ruta canónica de un nombre de archivo específico eliminando cualquier enlace simbólico que se encuentre en la ruta.
Sintaxis: os.path.realpath (ruta)
Parámetro:
ruta : A objeto similar a una ruta que representa la ruta del sistema de archivos.
Un objeto similar a una ruta es un objeto cadena o bytes que representa una ruta.Tipo de devolución: Este método devuelve un valor de cadena que representa la ruta canónica.
Crear enlace suave o enlace simbólico
En Unix o Linux, se puede crear un enlace suave o enlace simbólico usando el comando ln.¬†Siguiente es la sintaxis para crear un enlace simbólico en la línea de comando:
$ ln -s {nombre-archivo-fuente} {nombre-archivo-simbólico} Ejemplo:
Ejemplo:
En el resultado anterior, " / home / ihritik / Escritorio / archivo (acceso directo) .txt " es un enlace simbólico.
Código: usando os.path.realpath () método para obtener la ruta canónica y los enlaces simbólicos de resolución.
| ¬† ¬† ¬† ¬† ¬† ¬† < clase de código = "simple"> ruta ¬† ¬† ¬† ¬† ¬† ¬† ¬† ¬† ¬† ¬† |
Salir:
/ home / ihritik / Documentos / archivo (original) .txt /GeeksForGeeks/sample.py /home/ihritik/file.txt /home/ihritik/Downloads /file.txt