"os.path" --- Manipulaciones comunes de nombre de ruta
******************************************************

**Código fuente:** Lib/posixpath.py (para POSIX) y Lib/ntpath.py (para
Windows NT).

======================================================================

Este módulo implementa algunas funciones útiles en nombres de ruta.
Para leer o escribir archivos consulta "open()", y para acceder al
sistema de archivos consulta el módulo "os". Los parámetros de ruta
puede ser pasados tanto siendo cadenas o bytes. Se recomienda que las
aplicaciones representen los nombres de archivo como caracteres de
cadena (Unicode). Desafortunadamente, algunos nombres de archivo puede
que no sean representables como cadenas en Unix, así que las
aplicaciones que necesiten tener soporte para nombres de archivo
arbitrarios deberían usar objetos byte para representar nombres de
archivo. Viceversa, el uso de objetos de bytes no puede representar
todos los nombres de archivo en Windows (en la codificación estándar
"mbcs"), por lo tanto, las aplicaciones de Windows deben usar objetos
de cadena para acceder a todos los archivos.

A diferencia de un shell Unix, Python no realiza ninguna expansión de
ruta *automática*. Las funciones como "expanduser()" y "expandvars()"
puede ser invocadas de manera explicita cuando una aplicación desea
realizar una expansión de ruta *shell-like*. (Consulta el módulo
"glob")

Ver también: El módulo "pathlib" ofrece objetos de ruta de alto nivel.

Nota:

  Todas estas funciones aceptan solo bytes o solo objetos de cadena
  como sus parámetros. El resultado es un objeto del mismo tipo, si se
  retorna una ruta o un nombre de archivo.

Nota:

  Dado que los diferentes sistemas operativos tienen diferentes
  convenciones de nombres de ruta, existen varias versiones de este
  módulo en la librería estándar. El módulo "os.path" siempre es el
  módulo adecuado para el sistema operativo en el cual Python está
  operando, y por lo tanto es utilizable para rutas locales. Sin
  embargo, también puedes importar y utilizar los módulos individuales
  si deseas manipular una ruta que *siempre* está en uno de los
  diferentes formatos. Todos tienen la misma interfaz:

  * "posixpath" para rutas con estilo UNIX

  * "ntpath" para rutas Windows

Distinto en la versión 3.8: "exists()", "lexists()", "isdir()",
"isfile()", "islink()", y "ismount()" ahora retornan "False" en lugar
de lanzar una excepción para rutas que contienen caracteres o bytes
que no se puedan representar a nivel de sistema operativo.

os.path.abspath(path)

   Retorna una versión normalizada y absoluta del nombre de ruta
   *path*. En la mayoría de las plataformas esto es el equivalente a
   invocar la función "normpath`de la siguiente manera:
   ``normpath(join(os.getcwd(), path))`()".

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.basename(path)

   Retorna un nombre base de nombre de ruta *path*. Este es el segundo
   elemento del par retornado al pasar *path* a la función "split()".
   Toma en cuenta que el resultado de esta función es diferente a la
   del programa de Unix **basename**; donde **basename** para
   "'/foo/bar/'" retorna "'bar'", la función "basename()" retorna una
   cadena vacía ("''").

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.commonpath(paths)

   Retorna la sub-ruta común más larga de cada nombre de ruta en la
   secuencia *paths*. Lanza una excepción "ValueError" si *paths*
   contiene nombres de ruta absolutos y relativos, o los *paths* están
   en discos diferentes o si *paths* está vacío. A diferencia de
   "commonprefix()", retorna una ruta valida.

   Availability: Unix, Windows.

   Nuevo en la versión 3.5.

   Distinto en la versión 3.6: Acepta una secuencia de *path-like
   objects*.

os.path.commonprefix(list)

   Retorna el prefijo de ruta más largo (tomado carácter por carácter)
   que es un prefijo de todas las rutas en *list*. Si *list* está
   vacía, retorna la cadena vacía ("''").

   Nota:

     Esta función puede que retorne rutas invalidas porque trabaja un
     carácter a la vez. Para obtener una ruta valida, consulta
     "commonpath()".

        >>> os.path.commonprefix(['/usr/lib', '/usr/local/lib'])
        '/usr/l'

        >>> os.path.commonpath(['/usr/lib', '/usr/local/lib'])
        '/usr'

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.dirname(path)

   Retorna el nombre del directorio de la ruta *path*. Es el primer
   elemento del par retornado al pasar *path* a la función "split()".

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.exists(path)

   Retorna "True" si *path* se refiere a una ruta existente o un
   descriptor de archivo abierto. Retorna "False" para enlaces
   simbólicos rotos. En algunas plataformas, esta función puede
   retornar "False" si no se concede permiso para ejecutar "os.stat()"
   en el archivo solicitado, incluso la ruta *path* existe
   físicamente.

   Distinto en la versión 3.3: *path* ahora puede ser un valor entero:
   retorna "True" si es un descriptor de archivo abierto, de otro modo
   retorna "False".

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.lexists(path)

   Retorna "True" si *path* se refiere a un camino existente. Retorna
   "True" para los enlaces simbólicos rotos. Equivalente a "exists()"
   en plataformas que carecen de "os.lstat()".

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.expanduser(path)

   En Unix y Windows, retorna el argumento con un componente inicial
   de "~" o "~user" reemplazado por el directorio *home* de *user*.

   En Unix, el "~" inicial es reemplazado por la variable de entorno
   "HOME" si está activada; si no, el directorio principal del usuario
   actual se busca en el directorio de contraseñas a través del módulo
   incorporado "pwd". Un "~user" inicial es buscado directamente en el
   directorio de contraseñas.

   En Windows, se usará "USERPROFILE" si está configurado, si no, se
   usará una combinación de "HOMEPATH" y "HOMEDRIVE" . Un  *~user`*
   inicial se maneja quitando el último componente del directorio de
   la ruta de usuario creada derivada arriba.

   Si la expansión falla o si la ruta no comienza con una tilde, la
   ruta se retorna sin cambios.

   Distinto en la versión 3.6: Acepta un *path-like object*.

   Distinto en la versión 3.8: Ya no utiliza "HOME" en Windows.

os.path.expandvars(path)

   Retorna el argumento con variables de entorno expandidas. Las sub-
   cadenas de la forma "$name" or "${name}" se reemplazan por el valor
   de la variable de entorno *name*. Los nombres de variables mal
   formadas y las referencias a variables no existentes se dejan sin
   cambios.

   En Windows, las expansiones "%name%" están soportadas además de
   "$name" y "${name}".

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.getatime(path)

   Retorna la hora del último acceso de *path*. El valor de retorno es
   un número de punto flotante que da el número de segundos desde la
   época (Consulta el módulo "time"). Lanza una excepción "OSError" si
   el archivo no existe o es inaccesible.

os.path.getmtime(path)

   Retorna el tiempo de la última modificación de *path*. El valor de
   retorno es un número de punto flotante que da el número de segundos
   desde la época (consulta el módulo "time"). lanza una excepción
   "OSError" si el archivo no existe o es inaccesible.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.getctime(path)

   Retorna el *ctime* del sistema que, en algunos sistemas (como Unix)
   es la hora del último cambio de metadatos y, en otros (como
   Windows), es el tiempo de creación de *path*. El valor retornado es
   un número que da el número de segundos desde la época (consulta el
   módulo "time"). Lanza una excepción "OSError" si el archivo no
   existe o es inaccesible.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.getsize(path)

   Retorna el tamaño en bytes de *path*, Lanza una excepción "OSError"
   si el archivo no existe o es inaccesible.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.isabs(path)

   Retorna "True" si *path* es un nombre de ruta de acceso absoluto.
   En Unix, eso significa que comienza con una barra diagonal, en
   Windows que comienza con una barra diagonal (invertida) después de
   cortar una letra de unidad potencial.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.isfile(path)

   Retorna "True" si *path* es un archivo "existing". Esto sigue los
   enlaces simbólicos, por lo que tanto "islink()" como "isfile()"
   pueden ser verdaderos para la misma ruta.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.isdir(path)

   Retorna "True" si *path* es un directorio "existing". Esto sigue
   los enlaces simbólicos, por lo que tanto "islink()" como "isdir()"
   pueden ser verdaderos para la misma ruta.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.islink(path)

   Retorna  "True" si *path* hace referencia a una entrada de
   directorio "existing" que es un enlace simbólico. Siempre "False"
   si el entorno de ejecución de Python no admite vínculos
   simbólicos..

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.ismount(path)

   Retorna "True" si el nombre de ruta *path* es un *mount point*: un
   punto en un sistema de archivos donde se ha montado un sistema de
   archivos diferente. En POSIX, la función comprueba si el elemento
   primario de *path*, "*path*/..", se encuentra en un dispositivo
   diferente de *path*, o si "*path*/.." y *path* apuntan al mismo
   *i-node* en el mismo dispositivo --- esto debería detectar puntos
   de montaje para todas las variantes Unix y POSIX. No es capaz de
   detectar de forma fiable los montajes de enlace en el mismo sistema
   de archivos. En Windows, una raíz de letra de unidad y un recurso
   compartido UNC siempre son puntos de montaje, y para cualquier otra
   ruta de acceso "GetVolumePathName" se llama para ver si es
   diferente de la ruta de acceso de entrada.

   Nuevo en la versión 3.4: Soporte para detectar puntos de montaje
   *non-root* en Windows.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.join(path, *paths)

   Join one or more path components intelligently.  The return value
   is the concatenation of *path* and any members of **paths* with
   exactly one directory separator following each non-empty part
   except the last, meaning that the result will only end in a
   separator if the last part is empty.  If a component is an absolute
   path, all previous components are thrown away and joining continues
   from the absolute path component.

   En Windows, la letra de la unidad no se restablece cuando se
   encuentra un componente de ruta absoluta (por ejemplo, "r'\foo'").
   Si un componente contiene una letra de unidad, todos los
   componentes anteriores se desechan y la letra de unidad se
   restablece. Ten en cuenta que, dado que hay un directorio actual
   para cada unidad, `` os.path.join ("c:", "foo") `` representa una
   ruta relativa al directorio actual en la unidad "C:" ("c:foo"),, no
   "c:\foo".

   Distinto en la versión 3.6: Acepta un objeto *path-like object*
   para *path* y *paths*.

os.path.normcase(path)

   Normaliza las mayúsculas y minúsculas de un nombre de ruta. En
   Windows convierte todos los caracteres en el nombre de ruta a
   minúsculas y también convierte las barras inclinadas hacia atrás en
   barras inclinadas hacia atrás. En otros sistemas operativos,
   retorna la ruta sin cambios.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.normpath(path)

   Normaliza un nombre de ruta colapsando separadores redundantes y
   referencias de nivel superior para que "A//B", "A/B/", "A/./B" y
   "A/foo/../B" se transformen en``A/B``. Esta modificación de cadena
   puede que modifique el significado de la ruta que contenga enlaces
   simbólicos. En Windows, convierte las barras inclinadas hacia
   adelante en barras hacia atrás. Para normalizar mayúsculas y
   minúsculas, utiliza "normcase()".

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.realpath(path)

   Retorna la ruta canónica del nombre de archivo especificado,
   eliminando cualquier enlace simbólico encontrado en la ruta (si es
   que tienen soporte por el sistema operativo).

   Nota:

     Cuando ocurren ciclos de enlaces simbólicos, la ruta retornada
     será un miembro del ciclo, pero no se garantiza cuál miembro
     será.

   Distinto en la versión 3.6: Acepta un *path-like object*.

   Distinto en la versión 3.8: Los enlaces y uniones simbólicos ahora
   se resuelven en Windows.

os.path.relpath(path, start=os.curdir)

   Return a relative filepath to *path* either from the current
   directory or from an optional *start* directory.  This is a path
   computation:  the filesystem is not accessed to confirm the
   existence or nature of *path* or *start*.  On Windows, "ValueError"
   is raised when *path* and *start* are on different drives.

   *start* toma de forma predeterminada el valor de "os.curdir".

   Availability: Unix, Windows.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.samefile(path1, path2)

   Retorna "True" si ambos argumentos de nombre de ruta refieren al
   mismo archivo o directorio. Esto se determina por el número de
   dispositivo y el número de *i-node* y lanza una excepción si una
   llamada de "os.stat()" en alguno de los nombres de ruta falla.

   Availability: Unix, Windows.

   Distinto en la versión 3.2: Añadido soporte para Windows.

   Distinto en la versión 3.4: Windows ahora utiliza la misma
   implementación que en el resto de las plataformas.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.sameopenfile(fp1, fp2)

   Retorna "True" si los descriptores de archivo *fp1* y *fp2* se
   refieren al mismo archivo.

   Availability: Unix, Windows.

   Distinto en la versión 3.2: Añadido soporte para Windows.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.samestat(stat1, stat2)

   Retorna "True" si las tuplas de *stat* (*stat1* y *stat2*) refieren
   al mismo archivo. Estas estructuras pueden haber sido retornadas
   por "os.fstat()", "os.lstat()", o "os.stat()". Esta función
   implementa la comparación subyacente utilizada por: "samefile()" y
   "sameopenfile()".

   Availability: Unix, Windows.

   Distinto en la versión 3.4: Añadido soporte para Windows.

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.split(path)

   Divide el nombre de la ruta *path * en un par, `` (head, tail) ``
   donde *tail* es el último componente del nombre de la ruta y *head*
   es todo lo que conduce a eso. La parte *head* nunca contendrá una
   barra; si *head* termina en una barra, *tail* estará vacía. Si no
   hay barra inclinada en *path*, *head* estará vacío. Si *path* está
   vacía, tanto *head* como *tail* estarán vacíos. Las barras
   diagonales finales se eliminan de *head* a menos que sea la raíz
   (solo una o más barras). En todos los casos, "join(head, tail)"
   retorna una ruta a la misma ubicación que *path* (pero las cadenas
   pueden diferir). Consulta las funciones "dirname()" y "basename()".

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.splitdrive(path)

   Divide el nombre de ruta *path* en un par "(drive, tail)" donde
   *drive* es un punto de montaje o una cadena vacía. En sistemas que
   no utilizan especificaciones de unidad, *drive* siempre será una
   cadena vacía. En todos los casos, "drive + tail" será lo mismo que
   *path*.

   En Windows, divide un nombre de ruta en unidad / punto compartido
   UNC y ruta relativa.

   Si la ruta contiene una letra de unidad, la unidad contendrá todo
   hasta los dos puntos inclusive. p.ej. "splitdrive("c:/dir")"
   retorna "("c:", "/dir")"

   Si la ruta contiene una ruta UNC, *drive* contendrá el nombre de
   host y el recurso compartido, hasta el cuarto separador, pero sin
   incluirlo. p.ej. "splitdrive("//host/computer/dir")" retorna
   "("//host/computer", "/dir")"

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.splitext(path)

   Divide el nombre de ruta *path* en un par "(root, ext)" de tal
   forma que "root + ext == path", y *ext* queda vacío o inicia con un
   punto y contiene a lo mucho un punto. Se ignoran los puntos
   iniciales del nombre base; "splitext('.cshrc')" retorna "('.cshrc',
   '')".

   Distinto en la versión 3.6: Acepta un *path-like object*.

os.path.supports_unicode_filenames

   "True" si se pueden utilizar cadenas Unicode arbitrarias como
   nombres de archivo (dentro de las limitaciones impuestas por el
   sistema de archivos).
