# `os` — Interfaces misceláneas del sistema operativo

Código fuente: Lib/os.py

Este módulo provee una manera versátil de usar funcionalidades dependientes del sistema operativo. Si quieres leer o escribir un archivo mira `open()`, si quieres manipular rutas, mira el módulo `os.path`, y si quieres leer todas las líneas en todos los archivos en la línea de comandos mira el módulo `fileinput`. Para crear archivos temporales y directorios mira el módulo `tempfile`, y para el manejo de alto nivel de archivos y directorios puedes ver el módulo `shutil`.

Notas sobre la disponibilidad de estas funciones:

- El diseño de todos los módulos incorporados de Python dependientes del sistema operativo es tal que, mientras funcionalidad esté disponible, usará la misma interfaz; por ejemplo, la función `os.stat(path)` retorna estadísticas sobre la ruta (path) en el mismo formato (lo que sucede originalmente con la interfaz POSIX).

- Las extensiones propias de un sistema operativo en particular también están disponibles a través del módulo `os`, pero usarlas, por supuesto, es un riesgo a la portabilidad.

- Todas las funciones que aceptan rutas o nombres de archivos aceptan bytes o cadenas de texto, y el resultado es un objeto del mismo tipo, siempre que se retorna una ruta o un archivo.

- En VxWorks, no están soportados os.fork, os.execv y os.spawn*p*.

Nota

Todas las funciones en este módulo lanzan `OSError` (o subclases), en el caso de archivos o rutas inaccesibles o inválidas, u otros argumentos que tienen el tipo correcto, pero que no son aceptados por el sistema operativo.

exception `os.``error`

  Un alias de la excepción incorporada `OSError`.

`os.``name`

  El nombre del módulo dependiente del sistema operativo importado. Los siguientes nombres están registrados: `'posix'`, `'nt'`, `'java'`.

  Ver también

  `sys.platform` tiene un mayor nivel de detalle. `os.uname()` proporciona información de la versión dependiendo del sistema operativo.

  El módulo `platform` proporciona verificaciones detalladas de la identidad del sistema.

## Nombres de archivos, argumentos de la línea de comandos y variables de entorno

En Python, los nombres de archivo, los argumentos de la línea de comandos y las variables de entorno están representados usando cadena de caracteres. En algunos sistemas, decodificar esas cadenas desde y hacia bytes es necesario para pasárselos al sistema operativo. Python usa la codificación del sistema operativo para realizar esta conversión (ver `sys.getfilesystemencoding()`).

Distinto en la versión 3.1: En algunos sistemas, la conversión usando la codificación del sistema de archivos puede fallar. En este caso, Python usa el controlador de error de codificación de *subrogateescape*, lo que significa que los bytes no codificables se reemplazan por un carácter Unicode U + DCxx en la decodificación, y estos se traducen nuevamente al byte original en la codificación.

La codificación del sistema de archivos debe garantizar la decodificación exitosa de todos los bytes por debajo de 128. Si la codificación del sistema de archivos no proporciona esta garantía, las funciones de la API pueden generar errores Unicode.

## Parámetros de proceso

Estas funciones y elementos de datos proporcionan información y operan en el proceso y con el usuario actuales.

`os.``ctermid`()

  Retorna el nombre del archivo correspondiente al terminal que controla el proceso.

  Disponibilidad: Unix.

`os.``environ`

  A mapping object where keys and values are strings that represent the process environment. For example, `environ['HOME']` is the pathname of your home directory (on some platforms), and is equivalent to `getenv("HOME")` in C.

  This mapping is captured the first time the `os` module is imported, typically during Python startup as part of processing `site.py`. Changes to the environment made after this time are not reflected in `os.environ`, except for changes made by modifying `os.environ` directly.

  Este mapeo puede ser usado para modificar el entorno y también para consultarlo. `putenv()` será llamado automáticamente cuando el mapeo sea modificado.

  En Unix, claves y valores usan la función `sys.getfilesystemencoding()` y el controlador de errores `'surrogateescape'`. Hay que utilizar `environb` si se quiere usar una codificación diferente.

  Nota

  Calling `putenv()` directly does not change `os.environ`, so it’s better to modify `os.environ`.

  Nota

  On some platforms, including FreeBSD and macOS, setting `environ` may cause memory leaks. Refer to the system documentation for `putenv()`.

  You can delete items in this mapping to unset environment variables. `unsetenv()` will be called automatically when an item is deleted from `os.environ`, and when one of the `pop()` or `clear()` methods is called.

  Distinto en la versión 3.9: Actualizado para soportar los operadores merge (`|`) y update (`|=`) de PEP 584’s.

`os.``environb`

  Bytes version of `environ`: a mapping object where both keys and values are `bytes` objects representing the process environment. `environ` and `environb` are synchronized (modifying `environb` updates `environ`, and vice versa).

  `environb` está disponible sólo si `supports_bytes_environ` está establecido en `True`.

  Nuevo en la versión 3.2.

  Distinto en la versión 3.9: Actualizado para soportar los operadores merge (`|`) y update (`|=`) de PEP 584’s.

`os.``chdir`(path)
`os.``fchdir`(fd)
`os.``getcwd`()

  Estas funciones están detalladas en Archivos y directorios.

`os.``fsencode`(filename)

  Codifica un nombre de archivo tipo ruta con la codificación del sistema de archivos usando el controlador de errores `'surrogateescape'`, o `'strict'` en Windows; retorna `bytes` sin alterar.

  `fsdecode()` es la función inversa.

  Nuevo en la versión 3.2.

  Distinto en la versión 3.6: Soporte agregado para aceptar objetos que implementan una interfaz `os.PathLike`.

`os.``fsdecode`(filename)

  Decodifica un nombre de archivo tipo ruta desde la codificación del sistema de archivos usando el controlador de errores `'surrogateescape'`, o `'strict'` en Windows; retorna `str` sin alterar.

  `fsencode()` es la función inversa.

  Nuevo en la versión 3.2.

  Distinto en la versión 3.6: Soporte agregado para aceptar objetos que implementan una interfaz `os.PathLike`.

`os.``fspath`(path)

  Retorna la representación en el sistema de archivos de la ruta.

  Si se le pasa `str` o `bytes`, retorna sin alterar. De lo contrario se llama a `__fspath__()` y se retorna su valor siempre que sea un objeto `str` o `bytes`. En los demás casos se lanza una excepción del tipo `TypeError`.

  Nuevo en la versión 3.6.

class `os.``PathLike`

  Una clase base abstracta para objetos que representan una ruta del sistema de archivos, i.e. `pathlib.PurePath`.

  Nuevo en la versión 3.6.

  abstractmethod `__fspath__`()

    Retorna la representación de la ruta del sistema de archivos del objeto.

    Este método sólo retornará objetos `str` or `bytes`, preferentemente `str`.

`os.``getenv`(key, default=None)

  Return the value of the environment variable key if it exists, or default if it doesn’t. key, default and the result are str. Note that since `getenv()` uses `os.environ`, the mapping of `getenv()` is similarly also captured on import, and the function may not reflect future environment changes.

  En Unix, claves y valores se decodifican con la función `sys.getfilesystemencoding()` y con el controlador de errores `'surrogateescape'`. Usar `os.getenvb()` si se quiere usar una codificación diferente.

  Disponibilidad: sistemas tipo Unix, Windows.

`os.``getenvb`(key, default=None)

  Return the value of the environment variable key if it exists, or default if it doesn’t. key, default and the result are bytes. Note that since `getenvb()` uses `os.environb`, the mapping of `getenvb()` is similarly also captured on import, and the function may not reflect future environment changes.

  `getenvb()` está disponible sólo si `supports_bytes_environ` está establecido en `True`.

  Disponibilidad: sistemas tipo Unix.

  Nuevo en la versión 3.2.

`os.``get_exec_path`(env=None)

  Retorna una lista de directorios en la que se buscará un ejecutable, similar a una shell, cuando se ejecuta un proceso. env, cuando se especifica, tienen que ser un diccionario de variables de entorno donde buscar el PATH. Por defecto cuando env es `None`, se usa `environ`.

  Nuevo en la versión 3.2.

`os.``getegid`()

  Retorna el id del grupo (gid) efectivo correspondiente al proceso que se está ejecutando. Esto corresponde al bit de «set id» en el archivo que se está ejecutando en el proceso actual.

  Disponibilidad: Unix.

`os.``geteuid`()

  Retorna el id el usuario correspondiente al proceso que se está ejecutando actualmente.

  Disponibilidad: Unix.

`os.``getgid`()

  Retorna el id del grupo real correspondiente al proceso que se está ejecutando actualmente.

  Disponibilidad: Unix.

`os.``getgrouplist`(user, group)

  Return list of group ids that user belongs to. If group is not in the list, it is included; typically, group is specified as the group ID field from the password record for user, because that group ID will otherwise be potentially omitted.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``getgroups`()

  Retorna la lista de ids de grupos secundarios asociados con el proceso actual.

  Disponibilidad: Unix.

  Nota

  On macOS, `getgroups()` behavior differs somewhat from other Unix platforms. If the Python interpreter was built with a deployment target of `10.5` or earlier, `getgroups()` returns the list of effective group ids associated with the current user process; this list is limited to a system-defined number of entries, typically 16, and may be modified by calls to `setgroups()` if suitably privileged. If built with a deployment target greater than `10.5`, `getgroups()` returns the current group access list for the user associated with the effective user id of the process; the group access list may change over the lifetime of the process, it is not affected by calls to `setgroups()`, and its length is not limited to 16. The deployment target value, `MACOSX_DEPLOYMENT_TARGET`, can be obtained with `sysconfig.get_config_var()`.

`os.``getlogin`()

  Retorna el nombre del usuario que inició sesión en el terminal que controla el proceso. Para la mayoría de los casos, es más útil usar `getpass.getuser()` ya que este último verifica las variables de entorno `LOGNAME` o `USERNAME` para averiguar quién es el usuario y recurre a `pwd.getpwuid(os.getuid())[0]` para obtener el nombre de inicio de sesión del ID de usuario real actual.

  Disponibilidad: Unix, Windows.

`os.``getpgid`(pid)

  Retorna el id del grupo de procesos del proceso con la identificación del proceso pid. Si pid es 0, se retorna la identificación del grupo de proceso del proceso actual.

  Disponibilidad: Unix.

`os.``getpgrp`()

  Retorna el id del grupo de proceso actual.

  Disponibilidad: Unix.

`os.``getpid`()

  Retorna el id del proceso actual.

`os.``getppid`()

  Retorna el id del proceso del padre. Cuando el proceso padre ha terminado, en Unix la identificación que retorna es la del proceso init (1), en Windows sigue siendo la misma identificación, que ya puede ser reutilizada por otro proceso.

  Disponibilidad: Unix, Windows.

  Distinto en la versión 3.2: Se agregó soporte para Windows.

`os.``getpriority`(which, who)

  Obtenga la prioridad del programa. El valor which es uno de `PRIO_PROCESS`, `PRIO_PGRP`, o `PRIO_USER`, y who se interpreta en relación a which (un identificador de proceso para `PRIO_PROCESS`, un identificador de grupo de proceso para `PRIO_PGRP`, y un ID de usuario para `PRIO_USER`). Un valor cero para who denota (respectivamente) el proceso llamado, el grupo de proceso del proceso llamado o el ID de usuario real del proceso llamado.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``PRIO_PROCESS`
`os.``PRIO_PGRP`
`os.``PRIO_USER`

  Parámetros para las funciones `getpriority()` y `setpriority()`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``getresuid`()

  Retorna una tupla (ruid, euid, suid) que denota los ID de usuario reales, efectivos y guardados del proceso actual.

  Disponibilidad: Unix.

  Nuevo en la versión 3.2.

`os.``getresgid`()

  Retorna una tupla (rgid, egid, sgid) que denota los ID de grupo reales, efectivos y guardados del proceso actual.

  Disponibilidad: Unix.

  Nuevo en la versión 3.2.

`os.``getuid`()

  Retorna el id del usuario real del proceso actual.

  Disponibilidad: Unix.

`os.``initgroups`(username, gid)

  Llamada al sistema initgroups() para inicializar la lista de acceso de grupo con todos los grupos de los que es miembro el nombre de usuario especificado, más el ID del grupo especificado.

  Disponibilidad: Unix.

  Nuevo en la versión 3.2.

`os.``putenv`(key, value)

  Establece la variable de entorno llamada key con el valor de la cadena value. Dichos cambios en el entorno impactan a los subprocesos iniciados con `os.system()`, `popen()` o `fork()` y `execv()`.

  Assignments to items in `os.environ` are automatically translated into corresponding calls to `putenv()`; however, calls to `putenv()` don’t update `os.environ`, so it is actually preferable to assign to items of `os.environ`. This also applies to `getenv()` and `getenvb()`, which respectively use `os.environ` and `os.environb` in their implementations.

  Nota

  On some platforms, including FreeBSD and macOS, setting `environ` may cause memory leaks. Refer to the system documentation for `putenv()`.

  Lanza un evento de auditoría `os.putenv` con argumentos `key`, `value`.

  Distinto en la versión 3.9: Esta función actualmente siempre esta disponible.

`os.``setegid`(egid)

  Establece el id de grupo efectivo del proceso actual.

  Disponibilidad: Unix.

`os.``seteuid`(euid)

  Establece el id de usuario efectivo del proceso actual.

  Disponibilidad: Unix.

`os.``setgid`(gid)

  Establece el id de grupo del proceso actual.

  Disponibilidad: Unix.

`os.``setgroups`(groups)

  Establece la lista de ids de grupos secundarios asociados con el proceso actual en groups. groups debe ser una secuencia y cada elemento debe ser un número entero que identifique un grupo. Esta operación generalmente está disponible sólo para el superusuario.

  Disponibilidad: Unix.

  Nota

  On macOS, the length of groups may not exceed the system-defined maximum number of effective group ids, typically 16. See the documentation for `getgroups()` for cases where it may not return the same group list set by calling setgroups().

`os.``setpgrp`()

  Invoca a la llamada de sistema `setpgrp()` o `setpgrp(0, 0)` dependiendo de la versión que se implemente (si la hay). Vea el manual de Unix para la semántica.

  Disponibilidad: Unix.

`os.``setpgid`(pid, pgrp)

  Invoca a la llamada de sistema `setpgid()` para establecer la identificación del grupo de procesos del id del proceso como pid al grupo de procesos con id pgrp. Vea el manual de Unix para la semántica.

  Disponibilidad: Unix.

`os.``setpriority`(which, who, priority)

  Establecer la prioridad del programa. El valor which es uno de `PRIO_PROCESS`, `PRIO_PGRP`, o `PRIO_USER`, y who se interpreta en relación con which (un identificador de proceso para `PRIO_PROCESS`, un identificador de grupo de proceso para `PRIO_PGRP`, y un ID de usuario para `PRIO_USER`). Un valor cero para who denota (respectivamente) el proceso llamado, el grupo de procesos del proceso llamado o el ID del usuario real del proceso llamado. priority es un valor en el rango de -20 a 19. La prioridad predeterminada es 0; las prioridades más bajas causan una programación más favorable.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``setregid`(rgid, egid)

  Establece los ids de grupos reales y efectivos del proceso actual.

  Disponibilidad: Unix.

`os.``setresgid`(rgid, egid, sgid)

  Establece los ids de grupo reales, efectivos y guardados del proceso actual.

  Disponibilidad: Unix.

  Nuevo en la versión 3.2.

`os.``setresuid`(ruid, euid, suid)

  Establece los ids de usuario reales, efectivos y guardados del proceso actual.

  Disponibilidad: Unix.

  Nuevo en la versión 3.2.

`os.``setreuid`(ruid, euid)

  Establece los ids de usuario reales y efectivos del proceso actual.

  Disponibilidad: Unix.

`os.``getsid`(pid)

  Invoca a la llamada de sistema `getsid()`. Vea el manual de Unix para la semántica.

  Disponibilidad: Unix.

`os.``setsid`()

  Invoca a la llamada de sistema `setsid()`. Vea el manual de Unix para la semántica.

  Disponibilidad: Unix.

`os.``setuid`(uid)

  Establece id del usuario del proceso actual.

  Disponibilidad: Unix.

`os.``strerror`(code)

  Retorna el mensaje de error correspondiente al código de error en code. En plataformas donde `strerror()` retorna `NULL` cuando se le da un número de error desconocido lanza un `ValueError`.

`os.``supports_bytes_environ`

  `True` si el tipo de entorno nativo del sistema operativo es bytes (por ejemplo, `False` en Windows).

  Nuevo en la versión 3.2.

`os.``umask`(mask)

  Establece la umask numérica actual y retorna la umask anterior.

`os.``uname`()

  Retorna información que identifica el sistema operativo actual. El valor retornado es un objeto con cinco atributos:

  - `sysname` - nombre del sistema operativo

  - `nodename` - nombre de la máquina en la red (definida por la implementación)

  - `release` - release del sistema operativo

  - `version` - versión del sistema operativo

  - `machine` - identificador de hardware

  Por compatibilidad con versiones anteriores, este objeto también es iterable, se comporta como una tupla que contiene `sysname`, `nodename`, `release`, `version`, y `machine` en ese orden.

  Algunos sistemas se truncan `nodename` a 8 caracteres o al componente principal; una mejor manera de obtener el nombre de host es usar `socket.gethostname()` o incluso `socket.gethostbyaddr(socket.gethostname())`.

  Disponibilidad: sistemas tipo Unix más nuevos.

  Distinto en la versión 3.3: El tipo de objeto retornado cambió de una tupla a un objeto tipo tupla con atributos con nombre.

`os.``unsetenv`(key)

  Desestablece (elimine) la variable de entorno llamada key. Dichos cambios en el entorno afectan a los subprocesos iniciados con `os.system()`, `popen()` o `fork()` y `execv()`.

  Deletion of items in `os.environ` is automatically translated into a corresponding call to `unsetenv()`; however, calls to `unsetenv()` don’t update `os.environ`, so it is actually preferable to delete items of `os.environ`.

  Lanza un evento de auditoría `os.unsetenv` con argumento `key`.

  Distinto en la versión 3.9: Estas funciones se encuentra ahora siempre disponible y también esta disponible en Windows

## Creación de objetos de tipo archivo

Estas funciones crean nuevos objetos de archivo. (Consulte también `open()` para abrir los descriptores de archivos).

`os.``fdopen`(fd, *args, **kwargs)

  Retorna un objeto de archivo abierto conectado al descriptor de archivo fd. Este es un alias de la función incorporada `open()` y acepta los mismos argumentos. La única diferencia es que el primer argumento de `fdopen()` siempre debe ser un número entero.

## Operaciones de descriptores de archivos

Estas funciones operan en flujos de E/S a los que se hace referencia mediante descriptores de archivo.

Los descriptores de archivo son enteros pequeños que corresponden a un archivo que ha sido abierto por el proceso actual. Por ejemplo, la entrada estándar suele ser el descriptor de archivo 0, la salida estándar es el 1 y el error estándar es el 2. A los archivos abiertos por un proceso se les asignará 3, 4, 5, y así sucesivamente. El nombre «descriptor de archivo» es ligeramente engañoso; en las plataformas Unix, los descriptores de archivo también hacen referencia a sockets y tuberías.

El método `fileno()` se puede utilizar para obtener el descriptor de archivo asociado con un file object cuando sea necesario. Tenga en cuenta que el uso del descriptor de archivo directamente omitirá los métodos de objeto de archivo, ignorando aspectos como el almacenamiento interno interno de datos.

`os.``close`(fd)

  Cierra el descriptor de archivo fd.

  Nota

  Esta función está diseñada para E/S de bajo nivel y debe aplicarse a un descriptor de archivo tal como lo retorna `os.open()` o `pipe()`. Para cerrar un «objeto de archivo» retornado por la función incorporada `open()` o por `popen()` o `fdopen()`, use el método `close()`.

`os.``closerange`(fd_low, fd_high)

  Cierra todos los descriptores de archivo desde fd_low (inclusive) hasta fd_high (exclusivo), ignorando los errores. Equivalente a (pero mucho más rápido que):

      for fd in range(fd_low, fd_high):
          try:
              os.close(fd)
          except OSError:
              pass

`os.``copy_file_range`(src, dst, count, offset_src=None, offset_dst=None)

  Copia count bytes del descriptor de archivo src, comenzando desde offset offset_src, al descriptor de archivo dst, comenzando desde offset offset_dst. Si offset_src es None, entonces src se lee desde la posición actual; respectivamente para offset_dst. Los archivos señalados por src y dst deben estar en el mismo sistema de archivos; de lo contrario, se genera una `OSError` con `errno` establecido en `errno.EXDEV`.

  Esta copia se realiza sin el costo adicional de transferir datos desde el kernel al espacio del usuario y luego nuevamente al kernel. También, algunos sistemas de archivos podrían implementar optimizaciones adicionales. La copia se realiza como si ambos archivos se abrieran como binarios.

  El valor de retorno es la cantidad de bytes copiados. Esto podría ser menor que la cantidad solicitada.

  Disponibilidad: Kernel de Linux >= 4.5 o glibc >= 2.27.

  Nuevo en la versión 3.8.

`os.``device_encoding`(fd)

  Retorna una cadena que describe la codificación del dispositivo asociado con fd si está conectado a una terminal; sino retorna `None`.

`os.``dup`(fd)

  Retorna un duplicado del descriptor de archivo fd. El nuevo descriptor de archivo es no heredable.

  En Windows, al duplicar un flujo estándar (0: stdin, 1: stdout, 2: stderr), el nuevo descriptor de archivo es heredable.

  Distinto en la versión 3.4: El nuevo descriptor de archivo ahora es no heredable.

`os.``dup2`(fd, fd2, inheritable=True)

  Duplicar el descriptor de archivo fd a fd2, cerrando el anterior si es necesario. Retorna fd2. El nuevo descriptor de archivo es heredable por defecto o no heredable si inheritable es `False`.

  Distinto en la versión 3.4: Agrega el parámetro opcional inheritable.

  Distinto en la versión 3.7: Retorna fd2 en caso de éxito. Anteriormente se retornaba siempre `None`.

`os.``fchmod`(fd, mode)

  Cambia el modo del archivo dado por fd al modo numérico mode. Consulte los documentos para `chmod()` para conocer los posibles valores de mode. A partir de Python 3.3, esto es equivalente a `os.chmod(fd, mode)`.

  Lanza un evento de auditoría `os.chmod` con argumentos `path`, `mode`, `dir_fd`.

  Disponibilidad: Unix.

`os.``fchown`(fd, uid, gid)

  Cambia el propietario y el id del grupo del archivo proporcionado por fd a los numéricos dados por uid y gid. Para dejar uno de los identificadores sin cambios, configúrelo en -1. Ver `chown()`. A partir de Python 3.3, esto es equivalente a `os.chown(fd, uid, gid)`.

  Lanza un evento de auditoría `os.chown` con argumentos `path`, `uid`, `gid`, `dir_fd`.

  Disponibilidad: Unix.

`os.``fdatasync`(fd)

  Fuerza la escritura del archivo con el descriptor de archivo fd en el disco. No fuerza la actualización de metadatos.

  Disponibilidad: Unix.

  Nota

  Esta función no está disponible en MacOS.

`os.``fpathconf`(fd, name)

  Retorna la información de configuración del sistema relevante para un archivo abierto. name especifica el valor de configuración para recuperar; puede ser una cadena que es el nombre de un valor de sistema definido; estos nombres se especifican en varios estándares (POSIX.1, Unix 95, Unix 98 y otros). Algunas plataformas también definen nombres adicionales. Los nombres conocidos por el sistema operativo anfitrión se dan en el diccionario `pathconf_names`. Para las variables de configuración no incluidas en esa asignación, también se acepta pasar un número entero para name.

  Si name es una cadena y no se conoce, se lanza un `ValueError`. Si el sistema anfitrión no admite un valor específico para name, incluso si está incluido en `pathconf_names`, se genera un `OSError` con `errno.EINVAL` para el número de error.

  A partir de Python 3.3, esto es equivalente a `os.pathconf(fd, name)`.

  Disponibilidad: Unix.

`os.``fstat`(fd)

  Obtiene el estado del descriptor de archivo fd. Retorna un objeto `stat_result`.

  A partir de Python 3.3, esto es equivalente a `os.stat(fd)`.

  Ver también

  La función `stat()`.

`os.``fstatvfs`(fd)

  Retorna información sobre el sistema de archivos que contiene el archivo asociado con el descriptor de archivo fd, como `statvfs()`. A partir de Python 3.3, esto es equivalente a `os.statvfs(fd)`.

  Disponibilidad: Unix.

`os.``fsync`(fd)

  Fuerza la escritura del archivo con el descriptor de archivo fd en el disco. En Unix, esto llama a la función nativa `fsync()`; en Windows, la función MS `_commit()`.

  Si está comenzando con un Python almacenado en búfer file object f, primero haga `f.flush()`, y luego haga `os.fsync(f.fileno())`, para garantizar que todas las memorias intermedias internas asociadas con f se escriban en disco.

  Disponibilidad: Unix, Windows.

`os.``ftruncate`(fd, length)

  Trunca el archivo correspondiente al descriptor de archivo fd, para que tenga como máximo length bytes de tamaño. A partir de Python 3.3, esto es equivalente a `os.truncate(fd, length)`.

  Lanza un evento de auditoría `os.truncate` con argumentos `fd`, `length`.

  Disponibilidad: Unix, Windows.

  Distinto en la versión 3.5: Se agregó soporte para Windows

`os.``get_blocking`(fd)

  Obtiene el modo de bloqueo del descriptor de archivo: `False` si se establece el indicador `O_NONBLOCK`, `True` si el indicador se borra.

  Consulte también `set_blocking()` y `socket.socket.setblocking()`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.5.

`os.``isatty`(fd)

  Retorna `True` si el descriptor de archivo fd está abierto y conectado a un dispositivo tipo tty, de lo contrario, `False`.

`os.``lockf`(fd, cmd, len)

  Aplique, pruebe o elimine un bloqueo POSIX en un descriptor de archivo abierto. fd es un descriptor de archivo abierto. cmd especifica el comando a usar - uno de `F_LOCK`, `F_TLOCK`, `F_ULOCK` o `F_TEST`. len especifica la sección del archivo a bloquear.

  Lanza un evento de auditoría `os.lockf` con argumentos `fd`, `cmd`, `len`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``F_LOCK`
`os.``F_TLOCK`
`os.``F_ULOCK`
`os.``F_TEST`

  Indicadores que especifican qué acción tomará `lockf()`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``lseek`(fd, pos, how)

  Establece la posición actual del descriptor de archivo fd en la posición pos, modificada por how: `SEEK_SET` o `0` para establecer la posición relativa al comienzo del archivo; `SEEK_CUR` o `1` para establecerlo en relación con la posición actual; `SEEK_END` o `2` para establecerlo en relación con el final del archivo. Retorna la nueva posición del cursor en bytes, comenzando desde el principio.

`os.``SEEK_SET`
`os.``SEEK_CUR`
`os.``SEEK_END`

  Parámetros para la función `lseek()`. Sus valores son 0, 1 y 2, respectivamente.

  Nuevo en la versión 3.3: Algunos sistemas operativos pueden admitir valores adicionales, como `os.SEEK_HOLE` o `os.SEEK_DATA`.

`os.``open`(path, flags, mode=0o777, *, dir_fd=None)

  Abre el archivo path y configura varios indicadores según flags y su modo según mode. Al calcular el modo el valor actual de umask se enmascara primero. Retorna el descriptor de archivo para el archivo recién abierto. El nuevo descriptor de archivo es no heredable.

  Para una descripción de los valores de indicadores (flags) y modo (mode), consulte la documentación de tiempo de ejecución de C; los indicadores constantes de flag (como `O_RDONLY` y `O_WRONLY`) se definen en el módulo `os`. En particular, en Windows agregar `O_BINARY` es necesario para abrir archivos en modo binario.

  Esta función puede admitir rutas relativas a descriptores de directorio con el parámetro dir_fd.

  Lanza un evento de auditoría `open` con argumentos `path`, `mode`, `flags`.

  Distinto en la versión 3.4: El nuevo descriptor de archivo ahora es no heredable.

  Nota

  Esta función está diseñada para E/S de bajo nivel. Para un uso normal, use la función integrada `open()`, que retorna un file object con métodos `read()` y `write()` (y mucho mas). Para envolver un descriptor de archivo en un objeto de archivo, use `fdopen()`.

  Nuevo en la versión 3.3: El argumento dir_fd.

  Distinto en la versión 3.5: Si la llamada al sistema se interrumpe y el controlador de señal no genera una excepción, la función vuelve a intentar la llamada del sistema en lugar de generar una excepción `InterruptedError` (ver PEP 475 para la justificación).

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

Las siguientes constantes son opciones para el parámetro flags de la función `open()`. Se pueden combinar con el operador OR a nivel de bit `|`. Algunos de ellas no están disponibles en todas las plataformas. Para obtener descripciones de su disponibilidad y uso, consulte la página de manual open(2) en Unix o la MSDN en Windows.

`os.``O_RDONLY`
`os.``O_WRONLY`
`os.``O_RDWR`
`os.``O_APPEND`
`os.``O_CREAT`
`os.``O_EXCL`
`os.``O_TRUNC`

  Las constantes anteriores están disponibles en Unix y Windows.

`os.``O_DSYNC`
`os.``O_RSYNC`
`os.``O_SYNC`
`os.``O_NDELAY`
`os.``O_NONBLOCK`
`os.``O_NOCTTY`
`os.``O_CLOEXEC`

  Las constantes anteriores sólo están disponibles en Unix.

  Distinto en la versión 3.3: Se agregó la constante `O_CLOEXEC`.

`os.``O_BINARY`
`os.``O_NOINHERIT`
`os.``O_SHORT_LIVED`
`os.``O_TEMPORARY`
`os.``O_RANDOM`
`os.``O_SEQUENTIAL`
`os.``O_TEXT`

  Las constantes anteriores sólo están disponibles en Windows.

`os.``O_ASYNC`
`os.``O_DIRECT`
`os.``O_DIRECTORY`
`os.``O_NOFOLLOW`
`os.``O_NOATIME`
`os.``O_PATH`
`os.``O_TMPFILE`
`os.``O_SHLOCK`
`os.``O_EXLOCK`

  Las constantes anteriores son extensiones y no están presentes si no están definidas por la biblioteca de C.

  Distinto en la versión 3.4: Se agrega la constante `O_PATH` en los sistemas que lo admiten. Se agrega `O_TMPFILE`, sólo disponible en Linux para el Kernel 3.11 o posterior.

`os.``openpty`()

  Abre un nuevo par de pseudo-terminal. Retorna un par de descriptores de archivo `(master, slave)`; para pty y tty, respectivamente. Los nuevos descriptores de archivo son no heredable. Para un enfoque (ligeramente) más portátil, use el módulo `pty`.

  Disponibilidad: algunos sistemas tipo Unix.

  Distinto en la versión 3.4: Los nuevos descriptores de archivo ahora son no heredables.

`os.``pipe`()

  Crea una tubería. Retorna un par de descriptores de archivo `(r, w)` que se pueden usar para leer y escribir, respectivamente. El nuevo descriptor de archivo es no heredable.

  Disponibilidad: Unix, Windows.

  Distinto en la versión 3.4: Los nuevos descriptores de archivo ahora son no heredables.

`os.``pipe2`(flags)

  Crea una tubería con flags establecidas atómicamente. flags pueden construirse juntando uno o más de estos valores: `O_NONBLOCK`, `O_CLOEXEC` con el operador OR. Retorna un par de descriptores de archivo `(r, w)` que se pueden usar para leer y escribir, respectivamente.

  Disponibilidad: algunos sistemas tipo Unix.

  Nuevo en la versión 3.3.

`os.``posix_fallocate`(fd, offset, len)

  Asegura que se asigne suficiente espacio en disco para el archivo especificado por fd a partir de offset y se extiende por len bytes.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``posix_fadvise`(fd, offset, len, advice)

  Avisa una intención de acceder a los datos en un patrón específico, permitiendo así que el núcleo haga optimizaciones. El consejo se aplica a la región del archivo especificada por fd que comienza en offset y se extiende para len bytes. advice es uno de `POSIX_FADV_NORMAL`, `POSIX_FADV_SEQUENTIAL`, `POSIX_FADV_RANDOM`, `POSIX_FADV_NOREUSE`, `POSIX_FADV_WILLNEED` o `POSIX_FADV_DONTNEED`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``POSIX_FADV_NORMAL`
`os.``POSIX_FADV_SEQUENTIAL`
`os.``POSIX_FADV_RANDOM`
`os.``POSIX_FADV_NOREUSE`
`os.``POSIX_FADV_WILLNEED`
`os.``POSIX_FADV_DONTNEED`

  Indicadores que se pueden usar en advice en `posix_fadvise()` que especifican el patrón de acceso que es probable que se use.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``pread`(fd, n, offset)

  Lee como máximo n bytes del descriptor de archivo fd en una posición de offset, sin modificar el desplazamiento (offset) del archivo.

  Retorna una cadena de bytes que contiene los bytes leídos. Si se alcanza el final del archivo al que hace referencia fd, se retorna un objeto de bytes vacío.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``preadv`(fd, buffers, offset, flags=0)

  Lee de un descriptor de archivo fd en una posición de offset en mutable objetos de tipo bytes buffers, dejando el desplazamiento del archivo sin cambios. Transfiere datos a cada búfer hasta que esté lleno y luego pase al siguiente búfer en la secuencia para contener el resto de los datos.

  El argumento flags contiene un operador de bit a bit OR de cero o más de las siguientes flags:

  - `RWF_HIPRI`

  - `RWF_NOWAIT`

  Retorna el número total de bytes realmente leídos que puede ser menor que la capacidad total de todos los objetos.

  El sistema operativo puede establecer un límite (`sysconf()` valor `'SC_IOV_MAX'`) en el número de búferes que se pueden usar.

  Combina la funcionalidad de `os.readv()` y `os.pread()`.

  Disponibilidad: Linux 2.6.30 y posterior, FreeBSD 6.0 y posterior, OpenBSD 2.7 y posterior, AIX 7.1 y posterior. El uso de flags requiere Linux 4.6 o posterior.

  Nuevo en la versión 3.7.

`os.``RWF_NOWAIT`

  No espere datos que no estén disponibles de inmediato. Si se especifica este indicador, la llamada al sistema regresará instantáneamente si tuviera que leer datos del almacenamiento de respaldo o esperar por un bloqueo.

  Si algunos datos se leyeron con éxito, retornará el número de bytes leídos. Si no se leyeron bytes, retornará `-1` y establecerá errno en `errno.EAGAIN`.

  Disponibilidad: Linux 4.14 y más nuevos.

  Nuevo en la versión 3.7.

`os.``RWF_HIPRI`

  Alta prioridad de lectura/escritura. Permite que los sistemas de archivos basados en bloques utilicen el sondeo del dispositivo, lo que proporciona una latencia más baja, pero puede usar recursos adicionales.

  Actualmente, en Linux, esta función sólo se puede usar en un descriptor de archivo abierto con el indicador `O_DIRECT`.

  Disponibilidad: Linux 4.6 y más nuevos.

  Nuevo en la versión 3.7.

`os.``pwrite`(fd, str, offset)

  Escribe la cadena de bytes en str en el descriptor de archivo fd en la posición offset, sin modificar el desplazamiento del archivo.

  Retorna el número de bytes realmente escritos.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``pwritev`(fd, buffers, offset, flags=0)

  Escribe los contenidos de los buffers en el descriptor de archivo fd en un desplazamiento offset, dejando el desplazamiento del archivo sin cambios. buffers deben ser una secuencia de objetos tipo bytes. Los búferes se procesan en orden secuencial. Se escribe todo el contenido del primer búfer antes de pasar al segundo, y así sucesivamente.

  El argumento flags contiene un operador de bit a bit OR de cero o más de las siguientes flags:

  - `RWF_DSYNC`

  - `RWF_SYNC`

  Retorna el número total de bytes realmente escritos.

  El sistema operativo puede establecer un límite (`sysconf()` valor `'SC_IOV_MAX'`) en el número de búferes que se pueden usar.

  Combina la funcionalidad de `os.writev()` y `os.pwrite()`.

  Disponibilidad: Linux 2.6.30 y posterior, FreeBSD 6.0 y posterior, OpenBSD 2.7 y posterior, AIX 7.1 y posterior. El uso de flags requiere Linux 4.7 o posterior.

  Nuevo en la versión 3.7.

`os.``RWF_DSYNC`

  Proporciona un equivalente por escritura de la flag `O_DSYNC`` open(2)`. Esta flag sólo se aplica al rango de datos escrito por la llamada al sistema.

  Disponibilidad: Linux 4.7 y más nuevos.

  Nuevo en la versión 3.7.

`os.``RWF_SYNC`

  Proporciona un equivalente por escritura de la flag `O_SYNC`` open(2)`. Esta flag sólo se aplica al rango de datos escrito por la llamada al sistema.

  Disponibilidad: Linux 4.7 y más nuevos.

  Nuevo en la versión 3.7.

`os.``read`(fd, n)

  Lee como máximo n bytes del descriptor de archivo fd.

  Retorna una cadena de bytes que contiene los bytes leídos. Si se alcanza el final del archivo al que hace referencia fd, se retorna un objeto de bytes vacío.

  Nota

  Esta función está diseñada para E/S de bajo nivel y debe aplicarse a un descriptor de archivo tal como lo retorna `os.open()` o `pipe()`. Para leer un «objeto archivo» retornado por la función incorporada `open()` o por `popen()` o `fdopen()`, o `sys.stdin`, use los métodos `read()` o `readline()`.

  Distinto en la versión 3.5: Si la llamada al sistema se interrumpe y el controlador de señal no genera una excepción, la función vuelve a intentar la llamada del sistema en lugar de generar una excepción `InterruptedError` (ver PEP 475 para la justificación).

`os.``sendfile`(out_fd, in_fd, offset, count)
`os.``sendfile`(out_fd, in_fd, offset, count, headers=(), trailers=(), flags=0)

  Copia count bytes del descriptor de archivo in_fd al descriptor de archivo out_fd comenzando en offset. Retorna el número de bytes enviados. Cuando se alcanza EOF, retorna `0`.

  La primera notación de la función es compatible con todas las plataformas que definen `sendfile()`.

  En Linux, si offset se entrega como `None`, los bytes se leen desde la posición actual de in_fd y la posición de in_fd se actualiza.

  The second case may be used on macOS and FreeBSD where headers and trailers are arbitrary sequences of buffers that are written before and after the data from in_fd is written. It returns the same as the first case.

  On macOS and FreeBSD, a value of `0` for count specifies to send until the end of in_fd is reached.

  Todas las plataformas admiten sockets como descriptor de archivo out_fd, y algunas plataformas también permiten otros tipos (por ejemplo, archivo regular, tuberías).

  Las aplicaciones multiplataforma no deben usar los argumentos headers, trailers y flags.

  Disponibilidad: Unix.

  Nota

  Para un contenedor de alto nivel de `sendfile()`, vea `socket.socket.sendfile()`.

  Nuevo en la versión 3.3.

  Distinto en la versión 3.9: Parámetros out e in han sido renombrados a out_fd e in_fd.

`os.``set_blocking`(fd, blocking)

  Establece el modo de bloqueo del descriptor de archivo especificado. Establece la flag `O_NONBLOCK` si se quiere que el bloqueo sea `False`, borre la flag de lo contrario.

  Consulte también `get_blocking()` y `socket.socket.setblocking()`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.5.

`os.``SF_NODISKIO`
`os.``SF_MNOWAIT`
`os.``SF_SYNC`

  Parámetros para la función `sendfile()`, si la implementación los admite.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``readv`(fd, buffers)

  Leer desde un descriptor de archivo fd en una cantidad de mutable objetos tipo bytes buffers. Transfiere datos a cada búfer hasta que esté lleno y luego pase al siguiente búfer en la secuencia para contener el resto de los datos.

  Retorna el número total de bytes realmente leídos que puede ser menor que la capacidad total de todos los objetos.

  El sistema operativo puede establecer un límite (`sysconf()` valor `'SC_IOV_MAX'`) en el número de búferes que se pueden usar.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``tcgetpgrp`(fd)

  Retorna el grupo del proceso asociado con la terminal proporcionada por fd (un descriptor de archivo abierto como lo retorna `os.open()`).

  Disponibilidad: Unix.

`os.``tcsetpgrp`(fd, pg)

  Establece el grupo del proceso asociado con la terminal dada por fd (un descriptor de archivo abierto como lo retorna `os.open()`) a pg.

  Disponibilidad: Unix.

`os.``ttyname`(fd)

  Retorna una cadena que especifica el dispositivo de terminal asociado con el descriptor de archivo fd. Si fd no está asociado con un dispositivo de terminal, se genera una excepción.

  Disponibilidad: Unix.

`os.``write`(fd, str)

  Escribe la cadena de bytes en str en el descriptor de archivo fd.

  Retorna el número de bytes realmente escritos.

  Nota

  Esta función está diseñada para E/S de bajo nivel y debe aplicarse a un descriptor de archivo tal como lo retorna `os.open()` o `pipe()`. Para escribir un «objeto archivo» retornado por la función incorporada `open()` o por `popen()` o `fdopen()`, o `sys.stdout` o `sys.stderr`, use el método `write()`.

  Distinto en la versión 3.5: Si la llamada al sistema se interrumpe y el controlador de señal no genera una excepción, la función vuelve a intentar la llamada del sistema en lugar de generar una excepción `InterruptedError` (ver PEP 475 para la justificación).

`os.``writev`(fd, buffers)

  Escribe el contenido de buffers en el descriptor de archivo fd. buffers debe ser una secuencia de objetos tipo bytes. Los búferes se procesan en orden secuencial. Se escribe todo el contenido del primer búfer antes de pasar al segundo, y así sucesivamente.

  Retorna el número total de bytes realmente escritos.

  El sistema operativo puede establecer un límite (`sysconf()` valor `'SC_IOV_MAX'`) en el número de búferes que se pueden usar.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

### Consultando las dimensiones de una terminal

Nuevo en la versión 3.3.

`os.``get_terminal_size`(fd=STDOUT_FILENO)

  Retorna el tamaño de la ventana de la terminal como `(columns, lines)`, una tupla del tipo `terminal_size`.

  El argumento opcional `fd` (por defecto es `STDOUT_FILENO`, o la salida estándar) especifica qué descriptor de archivo debe consultarse.

  Si el descriptor de archivo no está conectado a una terminal, se genera un `OSError`.

  `shutil.get_terminal_size()` es la función de alto nivel que normalmente debería usarse, `os.get_terminal_size` es la implementación de bajo nivel.

  Disponibilidad: Unix, Windows.

class `os.``terminal_size`

  Una subclase de tupla, que contiene `(columns, lines)` representando el tamaño de la ventana de la terminal.

  `columns`

    Ancho de la ventana de la terminal en caracteres.

  `lines`

    Alto de la ventana de la terminal en caracteres.

### Herencia de los descriptores de archivos

Nuevo en la versión 3.4.

Un descriptor de archivo tiene un indicador heredable (inheritable) que indica si el descriptor de archivo puede ser heredado por procesos secundarios. Desde Python 3.4, los descriptores de archivo creados por Python son no heredables por defecto.

En UNIX, los descriptores de archivo no heredables se cierran en procesos hijos en la ejecución de un nuevo programa, otros descriptores de archivos sí se heredan.

En Windows, los descriptores de archivo y los identificadores no heredables se cierran en los procesos hijos, a excepción de los flujos estándar (descriptores de archivo 0, 1 y 2: stdin, stdout y stderr), que siempre se heredan. Usando las funciones `spawn*`, todos los identificadores heredables y todos los descriptores de archivos heredables se heredan. Usando el módulo `subprocess`, todos los descriptores de archivo, excepto los flujos estándar, están cerrados, y los identificadores heredables sólo se heredan si el parámetro close_fds es `False`.

`os.``get_inheritable`(fd)

  Obtiene el indicador heredable (inheritable) del descriptor de archivo especificado (un valor booleano).

`os.``set_inheritable`(fd, inheritable)

  Establece el indicador heredable (inheritable) del descriptor de archivo especificado.

`os.``get_handle_inheritable`(handle)

  Obtiene el indicador heredable (inheritable) del identificador especificado (un valor booleano).

  Disponibilidad: Windows.

`os.``set_handle_inheritable`(handle, inheritable)

  Establece el indicador heredable (inheritable) del identificador especificado.

  Disponibilidad: Windows.

## Archivos y directorios

En algunas plataformas Unix, muchas de estas funciones admiten una o más de estas características:

- especificando un descriptor de archivo: Normalmente el argumento path proporcionado a las funciones en el módulo `os` debe ser una cadena que especifique una ruta de archivo. Sin embargo, algunas funciones ahora aceptan alternativamente un descriptor de archivo abierto para su argumento path. La función actuará en el archivo al que hace referencia el descriptor. (Para los sistemas POSIX, Python llamará a la variante de la función con el prefijo `f` (por ejemplo, llamará a `fchdir` en lugar de `chdir`)).

  Puede verificar si path se puede especificar o no como un descriptor de archivo para una función particular en su plataforma usando `os.supports_fd`. Si esta funcionalidad no está disponible, su uso generará un `NotImplementedError`.

  Si la función también admite argumentos dir_fd o follow_symlinks, es un error especificar uno de esos al suministrar path como descriptor de archivo.

- rutas relativas a los descriptores de directorio: Si dir_fd no es `None`, debería ser un descriptor de archivo que se refiera a un directorio, y la ruta a operar debería ser relativa; entonces la ruta será relativa a ese directorio. Si la ruta es absoluta, dir_fd se ignora. (Para los sistemas POSIX, Python llamará a la variante de la función con un sufijo `at` y posiblemente con el prefijo `f` (por ejemplo, llamará a `faccessat` en lugar de `access`).

  Puede verificar si dir_fd es compatible o no para una función particular en su plataforma usando `os.supports_dir_fd`. Si no está disponible, usarlo generará un `NotImplementedError`.

- no seguir los enlaces simbólicos: Si follow_symlinks es `False`, y el último elemento de la ruta para operar es un enlace simbólico, la función operará en el enlace simbólico en lugar del archivo señalado por el enlace. (Para los sistemas POSIX, Python llamará a la variante `l...` de la función).

  Puede verificar si follow_symlinks es compatible o no para una función particular en su plataforma usando `os.supports_follow_symlinks`. Si no está disponible, usarlo generará un `NotImplementedError`.

`os.``access`(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)

  Use el uid/gid real para probar el acceso a path. Tenga en cuenta que la mayoría de las operaciones utilizarán el uid/gid efectivo, por lo tanto, esta rutina se puede usar en un entorno suid/sgid para probar si el usuario que invoca tiene el acceso especificado a path. mode debería ser `F_OK` para probar la existencia de path, o puede ser el OR inclusivo de uno o más de `R_OK`, `W_OK`, y `X_OK` para probar los permisos. Retorna `True` si el acceso está permitido, `False` si no. Consulte la página de manual de Unix access (2) para obtener más información.

  Esta función puede admitir la especificación rutas relativas a descriptores de directorio y no seguir los enlaces simbólicos.

  Si effective_ids es `True`, `access()` realizará sus comprobaciones de acceso utilizando el uid/gid efectivo en lugar del uid/gid real. effective_ids puede no ser compatible con su plataforma; puede verificar si está disponible o no usando `os.supports_effective_ids`. Si no está disponible, usarlo generará un `NotImplementedError`.

  Nota

  Usando `access()` para verificar si un usuario está autorizado para, por ejemplo, abrir un archivo antes de hacerlo usando `open()` crea un agujero de seguridad, porque el usuario podría explotar el breve intervalo de tiempo entre verificar y abrir el archivo para manipularlo es preferible utilizar técnicas EAFP. Por ejemplo:

      if os.access("myfile", os.R_OK):
          with open("myfile") as fp:
              return fp.read()
      return "some default data"

  está mejor escrito como:

      try:
          fp = open("myfile")
      except PermissionError:
          return "some default data"
      else:
          with fp:
              return fp.read()

  Nota

  Las operaciones de E/S pueden fallar incluso cuando `access()` indica que tendrán éxito, particularmente para operaciones en sistemas de archivos de red que pueden tener una semántica de permisos más allá del modelo habitual de bits de permiso POSIX.

  Distinto en la versión 3.3: Se agregaron los parámetros dir_fd, effective_ids y follow_symlinks.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``F_OK`
`os.``R_OK`
`os.``W_OK`
`os.``X_OK`

  Valores para pasar como parámetro mode de `access()` para probar la existencia, legibilidad, escritura y ejecutabilidad de path, respectivamente.

`os.``chdir`(path)

  Cambia el directorio de trabajo actual a path.

  Esta función puede soportar especificando un descriptor de archivo. El descriptor debe hacer referencia a un directorio abierto, no a un archivo abierto.

  Esta función puede generar `OSError` y subclases como `FileNotFoundError`, `PermissionError`, y `NotADirectoryError`.

  Lanza un evento de auditoría `os.chdir` con argumento `path`.

  Nuevo en la versión 3.3: Se agregó soporte para especificar path como descriptor de archivo en algunas plataformas.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``chflags`(path, flags, *, follow_symlinks=True)

  Establece las flags del path a las flags numéricas. flags puede tomar una combinación (OR bit a bit) de los siguientes valores (como se define en el módulo `stat`):

  - `stat.UF_NODUMP`

  - `stat.UF_IMMUTABLE`

  - `stat.UF_APPEND`

  - `stat.UF_OPAQUE`

  - `stat.UF_NOUNLINK`

  - `stat.UF_COMPRESSED`

  - `stat.UF_HIDDEN`

  - `stat.SF_ARCHIVED`

  - `stat.SF_IMMUTABLE`

  - `stat.SF_APPEND`

  - `stat.SF_NOUNLINK`

  - `stat.SF_SNAPSHOT`

  Esta función puede soportar no seguir enlaces simbólicos.

  Lanza un evento de auditoría `os.chflags` con argumentos `path`, `flags`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3: El argumento follow_symlinks.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``chmod`(path, mode, *, dir_fd=None, follow_symlinks=True)

  Cambia el modo de path al modo numérico mode. mode puede tomar uno de los siguientes valores (como se define en el módulo `stat`) o combinaciones OR de bit a bit de ellos:

  - `stat.S_ISUID`

  - `stat.S_ISGID`

  - `stat.S_ENFMT`

  - `stat.S_ISVTX`

  - `stat.S_IREAD`

  - `stat.S_IWRITE`

  - `stat.S_IEXEC`

  - `stat.S_IRWXU`

  - `stat.S_IRUSR`

  - `stat.S_IWUSR`

  - `stat.S_IXUSR`

  - `stat.S_IRWXG`

  - `stat.S_IRGRP`

  - `stat.S_IWGRP`

  - `stat.S_IXGRP`

  - `stat.S_IRWXO`

  - `stat.S_IROTH`

  - `stat.S_IWOTH`

  - `stat.S_IXOTH`

  Esta función puede soportar especificando un descriptor de archivo, rutas relativas a los descriptores de directorio y no seguir enlaces simbólicos.

  Nota

  Aunque Windows admite `chmod()`, sólo puede establecer el indicador de sólo lectura del archivo (a través de las constantes``stat.S_IWRITE`` y `stat.S_IREAD` o un valor entero correspondiente). Todos los demás bits son ignorados.

  Lanza un evento de auditoría `os.chmod` con argumentos `path`, `mode`, `dir_fd`.

  Nuevo en la versión 3.3: Se agregó soporte para especificar path como un descriptor de archivo abierto, y los argumentos dir_fd y follow_symlinks.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``chown`(path, uid, gid, *, dir_fd=None, follow_symlinks=True)

  Cambia el propietario y el id del grupo de path a los numéricos uid y gid. Para dejar uno de los identificadores sin cambios, configúrelo en -1.

  Esta función puede soportar especificando un descriptor de archivo, rutas relativas a los descriptores de directorio y no seguir enlaces simbólicos.

  Ver `shutil.chown()` para una función de nivel superior que acepta nombres además de identificadores numéricos.

  Lanza un evento de auditoría `os.chown` con argumentos `path`, `uid`, `gid`, `dir_fd`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3: Se agregó soporte para especificar path como un descriptor de archivo abierto, y los argumentos dir_fd y follow_symlinks.

  Distinto en la versión 3.6: Admite un objeto tipo ruta.

`os.``chroot`(path)

  Cambia el directorio raíz del proceso actual a path.

  Disponibilidad: Unix.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``fchdir`(fd)

  Cambia el directorio de trabajo actual al directorio representado por el descriptor de archivo fd. El descriptor debe hacer referencia a un directorio abierto, no a un archivo abierto. A partir de Python 3.3, esto es equivalente a `os.chdir(fd)`.

  Lanza un evento de auditoría `os.chdir` con argumento `path`.

  Disponibilidad: Unix.

`os.``getcwd`()

  Retorna una cadena que representa el directorio de trabajo actual.

`os.``getcwdb`()

  Retorna una cadena de bytes que representa el directorio de trabajo actual.

  Distinto en la versión 3.8: La función ahora usa la codificación UTF-8 en Windows, en lugar de los códigos ANSI: consulte PEP 529 para ver la justificación. La función ya no está en desuso en Windows.

`os.``lchflags`(path, flags)

  Establece las flags de path a las flags numéricas, como `chflags()`, pero no siga los enlaces simbólicos. A partir de Python 3.3, esto es equivalente a `os.chflags(path, flags, follow_symlinks=False)`.

  Lanza un evento de auditoría `os.chflags` con argumentos `path`, `flags`.

  Disponibilidad: Unix.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``lchmod`(path, mode)

  Cambia el modo de path al mode numérico. Si la ruta es un enlace simbólico, esto afecta al enlace simbólico en lugar del objetivo. Consulte los documentos para `chmod()` para conocer los posibles valores de mode. A partir de Python 3.3, esto es equivalente a `os.chmod(path, mode, follow_symlinks=False)`.

  Lanza un evento de auditoría `os.chmod` con argumentos `path`, `mode`, `dir_fd`.

  Disponibilidad: Unix.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``lchown`(path, uid, gid)

  Cambia el propietario y la identificación del grupo de path a los numéricos uid y gid. Esta función no seguirá enlaces simbólicos. A partir de Python 3.3, esto es equivalente a `os.chown(path, uid, gid, follow_symlinks=False)`.

  Lanza un evento de auditoría `os.chown` con argumentos `path`, `uid`, `gid`, `dir_fd`.

  Disponibilidad: Unix.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``link`(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)

  Cree un enlace rígido que apunte a src llamado dst.

  Esta función puede admitir la especificación de src_dir_fd o dst_dir_fd para proporcionar rutas relativas a los descriptores de directorio, y no sigue enlaces simbólicos.

  Lanza un evento de auditoría `os.link` con argumentos `src`, `dst`, `src_dir_fd`, `dst_dir_fd`.

  Disponibilidad: Unix, Windows.

  Distinto en la versión 3.2: Se agregó soporte para Windows.

  Nuevo en la versión 3.3: Se agregaron los argumentos src_dir_fd, dst_dir_fd y follow_symlinks.

  Distinto en la versión 3.6: Acepta un path-like object para src y dst.

`os.``listdir`(path='.')

  Retorna una lista que contiene los nombres de las entradas en el directorio dado por path. La lista está en un orden arbitrario y no incluye las entradas especiales `'.'` Y `'..'` incluso si están presentes en el directorio. Si un archivo es removido de o añadido al directorio mientras se llama a esta función, no se especifica si el nombre para el archivo será incluido.

  path puede ser un path-like object. Si path es de tipo `bytes` (directa o indirectamente a través de la interfaz `PathLike`), los nombres de archivo retornados también serán de tipo `bytes`; en todas las demás circunstancias, serán del tipo `str`.

  Esta función también puede admitir especificando un descriptor de archivo; el descriptor de archivo debe hacer referencia a un directorio.

  Lanza un evento de auditoría `os.listdir` con el argumento `ruta`.

  Nota

  Para codificar los nombres de archivo `str` en `bytes`, use `fsencode()`.

  Ver también

  La función `scandir()` retorna entradas de directorio junto con información de atributos de archivo, lo que proporciona un mejor rendimiento para muchos casos de uso comunes.

  Distinto en la versión 3.2: El parámetro path se convirtió en opcional.

  Nuevo en la versión 3.3: Se agregó soporte para especificar path como un descriptor de archivo abierto.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``lstat`(path, *, dir_fd=None)

  Realice el equivalente de una llamada al sistema `lstat()` en la ruta dada. Similar a `stat()`, pero no sigue enlaces simbólicos. Retorna un objeto `stat_result`.

  En plataformas que no admiten enlaces simbólicos, este es un alias para `stat()`.

  A partir de Python 3.3, esto es equivalente a `os.stat(path, dir_fd=dir_fd, follow_symlinks=False)`.

  Esta función también puede admitir rutas relativas a descriptores de directorio.

  Ver también

  La función `stat()`.

  Distinto en la versión 3.2: Se agregó soporte para enlaces simbólicos de Windows 6.0 (Vista).

  Distinto en la versión 3.3: Se agregó el parámetro dir_fd.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

  Distinto en la versión 3.8: En Windows, ahora abre puntos de análisis que representan otra ruta (nombres sustitutos), incluidos enlaces simbólicos y uniones de directorio. El sistema operativo resuelve otros tipos de puntos de análisis como `stat()`.

`os.``mkdir`(path, mode=0o777, *, dir_fd=None)

  Cree un directorio llamado path con modo numérico mode.

  If the directory already exists, `FileExistsError` is raised. If a parent directory in the path does not exist, `FileNotFoundError` is raised.

  En algunos sistemas, mode se ignora. Donde se usa, el valor actual de umask se enmascara primero. Si se establecen bits distintos de los últimos 9 (es decir, los últimos 3 dígitos de la representación octal del mode), su significado depende de la plataforma. En algunas plataformas, se ignoran y debe llamar a `chmod()` explícitamente para configurarlos.

  Esta función también puede admitir rutas relativas a descriptores de directorio.

  También es posible crear directorios temporales; vea la función `tempfile` del módulo `tempfile.mkdtemp()`.

  Lanza un evento de auditoría `os.mkdir` con argumentos `ruta`, `modo`, `dir_fd`.

  Nuevo en la versión 3.3: El argumento dir_fd.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``makedirs`(name, mode=0o777, exist_ok=False)

  Función de creación de directorio recursiva. Como `mkdir()`, pero hace que todos los directorios de nivel intermedio sean necesarios para contener el directorio hoja.

  El parámetro mode se pasa a `mkdir()` para crear el directorio hoja; ver la descripción de mkdir() por cómo se interpreta. Para configurar los bits de permiso de archivo de cualquier directorio padre recién creado, puede configurar la umask antes de invocar `makedirs()`. Los bits de permiso de archivo de los directorios principales existentes no se modifican.

  Si exist_ok es `False` (el valor predeterminado), se genera un `FileExistsError` si el directorio de destino ya existe.

  Nota

  `makedirs()` se confundirá si los elementos de ruta a crear incluyen `pardir` (por ejemplo, «..» en sistemas UNIX).

  Esta función maneja las rutas UNC correctamente.

  Lanza un evento de auditoría `os.mkdir` con argumentos `ruta`, `modo`, `dir_fd`.

  Nuevo en la versión 3.2: El parámetro exist_ok.

  Distinto en la versión 3.4.1: Antes de Python 3.4.1, si exist_ok era `True` y el directorio existía, `makedirs()` aún generaría un error si mode no coincidía con el modo del directorio existente. Como este comportamiento era imposible de implementar de forma segura, se eliminó en Python 3.4.1. Ver bpo-21082.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

  Distinto en la versión 3.7: El argumento mode ya no afecta los bits de permiso de archivo de los directorios de nivel intermedio recién creados.

`os.``mkfifo`(path, mode=0o666, *, dir_fd=None)

  Cree una FIFO (una tubería con nombre) llamada path con modo numérico modo. El valor actual de umask se enmascara primero del modo.

  Esta función también puede admitir rutas relativas a descriptores de directorio.

  Los FIFO son tuberías a las que se puede acceder como archivos normales. Los FIFO existen hasta que se eliminan (por ejemplo con `os.unlink()`). En general, los FIFO se utilizan como punto de encuentro entre los procesos de tipo «cliente» y «servidor»: el servidor abre el FIFO para leer y el cliente lo abre para escribir. Tenga en cuenta que `mkfifo()` no abre el FIFO — solo crea el punto de encuentro.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3: El argumento dir_fd.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``mknod`(path, mode=0o600, device=0, *, dir_fd=None)

  Cree un nodo del sistema de archivos (archivo, archivo especial del dispositivo o canalización con nombre) llamado path. mode especifica tanto los permisos para usar como el tipo de nodo que se creará, combinándose (OR bit a bit) con uno de `stat.S_IFREG`, `stat.S_IFCHR`, `stat.S_IFBLK` , y `stat.S_IFIFO` (esas constantes están disponibles en `stat`). Para `stat.S_IFCHR` y `stat.S_IFBLK`, device define el archivo especial del dispositivo recién creado (probablemente usando `os.makedev()`), de lo contrario se ignora.

  Esta función también puede admitir rutas relativas a descriptores de directorio.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3: El argumento dir_fd.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``major`(device)

  Extrae el número principal del dispositivo de un número de dispositivo sin formato (generalmente el campo `st_dev` o `st_rdev` de `stat`).

`os.``minor`(device)

  Extrae el número menor del dispositivo de un número de dispositivo sin formato (generalmente el campo `st_dev` o `st_rdev` de `stat`).

`os.``makedev`(major, minor)

  Compone un número de dispositivo sin procesar a partir de los números de dispositivo mayor y menor.

`os.``pathconf`(path, name)

  Retorna información de configuración del sistema relevante para un archivo con nombre. name especifica el valor de configuración para recuperar; puede ser una cadena que es el nombre de un valor de sistema definido; Estos nombres se especifican en varios estándares (POSIX.1, Unix 95, Unix 98 y otros). Algunas plataformas también definen nombres adicionales. Los nombres conocidos por el sistema operativo host se dan en el diccionario `pathconf_names`. Para las variables de configuración no incluidas en esa asignación, también se acepta pasar un número entero para name.

  Si name es una cadena y no se conoce, se lanza un `ValueError`. Si el sistema anfitrión no admite un valor específico para name, incluso si está incluido en `pathconf_names`, se genera un `OSError` con `errno.EINVAL` para el número de error.

  Esta función puede soportar especificando un descriptor de archivo.

  Disponibilidad: Unix.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``pathconf_names`

  Nombres de mapeo de diccionario aceptados por `pathconf()` y `fpathconf()` a los valores enteros definidos para esos nombres por el sistema operativo host. Esto se puede usar para determinar el conjunto de nombres conocidos por el sistema.

  Disponibilidad: Unix.

`os.``readlink`(path, *, dir_fd=None)

  Retorna una cadena que representa la ruta a la que apunta el enlace simbólico. El resultado puede ser un nombre de ruta absoluto o relativo; si es relativo, se puede convertir a un nombre de ruta absoluto usando `os.path.join(os.path.dirname(path), result)`.

  Si la path es un objeto de cadena (directa o indirectamente a través de una interfaz `PathLike`), el resultado también será un objeto de cadena y la llamada puede generar un UnicodeDecodeError. Si la path es un objeto de bytes (directa o indirectamente), el resultado será un objeto de bytes.

  Esta función también puede admitir rutas relativas a descriptores de directorio.

  Cuando intente resolver una ruta que puede contener enlaces, use `realpath()` para manejar adecuadamente la recurrencia y las diferencias de plataforma.

  Disponibilidad: Unix, Windows.

  Distinto en la versión 3.2: Se agregó soporte para enlaces simbólicos de Windows 6.0 (Vista).

  Nuevo en la versión 3.3: El argumento dir_fd.

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

  Distinto en la versión 3.8: Acepta un path-like object y un objeto de bytes en Windows.

  Distinto en la versión 3.8: Se agregó soporte para uniones de directorio y se modificó para retornar la ruta de sustitución (que generalmente incluye el prefijo `\\?\`) En lugar del campo opcional «nombre de impresión» que se retornó anteriormente.

`os.``remove`(path, *, dir_fd=None)

  Remove (delete) the file path. If path is a directory, an `IsADirectoryError` is raised. Use `rmdir()` to remove directories. If the file does not exist, a `FileNotFoundError` is raised.

  Esta función puede admitir rutas relativas a descriptores de directorio.

  En Windows, intentar eliminar un archivo que está en uso provoca una excepción; en Unix, la entrada del directorio se elimina pero el almacenamiento asignado al archivo no está disponible hasta que el archivo original ya no esté en uso.

  Esta función es semánticamente idéntica a `unlink()`.

  Lanza un evento de auditoría `os.remove` con argumentos `ruta`, `dir_fd`.

  Nuevo en la versión 3.3: El argumento dir_fd.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``removedirs`(name)

  Eliminar directorios de forma recursiva. Funciona como `rmdir()` excepto que, si el directorio hoja se elimina con éxito, `removeirs()` intenta eliminar sucesivamente cada directorio principal mencionado en path hasta que se genere un error (que se ignora, porque generalmente significa que un directorio padre no está vacío). Por ejemplo, `os.removedirs('foo/bar/baz')` primero eliminará el directorio `'foo/bar/baz'`, y luego eliminará `'foo/bar'` y `'foo'` si están vacíos. Genera `OSError` si el directorio hoja no se pudo eliminar con éxito.

  Lanza un evento de auditoría `os.remove` con argumentos `ruta`, `dir_fd`.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``rename`(src, dst, *, src_dir_fd=None, dst_dir_fd=None)

  Cambia el nombre del archivo o directorio src a dst. Si dst existe, la operación fallará con una subclase `OSError` en varios casos:

  En Windows, si dst existe a `FileExistsError` siempre se genera.

  En Unix, si src es un archivo y dst es un directorio o viceversa, se generará un `IsADirectoryError` o un `NotADirectoryError` respectivamente. Si ambos son directorios y dst está vacío, dst será reemplazado silenciosamente. Si dst es un directorio no vacío, se genera un `OSError`. Si ambos son archivos, dst se reemplazará en silencio si el usuario tiene permiso. La operación puede fallar en algunos sabores de Unix si src y dst están en diferentes sistemas de archivos. Si tiene éxito, el cambio de nombre será una operación atómica (este es un requisito POSIX).

  Esta función puede admitir la especificación de src_dir_fd o dst_dir_fd para proporcionar rutas relativas a los descriptores de directorio.

  Si desea sobrescribir multiplataforma del destino, use `replace()`.

  Lanza un evento de auditoría `os.rename` con argumentos `src`, `dst`, `src_dir_fd`, `dst_dir_fd`.

  Nuevo en la versión 3.3: Los argumentos src_dir_fd y dst_dir_fd.

  Distinto en la versión 3.6: Acepta un path-like object para src y dst.

`os.``renames`(old, new)

  Directorio recursivo o función de cambio de nombre de archivo. Funciona como `rename()`, excepto que primero se intenta crear cualquier directorio intermedio necesario para que el nuevo nombre de ruta sea bueno. Después del cambio de nombre, los directorios correspondientes a los segmentos de ruta más a la derecha del nombre anterior se eliminarán usando `removeirs()`.

  Nota

  Esta función puede fallar con la nueva estructura de directorios realizada si carece de los permisos necesarios para eliminar el directorio o archivo hoja.

  Lanza un evento de auditoría `os.rename` con argumentos `src`, `dst`, `src_dir_fd`, `dst_dir_fd`.

  Distinto en la versión 3.6: Acepta un path-like object para old y new.

`os.``replace`(src, dst, *, src_dir_fd=None, dst_dir_fd=None)

  Rename the file or directory src to dst. If dst is a non-empty directory, `OSError` will be raised. If dst exists and is a file, it will be replaced silently if the user has permission. The operation may fail if src and dst are on different filesystems. If successful, the renaming will be an atomic operation (this is a POSIX requirement).

  Esta función puede admitir la especificación de src_dir_fd o dst_dir_fd para proporcionar rutas relativas a los descriptores de directorio.

  Lanza un evento de auditoría `os.rename` con argumentos `src`, `dst`, `src_dir_fd`, `dst_dir_fd`.

  Nuevo en la versión 3.3.

  Distinto en la versión 3.6: Acepta un path-like object para src y dst.

`os.``rmdir`(path, *, dir_fd=None)

  Elimina (delete) el directorio path. Si el directorio no existe o no está vacío, se genera un `FileNotFoundError` o un `OSError` respectivamente. Para eliminar árboles de directorios completos, se puede usar `shutil.rmtree()`.

  Esta función puede admitir rutas relativas a descriptores de directorio.

  Lanza un evento de auditoría `os.rmdir` con argumentos `ruta`, `dir_fd`.

  Nuevo en la versión 3.3: El parámetro dir_fd.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``scandir`(path='.')

  Retorna un iterador de objetos `os.DirEntry` correspondientes a las entradas en el directorio dado por path. Las entradas se entregan en orden arbitrario, y las entradas especiales `'.'` Y `'..'` no están incluidas. Si un archivo es removido de o añadido al directorio después de crear el iterador, no se especifica si una entrada para el archivo será incluido.

  El uso de `scandir()` en lugar de `listdir()` puede aumentar significativamente el rendimiento del código que también necesita información de tipo de archivo o atributo de archivo, porque: los objetos `os.DirEntry` exponen esta información si el sistema operativo proporciona cuando escanea un directorio. Todos los métodos `os.DirEntry` pueden realizar una llamada al sistema, pero `is_dir()` y `is_file()` generalmente solo requieren una llamada al sistema para enlaces simbólicos; `os.DirEntry.stat()` siempre requiere una llamada al sistema en Unix, pero solo requiere una para enlaces simbólicos en Windows.

  path puede ser un path-like object. Si path es de tipo `bytes` (directa o indirectamente a través de la interfaz `PathLike`), el tipo de `name` y los atributos `path` de cada `os.DirEntry` serán `bytes`; en todas las demás circunstancias, serán del tipo `str`.

  Esta función también puede admitir especificando un descriptor de archivo; el descriptor de archivo debe hacer referencia a un directorio.

  Lanza un evento de auditoría `os.scandir` con argumento `ruta`.

  El iterador `scandir()` admite el protocolo context manager y tiene el siguiente método:

  `scandir.``close`()

    Cierre el iterador y libere los recursos adquiridos.

    Esto se llama automáticamente cuando el iterador se agota o se recolecta basura, o cuando ocurre un error durante la iteración. Sin embargo, es aconsejable llamarlo explícitamente o utilizar la palabra clave `with`.

    Nuevo en la versión 3.6.

  El siguiente ejemplo muestra un uso simple de `scandir()` para mostrar todos los archivos (excepto los directorios) en la path dada que no comienzan con `'.'`. La llamada `entry.is_file()` generalmente no realizará una llamada adicional al sistema:

      with os.scandir(path) as it:
          for entry in it:
              if not entry.name.startswith('.') and entry.is_file():
                  print(entry.name)

  Nota

  En sistemas basados en Unix, `scandir()` usa el opendir() del sistema y readdir() funciones. En Windows, utiliza el Win32 FindFirstFileW y FindNextFileW funciones.

  Nuevo en la versión 3.5.

  Nuevo en la versión 3.6: Se agregó soporte para el protocolo context manager y el método `close()`. Si un iterador `scandir()` no está agotado ni cerrado explícitamente, se emitirá a `ResourceWarning` en su destructor.

  La función acepta un path-like object.

  Distinto en la versión 3.7: Soporte agregado para descriptores de archivo en Unix.

class `os.``DirEntry`

  Objeto generado por `scandir()` para exponer la ruta del archivo y otros atributos de archivo de una entrada de directorio.

  `scandir()` proporcionará tanta información como sea posible sin hacer llamadas adicionales al sistema. Cuando se realiza una llamada al sistema `stat()` o `lstat()`, el objeto `os.DirEntry` almacenará en caché el resultado.

  Las instancias `os.DirEntry` no están destinadas a ser almacenadas en estructuras de datos de larga duración; si sabe que los metadatos del archivo han cambiado o si ha transcurrido mucho tiempo desde la llamada `scandir()`, llame a `os.stat(entry.path)` para obtener información actualizada.

  Debido a que los métodos `os.DirEntry` pueden hacer llamadas al sistema operativo, también pueden generar `OSError`. Si necesita un control muy preciso sobre los errores, puede detectar `OSError` cuando llame a uno de los métodos `os.DirEntry` y maneje según corresponda.

  Para ser directamente utilizable como path-like object, `os.DirEntry` implementa la interfaz `PathLike`.

  Los atributos y métodos en una instancia de `os.DirEntry` son los siguientes:

  `name`

    El nombre de archivo base de la entrada, relativo al argumento `scandir()` path.

    El atributo `name` será `bytes` si el argumento `scandir()` path es de tipo `bytes` y `str` de lo contrario. Utilice `fsdecode()` para decodificar los nombres de archivo de bytes.

  `path`

    El nombre completo de la ruta de entrada: equivalente a `os.path.join(scandir_path, entry.name)` donde scandir_path es el argumento `scandir()` path. La ruta solo es absoluta si el argumento `scandir()` path fue absoluto. Si el argumento `scandir()` path era un descriptor de archivo, el atributo `path` es el mismo que el atributo `name`.

    El atributo `path` será `bytes` si el argumento `scandir()` path es de tipo `bytes` y `str` de lo contrario. Utilice `fsdecode()` para decodificar los nombres de archivo de bytes.

  `inode`()

    Retorna el número de inodo de la entrada.

    El resultado se almacena en caché en el objeto `os.DirEntry`. Use `os.stat(entry.path, follow_symlinks=False).st_ino` para obtener información actualizada.

    En la primera llamada no almacenada en caché, se requiere una llamada del sistema en Windows pero no en Unix.

  `is_dir`(*, follow_symlinks=True)

    Retorna `True` si esta entrada es un directorio o un enlace simbólico que apunta a un directorio; retorna `False` si la entrada es o apunta a cualquier otro tipo de archivo, o si ya no existe.

    Si follow_symlinks es `False`, retorna `True` solo si esta entrada es un directorio (sin seguir los enlaces simbólicos); retorna `False` si la entrada es cualquier otro tipo de archivo o si ya no existe.

    El resultado se almacena en caché en el objeto `os.DirEntry`, con un caché separado para follow_symlinks `True` y `False`. Llame a `os.stat()` junto con `stat.S_ISDIR()` para obtener información actualizada.

    En la primera llamada no almacenada en caché, no se requiere ninguna llamada al sistema en la mayoría de los casos. Específicamente, para los enlaces no simbólicos, ni Windows ni Unix requieren una llamada al sistema, excepto en ciertos sistemas de archivos Unix, como los sistemas de archivos de red, que retornan `dirent.d_type == DT_UNKNOWN`. Si la entrada es un enlace simbólico, se requerirá una llamada al sistema para seguir el enlace simbólico a menos que follow_symlinks sea `False`.

    Este método puede generar `OSError`, como `PermissionError`, pero `FileNotFoundError` se captura y no se genera.

  `is_file`(*, follow_symlinks=True)

    Retorna `True` si esta entrada es un archivo o un enlace simbólico que apunta a un archivo; retorna `False` si la entrada es o apunta a un directorio u otra entrada que no sea de archivo, o si ya no existe.

    Si follow_symlinks es `False`, retorna `True` solo si esta entrada es un archivo (sin los siguientes enlaces simbólicos); retorna `False` si la entrada es un directorio u otra entrada que no sea de archivo, o si ya no existe.

    El resultado se almacena en caché en el objeto `os.DirEntry`. El almacenamiento en caché, las llamadas realizadas al sistema y las excepciones generadas son las siguientes `is_dir()`.

  `is_symlink`()

    Retorna `True` si esta entrada es un enlace simbólico (incluso si está roto); retorna `False` si la entrada apunta a un directorio o cualquier tipo de archivo, o si ya no existe.

    El resultado se almacena en caché en el objeto `os.DirEntry`. Llame a `os.path.islink()` para obtener información actualizada.

    En la primera llamada no almacenada en caché, no se requiere ninguna llamada al sistema en la mayoría de los casos. Específicamente, ni Windows ni Unix requieren una llamada al sistema, excepto en ciertos sistemas de archivos Unix, como los sistemas de archivos de red, que retornan `dirent.d_type == DT_UNKNOWN`.

    Este método puede generar `OSError`, como `PermissionError`, pero `FileNotFoundError` se captura y no se genera.

  `stat`(*, follow_symlinks=True)

    Retorna un objeto a `stat_result` para esta entrada. Este método sigue enlaces simbólicos por defecto; para crear un enlace simbólico agregue el argumento `follow_symlinks=False`.

    En Unix, este método siempre requiere una llamada al sistema. En Windows, solo requiere una llamada al sistema si follow_symlinks es `True` y la entrada es un punto de análisis (por ejemplo, un enlace simbólico o una unión de directorio).

    En Windows, los atributos `st_ino`, `st_dev` y `st_nlink` de `stat_result` siempre se establecen en cero. Llame a `os.stat()` para obtener estos atributos.

    El resultado se almacena en caché en el objeto `os.DirEntry`, con un caché separado para follow_symlinks `True` y `False`. Llame a `os.stat()` para obtener información actualizada.

  Tenga en cuenta que existe una buena correspondencia entre varios atributos y métodos de `os.DirEntry` y de `pathlib.Path`. En particular, el atributo `name` tiene el mismo significado, al igual que los métodos `is_dir()`, `is_file()`, `is_symlink()` y `stat()`.

  Nuevo en la versión 3.5.

  Distinto en la versión 3.6: Se agregó soporte para la interfaz `PathLike`. Se agregó soporte para rutas de `bytes` en Windows.

`os.``stat`(path, *, dir_fd=None, follow_symlinks=True)

  Obtener el estado de un archivo o un descriptor de archivo. Realice el equivalente de a llamada del sistema `stat()` en la ruta dada. path puede especificarse como una cadena o bytes, directa o indirectamente a través de la interfaz `PathLike`, o como un descriptor de archivo abierto. Retorna un objeto `stat_result`.

  Esta función normalmente sigue enlaces simbólicos; para crear un enlace simbólico agregue el argumento `follow_symlinks=False`, o use `lstat()`.

  Esta función puede soportar especificando un descriptor de archivo y no siguen enlaces simbólicos.

  En Windows, pasar `follow_symlinks=False` deshabilitará el seguimiento de todos los puntos de análisis sustitutos de nombre, que incluyen enlaces simbólicos y uniones de directorio. Se abrirán directamente otros tipos de puntos de análisis que no se parecen a los enlaces o que el sistema operativo no puede seguir. Al seguir una cadena de enlaces múltiples, esto puede dar como resultado que se retorna el enlace original en lugar del no enlace que impidió el recorrido completo. Para obtener resultados estadísticos para la ruta final en este caso, use la función `os.path.realpath()` para resolver el nombre de la ruta lo más posible y llame a `lstat()` en el resultado. Esto no se aplica a enlaces simbólicos o puntos de unión colgantes, lo que generará las excepciones habituales.

  El diseño de todos los módulos incorporados de Python dependientes del sistema operativo es tal que, mientras funcionalidad esté disponible, usará la misma interfaz; por ejemplo, la función `os.stat(path)` retorna estadísticas sobre la ruta (path) en el mismo formato (lo que sucede originalmente con la interfaz POSIX).

      >>> import os
      >>> statinfo = os.stat('somefile.txt')
      >>> statinfo
      os.stat_result(st_mode=33188, st_ino=7876932, st_dev=234881026,
      st_nlink=1, st_uid=501, st_gid=501, st_size=264, st_atime=1297230295,
      st_mtime=1297230027, st_ctime=1297230027)
      >>> statinfo.st_size
      264

  Ver también

  `fstat()` y funciones `lstat()`.

  Nuevo en la versión 3.3: Se agregaron los argumentos dir_fd y follow_symlinks, especificando un descriptor de archivo en lugar de una ruta.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

  Distinto en la versión 3.8: En Windows, ahora se siguen todos los puntos de análisis que el sistema operativo puede resolver, y pasar `follow_symlinks=False` desactiva los siguientes puntos de análisis sustitutos de nombre. Si el sistema operativo alcanza un punto de análisis que no puede seguir, stat ahora retorna la información de la ruta original como si se hubiera especificado `follow_symlinks=False` en lugar de generar un error.

class `os.``stat_result`

  Objeto cuyos atributos corresponden aproximadamente a los miembros de la estructura `stat`. Se utiliza para el resultado de `os.stat()`, `os.fstat()` y `os.lstat()`.

  Atributos:

  `st_mode`

    Modo de archivo: tipo de archivo y bits de modo de archivo (permisos).

  `st_ino`

    Dependiendo de la plataforma, pero si no es cero, identifica de forma exclusiva el archivo para un valor dado de `st_dev`. Típicamente:

    - el número de inodo en Unix,

    - el índice del archivo <https://msdn.microsoft.com/en-us/library/aa363788>`_ en Windows

  `st_dev`

    Identificador del dispositivo en el que reside este archivo.

  `st_nlink`

    Número de enlaces duros.

  `st_uid`

    Identificador de usuario del propietario del archivo.

  `st_gid`

    Identificador de grupo del propietario del archivo.

  `st_size`

    Tamaño del archivo en bytes, si es un archivo normal o un enlace simbólico. El tamaño de un enlace simbólico es la longitud del nombre de ruta que contiene, sin un byte nulo de terminación.

  Marcas de tiempo:

  `st_atime`

    Tiempo de acceso más reciente expresado en segundos.

  `st_mtime`

    Tiempo de modificación de contenido más reciente expresado en segundos.

  `st_ctime`

    Depende de la plataforma:

    - el momento del cambio de metadatos más reciente en Unix,

    - el tiempo de creación en Windows, expresado en segundos.

  `st_atime_ns`

    Tiempo de acceso más reciente expresado en nanosegundos como un entero.

  `st_mtime_ns`

    Hora de la modificación de contenido más reciente expresada en nanosegundos como un entero.

  `st_ctime_ns`

    Depende de la plataforma:

    - el momento del cambio de metadatos más reciente en Unix,

    - el tiempo de creación en Windows, expresado en nanosegundos como un entero.

  Nota

  El significado exacto y la resolución de los atributos `st_atime`, `st_mtime` y `st_ctime` dependen del sistema operativo y del sistema de archivos. Por ejemplo, en sistemas Windows que utilizan los sistemas de archivos FAT o FAT32, `st_mtime` tiene una resolución de 2 segundos y `st_atime` tiene una resolución de solo 1 día. Consulte la documentación de su sistema operativo para más detalles.

  De manera similar, aunque `st_atime_ns`, `st_mtime_ns` y `st_ctime_ns` siempre se expresan en nanosegundos, muchos sistemas no proporcionan precisión en nanosegundos. En los sistemas que proporcionan precisión en nanosegundos, el objeto de punto flotante utilizado para almacenar `st_atime`, `st_mtime`, y `st_ctime` no puede preservarlo todo, y como tal será ligeramente inexacto . Si necesita las marcas de tiempo exactas, siempre debe usar `st_atime_ns`, `st_mtime_ns` y `st_ctime_ns`.

  En algunos sistemas Unix (como Linux), los siguientes atributos también pueden estar disponibles:

  `st_blocks`

    Número de bloques de 512 bytes asignados para el archivo. Esto puede ser más pequeño que `st_size` / 512 cuando el archivo tiene agujeros.

  `st_blksize`

    Tamaño de bloque «preferido» para una eficiente E / S del sistema de archivos. Escribir en un archivo en fragmentos más pequeños puede causar una lectura-modificación-reescritura ineficiente.

  `st_rdev`

    Tipo de dispositivo si es un dispositivo inodo.

  `st_flags`

    Indicadores definidos por el usuario para el archivo.

  En otros sistemas Unix (como FreeBSD), los siguientes atributos pueden estar disponibles (pero solo se pueden completar si la raíz intenta usarlos):

  `st_gen`

    Número de generación de archivos.

  `st_birthtime`

    Hora de creación del archivo.

  En Solaris y derivados, los siguientes atributos también pueden estar disponibles:

  `st_fstype`

    Cadena que identifica de forma exclusiva el tipo de sistema de archivos que contiene el archivo.

  On macOS systems, the following attributes may also be available:

  `st_rsize`

    Tamaño real del archivo.

  `st_creator`

    Creador del archivo.

  `st_type`

    Tipo de archivo.

  En los sistemas Windows, los siguientes atributos también están disponibles:

  `st_file_attributes`

    Atributos del archivo de Windows: miembro `dwFileAttributes` de la estructura `BY_HANDLE_FILE_INFORMATION` retornado por `GetFileInformationByHandle()`. Vea las constantes `FILE_ATTRIBUTE_*` en el módulo `stat`.

  `st_reparse_tag`

    Cuando `st_file_attributes` tiene el conjunto` FILE_ATTRIBUTE_REPARSE_POINT`, este campo contiene la etiqueta que identifica el tipo de punto de análisis. Vea las constantes `IO_REPARSE_TAG_*` en el módulo `stat`.

  El módulo estándar `stat` define funciones y constantes que son útiles para extraer información de la estructura a `stat`. (En Windows, algunos elementos están llenos de valores ficticios).

  Para compatibilidad con versiones anteriores, una instancia de `stat_result` también es accesible como una tupla de al menos 10 enteros que dan los miembros más importantes (y portátiles) de la estructura `stat`, en el orden `st_mode`, `st_ino`, `st_dev`, `st_nlink`, `st_uid`, `st_gid`, `st_size`, `st_atime`, `st_mtime`, `st_ctime`. Algunas implementaciones pueden agregar más elementos al final. Para compatibilidad con versiones anteriores de Python, acceder a `stat_result` como una tupla siempre retorna enteros.

  Nuevo en la versión 3.3: Se agregaron los miembros `st_atime_ns`, `st_mtime_ns` y `st_ctime_ns`.

  Nuevo en la versión 3.5: Se agregó el miembro `st_file_attributes` en Windows.

  Distinto en la versión 3.5: Windows ahora retorna el índice del archivo como `st_ino` cuando está disponible.

  Nuevo en la versión 3.7: Se agregó el miembro `st_fstype` a Solaris/derivados.

  Nuevo en la versión 3.8: Se agregó el miembro `st_reparse_tag` en Windows.

  Distinto en la versión 3.8: En Windows, el miembro `st_mode` ahora identifica archivos especiales como `S_IFCHR`, `S_IFIFO` o `S_IFBLK` según corresponda.

`os.``statvfs`(path)

  Realice una llamada al sistema a `statvfs()` en la ruta dada. El valor de retorno es un objeto cuyos atributos describen el sistema de archivos en la ruta dada y corresponden a los miembros de la estructura `statvfs`, a saber: `f_bsize`, `f_frsize`, `f_blocks`, `f_bfree`, `f_bavail`, `f_files`, `f_ffree`, `f_favail`, `f_flag`, `f_namemax`, `f_fsid`.

  Se definen dos constantes de nivel de módulo para: indicadores de bit del atributo `f_flag`: si `ST_RDONLY` está configurado, el sistema de archivos está montado de solo lectura, y si `ST_NOSUID` está configurado, el la semántica de los bits setuid/setgid está deshabilitada o no es compatible.

  Se definen constantes de nivel de módulo adicionales para sistemas basados en GNU / glibc. Estos son `ST_NODEV` (no permitir el acceso a archivos especiales del dispositivo), `ST_NOEXEC` (no permitir la ejecución del programa), `ST_SYNCHRONOUS` (las escrituras se sincronizan a la vez), `ST_MANDLOCK` ( permitir bloqueos obligatorios en un FS), `ST_WRITE` (escribir en el archivo/directorio/enlace simbólico), `ST_APPEND` (archivo de solo agregado), `ST_IMMUTABLE` (archivo inmutable), `ST_NOATIME` (no actualiza los tiempos de acceso), `ST_NODIRATIME` (no actualiza los tiempos de acceso al directorio), `ST_RELATIME` (tiempo de actualización relativo a mtime/ctime).

  Esta función puede soportar especificando un descriptor de archivo.

  Disponibilidad: Unix.

  Distinto en la versión 3.2: Se agregaron las constantes `ST_RDONLY` y `ST_NOSUID`.

  Nuevo en la versión 3.3: Se agregó soporte para especificar path como un descriptor de archivo abierto.

  Distinto en la versión 3.4: El `ST_NODEV`, `ST_NOEXEC`, `ST_SYNCHRONOUS`, `ST_MANDLOCK`, `ST_WRITE`, `ST_APPEND`, `ST_IMMUTABLE`, `ST_NOATIME`, `ST_NODIRATIME`, y `ST_RELATIME` se agregaron constantes.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

  Nuevo en la versión 3.7: Agregado `f_fsid`.

`os.``supports_dir_fd`

  A objeto `set` que indica qué funciones en el módulo `os` aceptan un descriptor de archivo abierto para su parámetro dir_fd. Las diferentes plataformas proporcionan características diferentes, y la funcionalidad subyacente que Python usa para implementar el parámetro dir_fd no está disponible en todas las plataformas que admite Python. En aras de la coherencia, las funciones que pueden admitir dir_fd siempre permiten especificar el parámetro, pero generarán una excepción si la funcionalidad se utiliza cuando no está disponible localmente. (Especificar `None` para dir_fd siempre es compatible con todas las plataformas).

  Para verificar si una función particular acepta un descriptor de archivo abierto para su parámetro dir_fd, use el operador `in` en `supports_dir_fd`. Como ejemplo, esta expresión se evalúa como `True` si `os.stat()` acepta descriptores de archivos abiertos para dir_fd en la plataforma local:

      os.stat in os.supports_dir_fd

  Actualmente, los parámetros dir_fd solo funcionan en plataformas Unix; ninguno de ellos funciona en Windows.

  Nuevo en la versión 3.3.

`os.``supports_effective_ids`

  Un objeto `set` que indica si `os.access()` permite especificar `True` para su parámetro fective_ids en la plataforma local. (Especificar `False` para effective_id siempre es compatible con todas las plataformas). Si la plataforma local lo admite, la colección contendrá `os.access()`; de lo contrario estará vacío.

  Esta expresión se evalúa como `True` si `os.access()` admite `effective_id=True` en la plataforma local:

      os.access in os.supports_effective_ids

  Actualmente, effective_ids solo es compatible con plataformas Unix; No funciona en Windows.

  Nuevo en la versión 3.3.

`os.``supports_fd`

  A objeto `set` que indica qué funciones en el módulo `os` permiten especificar su parámetro path como un descriptor de archivo abierto en la plataforma local. Las diferentes plataformas proporcionan características diferentes, y la funcionalidad subyacente que Python utiliza para aceptar descriptores de archivos abiertos como argumentos path no está disponible en todas las plataformas que admite Python.

  Para determinar si una función en particular permite especificar un descriptor de archivo abierto para su parámetro path, use el operador `in` en `supports_fd`. Como ejemplo, esta expresión se evalúa como `True` si `os.chdir()` acepta descriptores de archivo abiertos para path en su plataforma local:

      os.chdir in os.supports_fd

  Nuevo en la versión 3.3.

`os.``supports_follow_symlinks`

  Un objeto `set` que indica qué funciones en el módulo `os` aceptan `False` para su parámetro follow_symlinks en la plataforma local. Las diferentes plataformas proporcionan características diferentes, y la funcionalidad subyacente que Python usa para implementar follow_symlinks no está disponible en todas las plataformas que admite Python. En aras de la coherencia, las funciones que pueden admitir follow_symlinks siempre permiten especificar el parámetro, pero arrojarán una excepción si la funcionalidad se utiliza cuando no está disponible localmente. (Especificar `True` para follow_symlinks siempre se admite en todas las plataformas).

  Para verificar si una función particular acepta `False` para su parámetro follow_symlinks, use el operador `in` en `supports_follow_symlinks`. Como ejemplo, esta expresión se evalúa como `True` si puede especificar `follow_symlinks=False` al llamar a `os.stat()` en la plataforma local:

      os.stat in os.supports_follow_symlinks

  Nuevo en la versión 3.3.

`os.``symlink`(src, dst, target_is_directory=False, *, dir_fd=None)

  Cree un enlace simbólico que apunte a src llamado dst.

  En Windows, un enlace simbólico representa un archivo o un directorio, y no se transforma dinámicamente en el destino. Si el objetivo está presente, el tipo de enlace simbólico se creará para que coincida. De lo contrario, el enlace simbólico se creará como un directorio si target_is_directory es `True` o un enlace simbólico de archivo (el valor predeterminado) de lo contrario. En plataformas que no son de Windows, target_is_directory se ignora.

  Esta función puede admitir rutas relativas a descriptores de directorio.

  Nota

  En las versiones más recientes de Windows 10, las cuentas sin privilegios pueden crear enlaces simbólicos si el Modo desarrollador está habilitado. Cuando el Modo desarrollador no está disponible / habilitado, se requiere el privilegio SeCreateSymbolicLinkPrivilege, o el proceso debe ejecutarse como administrador.

  `OSError` se lanza cuando un usuario sin privilegios llama a la función.

  Lanza un evento de auditoría `os.symlink` con argumentos `src`, `dst`, `dir_fd`.

  Disponibilidad: Unix, Windows.

  Distinto en la versión 3.2: Se agregó soporte para enlaces simbólicos de Windows 6.0 (Vista).

  Nuevo en la versión 3.3: Se agregó el argumento dir_fd y ahora permite target_is_directory en plataformas que no son de Windows.

  Distinto en la versión 3.6: Acepta un path-like object para src y dst.

  Distinto en la versión 3.8: Se agregó soporte para enlaces simbólicos sin elevar en Windows con el modo de desarrollador.

`os.``sync`()

  Forzar la escritura de todo en el disco.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``truncate`(path, length)

  Trunca el archivo correspondiente a path, para que tenga como máximo length bytes de tamaño.

  Esta función puede soportar especificando un descriptor de archivo.

  Lanza un evento de auditoría `os.truncate` con argumentos `path`, `length`.

  Disponibilidad: Unix, Windows.

  Nuevo en la versión 3.3.

  Distinto en la versión 3.5: Se agregó soporte para Windows

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``unlink`(path, *, dir_fd=None)

  Elimina (elimine) el archivo path. Esta función es semánticamente idéntica a `remove()`; El nombre `unlink` es su nombre tradicional de Unix. Consulte la documentación de `remove()` para obtener más información.

  Lanza un evento de auditoría `os.remove` con argumentos `ruta`, `dir_fd`.

  Nuevo en la versión 3.3: El parámetro dir_fd.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``utime`(path, times=None, *, [ns, ]dir_fd=None, follow_symlinks=True)

  Establece el acceso y los tiempos modificados del archivo especificado por path.

  `utime()` toma dos parámetros opcionales, times y ns. Estos especifican los tiempos establecidos en path y se utilizan de la siguiente manera:

  - Si se especifica ns, debe ser una tupla de 2 de la forma `(atime_ns, mtime_ns)` donde cada miembro es un int que expresa nanosegundos.

  - Si times no es `None`, debe ser una 2-tupla de la forma `(atime, mtime)` donde cada miembro es un int o flotante que expresa segundos.

  - Si times es `None` y ns no está especificado, esto es equivalente a especificar `ns=(atime_ns, mtime_ns)` donde ambas horas son la hora actual.

  Es un error especificar tuplas para times y ns.

  Tenga en cuenta que las horas exactas que establezca aquí pueden no ser retornadas por una llamada posterior `stat()`, dependiendo de la resolución con la que su sistema operativo registre los tiempos de acceso y modificación; ver `stat()`. La mejor manera de preservar los tiempos exactos es usar los campos st_atime_ns y st_mtime_ns del objeto de resultado `os.stat()` con el parámetro ns para utime.

  Esta función puede soportar especificando un descriptor de archivo, rutas relativas a los descriptores de directorio y no seguir enlaces simbólicos.

  Lanza un evento de auditoría `os.utime` con argumentos `path`, `times`, `ns`, `dir_fd`.

  Nuevo en la versión 3.3: Se agregó soporte para especificar path como un descriptor de archivo abierto, y los parámetros dir_fd, follow_symlinks y ns.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``walk`(top, topdown=True, onerror=None, followlinks=False)

  Genere los nombres de archivo en un árbol de directorios recorriendo el árbol de arriba hacia abajo o de abajo hacia arriba. Para cada directorio en el árbol enraizado en el directorio top (incluido top), produce una tupla de 3 tuplas `(dirpath, dirnames, filenames)`.

  dirpath es una cadena, la ruta al directorio. dirnames es una lista de los nombres de los subdirectorios en dirpath (excluyendo `'.'` y `'..'`). filenames es una lista de los nombres de los archivos que no son un directorio en dirpath. Tenga en cuenta que los nombres en las listas no contienen componentes de ruta. Para obtener una ruta completa (que comienza con top) a un archivo o directorio en dirpath, haga `os.path.join(dirpath, name)`. El hecho de que las lista esta ordenada o no depende del sistema de archivos. Si un archivo es removido de o agregado al directorio dirpath mientras se generan las listas, no se especifica si el nombre para el archivo será incluido.

  Si el argumento opcional topdown es `True` o no se especifica, el triple para un directorio se genera antes de triplicarse para cualquiera de sus subdirectorios (los directorios se generan de arriba hacia abajo). Si topdown es `False`, el triple para un directorio se genera después de los triples para todos sus subdirectorios (los directorios se generan de abajo hacia arriba). No importa el valor de topdown, la lista de subdirectorios se recupera antes de que se generen las tuplas para el directorio y sus subdirectorios.

  Cuando topdown es `True`, la persona que llama puede modificar la lista dirnames en su lugar (quizás usando `del` o asignación de corte) y `walk()` solo se repetirá en los subdirectorios cuyos nombres permanecen en dirnames; Esto se puede utilizar para podar la búsqueda, imponer un orden específico de visitas o incluso para informar `walk()` sobre los directorios que la persona que llama crea o renombra antes de que se reanude `walk()` nuevamente. La modificación de dirnames cuando topdown es `False` no tiene ningún efecto en el comportamiento de la caminata, porque en el modo ascendente los directorios en dirnames se generan antes de que se genere dirpath.

  Por defecto, los errores de la llamada `scandir()` se ignoran. Si se especifica el argumento opcional onerror, debería ser una función; se llamará con un argumento, una instancia `OSError`. Puede informar el error para continuar con la caminata, o generar la excepción para abortar la caminata. Tenga en cuenta que el nombre de archivo está disponible como el atributo `filename` del objeto de excepción.

  Por defecto, `walk()` no entrará en enlaces simbólicos que se resuelven en directorios. Establece followlinks en `True` para visitar los directorios señalados por los enlaces simbólicos, en los sistemas que los admiten.

  Nota

  Tenga en cuenta que establecer followlinks en `True` puede conducir a una recursión infinita si un enlace apunta a un directorio padre de sí mismo. `walk()` no realiza un seguimiento de los directorios que ya visitó.

  Nota

  Si pasa un nombre de ruta relativo, no cambie el directorio de trabajo actual entre las reanudaciones de `walk()`. `walk()` nunca cambia el directorio actual, y supone que la persona que llama tampoco.

  Este ejemplo muestra el número de bytes que toman los archivos que no son de directorio en cada directorio bajo el directorio inicial, excepto que no se ve en ningún subdirectorio CVS:

      import os
      from os.path import join, getsize
      for root, dirs, files in os.walk('python/Lib/email'):
          print(root, "consumes", end=" ")
          print(sum(getsize(join(root, name)) for name in files), end=" ")
          print("bytes in", len(files), "non-directory files")
          if 'CVS' in dirs:
              dirs.remove('CVS')  # don't visit CVS directories

  En el siguiente ejemplo (implementación simple de `shutil.rmtree()`), recorrer el árbol de abajo hacia arriba es esencial, `rmdir()` no permite eliminar un directorio antes de que el directorio esté vacío:

      # Delete everything reachable from the directory named in "top",
      # assuming there are no symbolic links.
      # CAUTION:  This is dangerous!  For example, if top == '/', it
      # could delete all your disk files.
      import os
      for root, dirs, files in os.walk(top, topdown=False):
          for name in files:
              os.remove(os.path.join(root, name))
          for name in dirs:
              os.rmdir(os.path.join(root, name))

  Lanza un evento de auditoría `os.spawn` con argumentos `top`, `topdown`, `onerror`, `followlinks`.

  Distinto en la versión 3.5: Esta función ahora llama `os.scandir()` en lugar de `os.listdir()`, lo que lo hace más rápido al reducir el número de llamadas a `os.stat()`.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``fwalk`(top='.', topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None)

  Esto se comporta exactamente como `walk()`, excepto que produce 4 tuplas `(dirpath, dirnames, filenames, dirfd)`, y admite `dir_fd`.

  dirpath, dirnames y filenames son idénticos a `walk()` output, y dirfd es un descriptor de archivo que se refiere al directorio dirpath.

  Esta función siempre admite rutas relativas a descriptores de directorio y no siguen enlaces simbólicos. Sin embargo, tenga en cuenta que, a diferencia de otras funciones, el valor predeterminado `fwalk()` para follow_symlinks es `False`.

  Nota

  Dado que `fwalk()` produce descriptores de archivo, estos solo son válidos hasta el siguiente paso de iteración, por lo que debe duplicarlos (por ejemplo, con `dup()`) si desea mantenerlos más tiempo.

  Este ejemplo muestra el número de bytes que toman los archivos que no son de directorio en cada directorio bajo el directorio inicial, excepto que no se ve en ningún subdirectorio CVS:

      import os
      for root, dirs, files, rootfd in os.fwalk('python/Lib/email'):
          print(root, "consumes", end="")
          print(sum([os.stat(name, dir_fd=rootfd).st_size for name in files]),
                end="")
          print("bytes in", len(files), "non-directory files")
          if 'CVS' in dirs:
              dirs.remove('CVS')  # don't visit CVS directories

  En el siguiente ejemplo, recorrer el árbol de abajo hacia arriba es esencial: `rmdir()` no permite eliminar un directorio antes de que el directorio esté vacío:

      # Delete everything reachable from the directory named in "top",
      # assuming there are no symbolic links.
      # CAUTION:  This is dangerous!  For example, if top == '/', it
      # could delete all your disk files.
      import os
      for root, dirs, files, rootfd in os.fwalk(top, topdown=False):
          for name in files:
              os.unlink(name, dir_fd=rootfd)
          for name in dirs:
              os.rmdir(name, dir_fd=rootfd)

  Lanza un evento de auditoría `os.chown` con argumentos `top`, `topdown`, `onerror`, `follow_symlinks`, `dir_fd`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

  Distinto en la versión 3.7: Se agregó soporte para rutas de acceso `bytes`.

`os.``memfd_create`(name[, flags=os.MFD_CLOEXEC])

  Cree un archivo anónimo y retorna un descriptor de archivo que se refiera a él. flags debe ser una de las constantes `os.MFD_*` disponibles en el sistema (o una combinación ORed bit a bit de ellas). Por defecto, el nuevo descriptor de archivo es no heredable.

  El nombre proporcionado en name se utiliza como nombre de archivo y se mostrará como el destino del enlace simbólico correspondiente en el directorio `/proc/self/fd/`. El nombre que se muestra siempre tiene el prefijo `memfd:` y solo sirve para fines de depuración. Los nombres no afectan el comportamiento del descriptor de archivo y, como tal, varios archivos pueden tener el mismo nombre sin efectos secundarios.

  Disponibilidad: Linux 3.17 o posterior con glibc 2.27 o posterior.

  Nuevo en la versión 3.8.

`os.``MFD_CLOEXEC`
`os.``MFD_ALLOW_SEALING`
`os.``MFD_HUGETLB`
`os.``MFD_HUGE_SHIFT`
`os.``MFD_HUGE_MASK`
`os.``MFD_HUGE_64KB`
`os.``MFD_HUGE_512KB`
`os.``MFD_HUGE_1MB`
`os.``MFD_HUGE_2MB`
`os.``MFD_HUGE_8MB`
`os.``MFD_HUGE_16MB`
`os.``MFD_HUGE_32MB`
`os.``MFD_HUGE_256MB`
`os.``MFD_HUGE_512MB`
`os.``MFD_HUGE_1GB`
`os.``MFD_HUGE_2GB`
`os.``MFD_HUGE_16GB`

  Estas flags se pueden pasar a `memfd_create()`.

  Disponibilidad: Linux 3.17 o posterior con glibc 2.27 o posterior. Los indicadores `MFD_HUGE*` solo están disponibles desde Linux 4.14.

  Nuevo en la versión 3.8.

### Atributos extendidos de Linux

Nuevo en la versión 3.3.

Estas funciones están disponibles solo en Linux.

`os.``getxattr`(path, attribute, *, follow_symlinks=True)

  Retorna el valor del atributo del sistema de archivos extendido atrribute para path. attribute puede ser bytes o str (directa o indirectamente a través de la interfaz `PathLike`). Si es str, se codifica con la codificación del sistema de archivos.

  Esta función puede soportar especificando un descriptor de archivo y no siguen enlaces simbólicos.

  Lanza un evento de auditoría `os.getxattr` con argumentos `path`, `atributo`.

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

`os.``listxattr`(path=None, *, follow_symlinks=True)

  Retorna una lista de los atributos del sistema de archivos extendido en path. Los atributos en la lista se representan como cadenas decodificadas con la codificación del sistema de archivos. Si path es `None`, `listxattr()` examinará el directorio actual.

  Esta función puede soportar especificando un descriptor de archivo y no siguen enlaces simbólicos.

  Lanza un evento de auditoría `os.listxattr` con el argumento `path`.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``removexattr`(path, attribute, *, follow_symlinks=True)

  Elimina el atributo del sistema de archivos extendido attribute de path. attribute debe ser bytes o str (directa o indirectamente a través de la interfaz `PathLike`). Si es una cadena, se codifica con la codificación del sistema de archivos.

  Esta función puede soportar especificando un descriptor de archivo y no siguen enlaces simbólicos.

  Lanza un evento de auditoría `os.removexattr` con argumentos `path`, `attribute`.

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

`os.``setxattr`(path, attribute, value, flags=0, *, follow_symlinks=True)

  Set the extended filesystem attribute attribute on path to value. attribute must be a bytes or str with no embedded NULs (directly or indirectly through the `PathLike` interface). If it is a str, it is encoded with the filesystem encoding. flags may be `XATTR_REPLACE` or `XATTR_CREATE`. If `XATTR_REPLACE` is given and the attribute does not exist, `ENODATA` will be raised. If `XATTR_CREATE` is given and the attribute already exists, the attribute will not be created and `EEXISTS` will be raised.

  Esta función puede soportar especificando un descriptor de archivo y no siguen enlaces simbólicos.

  Nota

  Un error en las versiones de kernel de Linux anteriores a 2.6.39 hizo que el argumento de las flags se ignorara en algunos sistemas de archivos.

  Lanza un evento de auditoría `os.setxattr` con argumentos `path`, `attribute`, `value`, `flags`.

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

`os.``XATTR_SIZE_MAX`

  El tamaño máximo que puede tener el valor de un atributo extendido. Actualmente, esto es 64 KiB en Linux.

`os.``XATTR_CREATE`

  Este es un valor posible para el argumento flags en `setxattr()`. Indica que la operación debe crear un atributo.

`os.``XATTR_REPLACE`

  Este es un valor posible para el argumento flags en `setxattr()`. Indica que la operación debe reemplazar un atributo existente.

## Gestión de proceso

Estas funciones pueden usarse para crear y administrar procesos.

Las varias funciones `exec *` toman una lista de argumentos para el nuevo programa cargado en el proceso. En cada caso, el primero de estos argumentos se pasa al nuevo programa como su propio nombre en lugar de como un argumento que un usuario puede haber escrito en una línea de comando. Para el programador C, este es el `argv[0]` pasado a un programa `main()`. Por ejemplo, `os.execv('/bin/echo', ['foo', 'bar'])` solo imprimirá `bar` en la salida estándar; `foo` parecerá ignorado.

`os.``abort`()

  Genere una señal `SIGABRT` para el proceso actual. En Unix, el comportamiento predeterminado es producir un volcado de núcleo; en Windows, el proceso retorna inmediatamente un código de salida de `3`. Tenga en cuenta que llamar a esta función no llamará al controlador de señal Python registrado para `SIGABRT` con `signal.signal()`.

`os.``add_dll_directory`(path)

  Agregue una ruta a la ruta de búsqueda de DLL.

  This search path is used when resolving dependencies for imported extension modules (the module itself is resolved through `sys.path`), and also by `ctypes`.

  Elimina el directorio llamando a close() en el objeto retornado o utilizándolo en una `with` instrucción.

  Consulte la documentación de Microsoft para obtener más información sobre cómo se cargan las DLL.

  Lanza un evento de auditoría `os.add_dll_directory` con el argumento `path`.

  Disponibilidad: Windows.

  Nuevo en la versión 3.8: Las versiones anteriores de CPython resolverían las DLL utilizando el comportamiento predeterminado para el proceso actual. Esto condujo a inconsistencias, como solo a veces buscar `PATH` o el directorio de trabajo actual, y las funciones del sistema operativo como `AddDllDirectory` no tienen ningún efecto.

  En 3.8, las dos formas principales en que se cargan las DLL ahora anulan explícitamente el comportamiento de todo el proceso para garantizar la coherencia. Ver el notas de portabilidad para obtener información sobre la actualización de bibliotecas.

`os.``execl`(path, arg0, arg1, ...)
`os.``execle`(path, arg0, arg1, ..., env)
`os.``execlp`(file, arg0, arg1, ...)
`os.``execlpe`(file, arg0, arg1, ..., env)
`os.``execv`(path, args)
`os.``execve`(path, args, env)
`os.``execvp`(file, args)
`os.``execvpe`(file, args, env)

  Todas estas funciones ejecutan un nuevo programa, reemplazando el proceso actual; No vuelven. En Unix, el nuevo ejecutable se carga en el proceso actual y tendrá la misma identificación de proceso que la persona que llama. Los errores se informarán como excepciones `OSError`.

  El proceso actual se reemplaza inmediatamente. Los objetos de archivo abierto y los descriptores no se vacían, por lo que si puede haber datos almacenados en estos archivos abiertos, debe limpiarlos usando `sys.stdout.flush()` o `os.fsync()` antes de llamar a `exec*` función.

  Las variantes «l» y «v» de las funciones `exec*` difieren en cómo se pasan los argumentos de la línea de comandos. Las variantes «l» son quizás las más fáciles de trabajar si el número de parámetros se fija cuando se escribe el código; los parámetros individuales simplemente se convierten en parámetros adicionales a las funciones `execl*()`. Las variantes «v» son buenas cuando el número de parámetros es variable, y los argumentos se pasan en una lista o tupla como parámetro args. En cualquier caso, los argumentos del proceso secundario deben comenzar con el nombre del comando que se ejecuta, pero esto no se aplica.

  Las variantes que incluyen una «p» cerca del final (`execlp()`, `execlpe()`, `execvp()`, y `execvpe()`) usarán `PATH` variable de entorno para ubicar el programa file. Cuando se reemplaza el entorno (utilizando uno de los siguientes variantes `exec*e` variantes, discutidas en el siguiente párrafo), el nuevo entorno se utiliza como fuente de la variable `PATH`. Las otras variantes, `execl()`, `execle()`, `execv()`, y `execve()`, no utilizarán la variable `PATH` para localizar el ejecutable; path debe contener una ruta absoluta o relativa apropiada.

  Para `execle()`, `execlpe()`, `execve()` y `execvpe()` (tenga en cuenta que todo esto termina en «e»), el parámetro env debe ser un mapeo que se utiliza para definir las variables de entorno para el nuevo proceso (se utilizan en lugar del entorno del proceso actual); las funciones `execl()`, `execlp()`, `execv()` y `execvp()` hacen que el nuevo proceso herede el entorno del proceso actual.

  Para `execve()` en algunas plataformas, path también puede especificarse como un descriptor de archivo abierto. Es posible que esta funcionalidad no sea compatible con su plataforma; puede verificar si está disponible o no usando `os.supports_fd`. Si no está disponible, su uso generará un `NotImplementedError`.

  Lanza un evento de auditoría `os.exec` con argumentos `ruta`, `args`, `env`.

  Disponibilidad: Unix, Windows.

  Nuevo en la versión 3.3: Se agregó soporte para especificar path como un descriptor de archivo abierto para `execve()`.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``_exit`(n)

  Salga del proceso con el estado n, sin llamar a los controladores de limpieza, vaciar los buffers stdio, etc.

  Nota

  La forma estándar de salir es `sys.exit(n)`. `_exit()` normalmente solo debe usarse en el proceso secundario después de `fork()`.

Los siguientes códigos de salida están definidos y se pueden usar con `_exit()`, aunque no son obligatorios. Por lo general, se usan para programas del sistema escritos en Python, como el programa de entrega de comandos externos de un servidor de correo.

Nota

Es posible que algunos de estos no estén disponibles en todas las plataformas Unix, ya que hay alguna variación. Estas constantes se definen donde están definidas por la plataforma subyacente.

`os.``EX_OK`

  Código de salida que significa que no se produjo ningún error.

  Disponibilidad: Unix.

`os.``EX_USAGE`

  Código de salida que significa que el comando se usó incorrectamente, como cuando se da un número incorrecto de argumentos.

  Disponibilidad: Unix.

`os.``EX_DATAERR`

  Código de salida que significa que los datos de entrada eran incorrectos.

  Disponibilidad: Unix.

`os.``EX_NOINPUT`

  Código de salida que significa que no existía un archivo de entrada o que no era legible.

  Disponibilidad: Unix.

`os.``EX_NOUSER`

  Código de salida que significa que un usuario especificado no existía.

  Disponibilidad: Unix.

`os.``EX_NOHOST`

  Código de salida que significa que no existía un host especificado.

  Disponibilidad: Unix.

`os.``EX_UNAVAILABLE`

  Código de salida que significa que un servicio requerido no está disponible.

  Disponibilidad: Unix.

`os.``EX_SOFTWARE`

  Código de salida que significa que se detectó un error interno de software.

  Disponibilidad: Unix.

`os.``EX_OSERR`

  Código de salida que significa que se detectó un error del sistema operativo, como la imposibilidad de bifurcar o crear una tubería.

  Disponibilidad: Unix.

`os.``EX_OSFILE`

  Código de salida que significa que algunos archivos del sistema no existían, no podían abrirse o tenían algún otro tipo de error.

  Disponibilidad: Unix.

`os.``EX_CANTCREAT`

  Código de salida que significa que no se pudo crear un archivo de salida especificado por el usuario.

  Disponibilidad: Unix.

`os.``EX_IOERR`

  Código de salida que significa que se produjo un error al realizar E / S en algún archivo.

  Disponibilidad: Unix.

`os.``EX_TEMPFAIL`

  Código de salida que significa que ocurrió una falla temporal. Esto indica algo que puede no ser realmente un error, como una conexión de red que no se pudo realizar durante una operación recuperable.

  Disponibilidad: Unix.

`os.``EX_PROTOCOL`

  Código de salida que significa que un intercambio de protocolo fue ilegal, inválido o no se entendió.

  Disponibilidad: Unix.

`os.``EX_NOPERM`

  Código de salida que significa que no había permisos suficientes para realizar la operación (pero no para problemas del sistema de archivos).

  Disponibilidad: Unix.

`os.``EX_CONFIG`

  Código de salida que significa que se produjo algún tipo de error de configuración.

  Disponibilidad: Unix.

`os.``EX_NOTFOUND`

  Código de salida que significa algo así como «no se encontró una entrada».

  Disponibilidad: Unix.

`os.``fork`()

  Bifurcar un proceso hijo. Retorna `0` en el niño y la identificación del proceso del niño en el padre. Si se produce un error se genera `OSError`.

  Tenga en cuenta que algunas plataformas que incluyen FreeBSD &lt;= 6.3 y Cygwin tienen problemas conocidos al usar `fork()` desde un hilo.

  Lanza un evento de auditoría `os.fork` sin argumentos.

  Distinto en la versión 3.8: Llamar a `fork()` en un subinterpretador ya no es compatible (`RuntimeError` está activado).

  Advertencia

  Ver `ssl` para aplicaciones que usan el módulo SSL con fork().

  Disponibilidad: Unix.

`os.``forkpty`()

  Bifurca un proceso hijo, usando un nuevo pseudo-terminal como terminal de control del niño. Retorna un par de `(pid, fd)`, donde pid es `0` en el elemento secundario, la identificación del proceso del elemento secundario nuevo en el elemento primario y fd es el descriptor de archivo del final maestro de El pseudo-terminal. Para un enfoque más portátil, use el módulo `pty`. Si se produce un error se genera `OSError`.

  Lanza un evento de auditoría `os.forkpty` sin argumentos.

  Distinto en la versión 3.8: Llamar a `forkpty()` en un subinterpretador ya no es compatible (`RuntimeError` está activado).

  Disponibilidad: algunos sistemas tipo Unix.

`os.``kill`(pid, sig)

  Enviar señal sig al proceso pid. Las constantes para las señales específicas disponibles en la plataforma host se definen en el módulo `signal`.

  Windows: Las señales `signal.CTRL_C_EVENT` y `signal.CTRL_BREAK_EVENT` son señales especiales que solo pueden enviarse a procesos de consola que comparten una ventana de consola común, por ejemplo, algunos subprocesos. Cualquier otro valor para sig hará que la API TerminateProcess elimine el proceso incondicionalmente, y el código de salida se establecerá en sig. La versión de Windows de `kill()` también requiere que los identificadores de proceso sean eliminados.

  Ver también `signal.pthread_kill()`.

  Lanza un evento de auditoría `os.kill` con argumentos `pid`, `sig`.

  Nuevo en la versión 3.2: Soporte de Windows.

`os.``killpg`(pgid, sig)

  Envíe la señal sig al grupo de procesos pgid.

  Lanza un evento de auditoría `os.killpg` con argumentos `pgid`, `sig`.

  Disponibilidad: Unix.

`os.``nice`(increment)

  Agregue increment a la «simpatía» del proceso. Retorna la nueva amabilidad.

  Disponibilidad: Unix.

`os.``pidfd_open`(pid, flags=0)

  Retorna un descriptor de archivo referente al pid del proceso. Este descriptor puede ser usado para realizar gestión de procesos sin necesidad de señales y carreras. El argumento flags es proporcionado para extensiones futuras; ningún valor se encuentra definido en las banderas actualmente.

  Ver la página manual de pidfd_open(2) para mas detalles.

  Disponibilidad: Linux 5.3+

  Nuevo en la versión 3.9.

`os.``plock`(op)

  Bloquee segmentos del programa en la memoria. El valor de op (definido en `<sys/lock.h>`) determina qué segmentos están bloqueados.

  Disponibilidad: Unix.

`os.``popen`(cmd, mode='r', buffering=-1)

  Abra una tubería hacia o desde el comando cmd. El valor de retorno es un objeto de archivo abierto conectado a la tubería, que puede leerse o escribirse dependiendo de si mode es `'r'` (predeterminado) o `'w'`. El argumento buffering tiene el mismo significado que el argumento correspondiente a la función incorporada `open()`. El objeto de archivo retornado lee o escribe cadenas de texto en lugar de bytes.

  El método `close` retorna `None` si el subproceso salió correctamente, o el código de retorno del subproceso si hubo un error. En los sistemas POSIX, si el código de retorno es positivo, representa el valor de retorno del proceso desplazado a la izquierda en un byte. Si el código de retorno es negativo, el proceso fue terminado por la señal dada por el valor negado del código de retorno. (Por ejemplo, el valor de retorno podría ser `- signal.SIGKILL` si se eliminó el subproceso). En los sistemas Windows, el valor de retorno contiene el código de retorno entero firmado del proceso secundario.

  En Unix, `waitstatus_to_exitcode()` puede ser usado para convertir el resultado del método `close` (estado de salida) en un código de salida si es que no es `None`. En Windows, el resultado del método `close` es directamente el código de salida (o `None`).

  Esto se implementa usando `subprocess.Popen`; consulte la documentación de esa clase para obtener formas más potentes de administrar y comunicarse con subprocesos.

`os.``posix_spawn`(path, argv, env, *, file_actions=None, setpgroup=None, resetids=False, setsid=False, setsigmask=(), setsigdef=(), scheduler=None)

  Envuelve la API de la biblioteca C `posix_spawn()` para usar desde Python.

  La mayoría de los usuarios deberían usar `subprocess.run()` en lugar de `posix_spawn()`.

  Los argumentos de solo posición path, args y env son similares a `execve()`.

  El parámetro path es la ruta al archivo ejecutable. La path debe contener un directorio. Utilice `posix_spawnp()` para pasar un archivo ejecutable sin directorio.

  El argumento file_actions puede ser una secuencia de tuplas que describen acciones para tomar descriptores de archivo específicos en el proceso secundario entre los pasos de implementación de la biblioteca C `fork()` y `exec()`. El primer elemento de cada tupla debe ser uno de los tres indicadores de tipo que se enumeran a continuación y que describen los elementos de tupla restantes:

  `os.``POSIX_SPAWN_OPEN`

    (`os.POSIX_SPAWN_OPEN`, fd, path, flags, mode)

    Realiza `os.dup2(os.open(path, flags, mode), fd)`.

  `os.``POSIX_SPAWN_CLOSE`

    (`os.POSIX_SPAWN_CLOSE`, fd)

    Realiza `os.close(fd)`.

  `os.``POSIX_SPAWN_DUP2`

    (`os.POSIX_SPAWN_DUP2`, fd, new_fd)

    Realiza `os.dup2(fd, new_fd)`.

  Estas tuplas corresponden a la biblioteca C `posix_spawn_file_actions_addopen()`, `posix_spawn_file_actions_addclose()`, y `posix_spawn_file_actions_adddup2()` Llamadas API utilizadas para prepararse para `posix_spawn()` se llame a sí mismo.

  El argumento setpgroup establecerá el grupo de proceso del elemento secundario en el valor especificado. Si el valor especificado es 0, la ID del grupo de procesos del niño se hará igual que su ID de proceso. Si el valor de setpgroup no está establecido, el elemento secundario heredará la ID del grupo de proceso del elemento primario. Este argumento corresponde al flag `POSIX_SPAWN_SETPGROUP` de la biblioteca de C.

  Si el argumento resetids es `True`, restablecerá el UID y el GID efectivos del niño al UID y GID reales del proceso padre. Si el argumento es `False`, el niño conserva el UID y el GID efectivos del padre. En cualquier caso, si los bits de permiso set-user-ID y set-group-ID están habilitados en el archivo ejecutable, su efecto anulará la configuración del UID y GID efectivos. Este argumento corresponde a la flag de la biblioteca C `POSIX_SPAWN_RESETIDS`.

  Si el argumento setsid es `True`, creará una nueva ID de sesión para posix_spawn. setsid requiere `POSIX_SPAWN_SETSID` o flag `POSIX_SPAWN_SETSID_NP`. De lo contrario, se excita `NotImplementedError`.

  El argumento setsigmask establecerá la máscara de señal en el conjunto de señal especificado. Si no se usa el parámetro, el niño hereda la máscara de señal del padre. Este argumento corresponde al flag `POSIX_SPAWN_SETSIGMASK` de la biblioteca en C.

  El argumento sigdef restablecerá la disposición de todas las señales en el conjunto especificado. Este argumento corresponde al flag `POSIX_SPAWN_SETSIGDEF` de la biblioteca de C.

  El argumento scheduler debe ser una tupla que contenga la política del planificador (opcional) y una instancia de `sched_param` con los parámetros del planificador. Un valor de `None` en el lugar de la política del planificador indica que no se proporciona. Este argumento es una combinación de la biblioteca C `POSIX_SPAWN_SETSCHEDPARAM` y flags `POSIX_SPAWN_SETSCHEDULER`.

  Lanza un evento de auditoría `os.posix_spawn` con argumentos `ruta`, `argv`, `env`.

  Nuevo en la versión 3.8.

  Disponibilidad: Unix.

`os.``posix_spawnp`(path, argv, env, *, file_actions=None, setpgroup=None, resetids=False, setsid=False, setsigmask=(), setsigdef=(), scheduler=None)

  Envuelve la API de la biblioteca `posix_spawnp()` C para usar desde Python.

  Similar a `posix_spawn()` excepto que el sistema busca el archivo executable en la lista de directorios especificada por la variable de entorno `PATH` (de la misma manera que para `execvp(3)` )

  Lanza un evento de auditoría `os.posix_spawn` con argumentos `ruta`, `argv`, `env`.

  Nuevo en la versión 3.8.

  Disponibilidad: Ver documentación `posix_spawn()`.

`os.``register_at_fork`(*, before=None, after_in_parent=None, after_in_child=None)

  Registra los invocables que se ejecutarán cuando se bifurca un nuevo proceso secundario utilizando `os.fork()` o API de clonación de procesos similares. Los parámetros son opcionales y solo de palabras clave. Cada uno especifica un punto de llamada diferente.

  - before es una función llamada antes de bifurcar un proceso hijo.

  - after_in_parent es una función llamada desde el proceso padre después de bifurcar un proceso hijo.

  - after_in_child es una función llamada desde el proceso hijo.

  Estas llamadas solo se realizan si se espera que el control regrese al intérprete de Python. Un lanzamiento típico `subprocess` no los activará ya que el niño no va a volver a ingresar al intérprete.

  Las funciones registradas para su ejecución antes de la bifurcación se invocan en orden de registro inverso. Las funciones registradas para la ejecución después de la bifurcación (ya sea en el padre o en el hijo) se invocan en orden de registro.

  Tenga en cuenta que las llamadas `fork()` realizadas por código C de terceros no pueden llamar a esas funciones, a menos que explícitamente llame a `PyOS_BeforeFork()`, `PyOS_AfterFork_Parent()` y `PyOS_AfterFork_Child()`.

  No hay forma de cancelar el registro de una función.

  Disponibilidad: Unix.

  Nuevo en la versión 3.7.

`os.``spawnl`(mode, path, ...)
`os.``spawnle`(mode, path, ..., env)
`os.``spawnlp`(mode, file, ...)
`os.``spawnlpe`(mode, file, ..., env)
`os.``spawnv`(mode, path, args)
`os.``spawnve`(mode, path, args, env)
`os.``spawnvp`(mode, file, args)
`os.``spawnvpe`(mode, file, args, env)

  Ejecute el programa path en un nuevo proceso.

  (Tenga en cuenta que el módulo `subprocess` proporciona funciones más potentes para generar nuevos procesos y recuperar sus resultados; es preferible usar ese módulo que usar estas funciones. Compruebe especialmente la sección Cómo reemplazar anteriores funciones con el módulo subprocess.)

  Si mode es `P_NOWAIT`, esta función retorna la identificación del proceso del nuevo proceso; if mode is `P_WAIT`, retorna el código de salida del proceso si sale normalmente, o `-signal`, donde signal es la señal que mató el proceso. En Windows, la identificación del proceso en realidad será el identificador del proceso, por lo que se puede usar con la función `waitpid()`.

  Nota sobre VxWorks, esta función no retorna `-signal` cuando se cierra el nuevo proceso. En su lugar, genera una excepción OSError.

  Las variantes «l» y «v» de las funciones `spawn*` difieren en cómo se pasan los argumentos de la línea de comandos. Las variantes «l» son quizás las más fáciles de trabajar si el número de parámetros se fija cuando se escribe el código; los parámetros individuales simplemente se convierten en parámetros adicionales a las funciones `spawnl*()`. Las variantes «v» son buenas cuando el número de parámetros es variable, y los argumentos se pasan en una lista o tupla como parámetro args. En cualquier caso, los argumentos del proceso secundario deben comenzar con el nombre del comando que se está ejecutando.

  Las variantes que incluyen una segunda «p» cerca del final (`spawnlp()`, `spawnlpe()`, `spawnvp()`, y `spawnvpe()`) usarán `PATH` variable de entorno para ubicar el programa file. Cuando se reemplaza el entorno (usando uno de los siguientes `spawn*e` variantes, discutidas en el siguiente párrafo), el nuevo entorno se utiliza como fuente de la variable `PATH`. Las otras variantes, `spawnl()`, `spawnle()`, `spawnv()`, y `spawnve()`, no utilizarán la variable `PATH` para localizar el ejecutable; path debe contener una ruta absoluta o relativa apropiada.

  Para `spawnle()`, `spawnlpe()`, `spawnve()`, y `spawnvpe()` (tenga en cuenta que todo esto termina en «e»), el parámetro env debe ser un mapeo que se utiliza para definir las variables de entorno para el nuevo proceso (se utilizan en lugar del entorno del proceso actual); las funciones `spawnl()`, `spawnlp()`, `spawnv()` y `spawnvp()` hacen que el nuevo proceso herede el entorno del proceso actual. Tenga en cuenta que las claves y los valores en el diccionario env deben ser cadenas; Las teclas o valores no válidos harán que la función falle, con un valor de retorno de `127`.

  Como ejemplo, las siguientes llamadas a `spawnlp()` y `spawnvpe()` son equivalentes:

      import os
      os.spawnlp(os.P_WAIT, 'cp', 'cp', 'index.html', '/dev/null')

      L = ['cp', 'index.html', '/dev/null']
      os.spawnvpe(os.P_WAIT, 'cp', L, os.environ)

  Lanza un evento de auditoría `os.spawn` con argumentos `mode`, `path`, `args`, `env`.

  Disponibilidad: Unix, Windows. `spawnlp()`, `spawnlpe()`, `spawnvp()` y `spawnvpe()` no están disponibles en Windows. `spawnle()` y `spawnve()` no son seguros para subprocesos en Windows; le recomendamos que utilice el módulo `subprocess` en su lugar.

  Distinto en la versión 3.6: Acepta un objeto tipo ruta.

`os.``P_NOWAIT`
`os.``P_NOWAITO`

  Valores posibles para el parámetro mode para `spawn*` familia de funciones. Si se da alguno de estos valores, las funciones `spawn*()` volverán tan pronto como se haya creado el nuevo proceso, con la identificación del proceso como valor de retorno.

  Disponibilidad: Unix, Windows.

`os.``P_WAIT`

  Posible valor para el parámetro mode para `spawn*` familia de funciones. Si esto se da como mode, las funciones `spawn*()` no volverán hasta que el nuevo proceso se haya completado y retornará el código de salida del proceso, la ejecución es exitosa, o `-signal` si una señal mata el proceso.

  Disponibilidad: Unix, Windows.

`os.``P_DETACH`
`os.``P_OVERLAY`

  Valores posibles para el parámetro mode para `spawn*` familia de funciones. Estos son menos portátiles que los enumerados anteriormente. `P_DETACH` es similar a `P_NOWAIT`, pero el nuevo proceso se desconecta de la consola del proceso de llamada. Si se usa `P_OVERLAY`, el proceso actual será reemplazado; la función `spawn*` no volverá.

  Disponibilidad: Windows.

`os.``startfile`(path[, operation])

  Inicie un archivo con su aplicación asociada.

  Cuando operation no se especifica o `'abre'`, esto actúa como hacer doble clic en el archivo en el Explorador de Windows, o dar el nombre del archivo como argumento para el comando start desde el shell de comandos interactivo: el archivo se abre con cualquier aplicación (si la hay) a la que está asociada su extensión.

  Cuando se da otra operation, debe ser un «verbo de comando» que especifica qué se debe hacer con el archivo. Los verbos comunes documentados por Microsoft son `'print'` y `'edit'` (para usar en archivos), así como `'explore'` y `'find'` (para usar en directorios).

  `startfile()` vuelve tan pronto como se inicia la aplicación asociada. No hay opción de esperar a que la aplicación se cierre y no hay forma de recuperar el estado de salida de la aplicación. El parámetro path es relativo al directorio actual. Si desea utilizar una ruta absoluta, asegúrese de que el primer carácter no sea una barra inclinada (`'/'`); la función subyacente Win32 `ShellExecute()` no funciona si lo es. Use la función `os.path.normpath()` para asegurarse de que la ruta esté codificada correctamente para Win32.

  Para reducir la sobrecarga de inicio del intérprete, la función Win32 `ShellExecute()` no se resuelve hasta que esta función se llama por primera vez. Si la función no se puede resolver, se generará `NotImplementedError`.

  Lanza un evento de auditoría `os.startfile` con argumentos `path`, `operation`.

  Disponibilidad: Windows.

`os.``system`(command)

  Execute the command (a string) in a subshell. This is implemented by calling the Standard C function `system()`, and has the same limitations. Changes to `sys.stdin`, etc. are not reflected in the environment of the executed command. If command generates any output, it will be sent to the interpreter standard output stream. The C standard does not specify the meaning of the return value of the C function, so the return value of the Python function is system-dependent.

  On Unix, the return value is the exit status of the process encoded in the format specified for `wait()`.

  En Windows, el valor de retorno es el que retorna el shell del sistema después de ejecutar command. El shell viene dado por la variable de entorno de Windows `COMSPEC`: generalmente es cmd.exe, que retorna el estado de salida de la ejecución del comando; En sistemas que utilizan un shell no nativo, consulte la documentación del shell.

  El módulo `subprocess` proporciona instalaciones más potentes para generar nuevos procesos y recuperar sus resultados; usar ese módulo es preferible a usar esta función. Consulte la sección Cómo reemplazar anteriores funciones con el módulo subprocess en la documentación de `subprocess` para obtener algunas recetas útiles.

  En Unix, `waitstatus_to_exitcode()` puede ser usado para convertir el resultado (estado de salida) en un código de salida. En Windows, el resultado es directamente el código de salida.

  Lanza un evento de auditoría `os.system` con argumento `command`.

  Disponibilidad: Unix, Windows.

`os.``times`()

  Retorna los tiempos de proceso globales actuales. El valor de retorno es un objeto con cinco atributos:

  - `user` - user time

  - `system` - system time

  - `children_user` - user time of all child processes

  - `children_system` - system time of all child processes

  - `elapsed` - elapsed real time since a fixed point in the past

  For backwards compatibility, this object also behaves like a five-tuple containing `user`, `system`, `children_user`, `children_system`, and `elapsed` in that order.

  See the Unix manual page times(2) and times(3) manual page on Unix or the GetProcessTimes MSDN on Windows. On Windows, only `user` and `system` are known; the other attributes are zero.

  Disponibilidad: Unix, Windows.

  Distinto en la versión 3.3: El tipo de objeto retornado cambió de una tupla a un objeto tipo tupla con atributos con nombre.

`os.``wait`()

  Espere a que se complete un proceso secundario y retorna una tupla que contenga su indicación de estado pid y de salida: un número de 16 bits, cuyo byte bajo es el número de señal que mató el proceso y cuyo byte alto es el estado de salida (si la señal el número es cero); el bit alto del byte bajo se establece si se produjo un archivo central.

  `waitstatus_to_exitcode()` puede ser usado para convertir el estado de salida en el código de salida.

  Disponibilidad: Unix.

  Ver también

  `waitpid()` puede ser usado para esperar a la terminación de algún proceso hijo en específico y tiene más opciones.

`os.``waitid`(idtype, id, options)

  Espere la finalización de uno o más procesos secundarios. idtype puede ser `P_PID`, `P_PGID`, `P_ALL` o `P_PIDFD` en Linux. id especifica el pid para esperar. options se construye a partir de ORing de uno o más de `WEXITED`, `WSTOPPED` o `WCONTINUED` y adicionalmente se puede ORed con `WNOHANG` o `WNOWAIT`. El valor de retorno es un objeto que representa los datos contenidos en la estructura `siginfo_t`, a saber: `si_pid`, `si_uid`, `si_signo`, `si_status`, `si_code` o `None` si `WNOHANG` está especificado y no hay hijos en un estado de espera.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``P_PID`
`os.``P_PGID`
`os.``P_ALL`

  Estos son los valores posibles para idtype en `waitid()`. Afectan cómo se interpreta id.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``P_PIDFD`

  Esto es un idtype especifico de Linux que indica que ese id es un descriptor de archivo que hace referencia a un proceso.

  Disponibilidad: Linux 5.4+

  Nuevo en la versión 3.9.

`os.``WEXITED`
`os.``WSTOPPED`
`os.``WNOWAIT`

  Indicadores que se pueden usar en options en `waitid()` que especifican qué señal secundaria esperar.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

`os.``CLD_EXITED`
`os.``CLD_KILLED`
`os.``CLD_DUMPED`
`os.``CLD_TRAPPED`
`os.``CLD_STOPPED`
`os.``CLD_CONTINUED`

  Estos son los valores posibles para `si_code` en el resultado retornado por `waitid()`.

  Disponibilidad: Unix.

  Nuevo en la versión 3.3.

  Distinto en la versión 3.9: Agregado los valores `CLD_KILLED` y `CLD_STOPPED`.

`os.``waitpid`(pid, options)

  Los detalles de esta función difieren en Unix y Windows.

  En Unix: espere a que se complete un proceso secundario dado por la identificación del proceso pid, y retorna una tupla que contenga su identificación del proceso y la indicación del estado de salida (codificado como para `wait()`). La semántica de la llamada se ve afectada por el valor del número entero options, que debe ser `0` para el funcionamiento normal.

  Si pid es mayor que `0`, `waitpid()` solicita información de estado para ese proceso específico. Si pid es `0`, la solicitud es para el estado de cualquier hijo en el grupo de procesos del proceso actual. Si pid es `-1`, la solicitud corresponde a cualquier elemento secundario del proceso actual. Si pid es menor que `-1`, se solicita el estado de cualquier proceso en el grupo de procesos `-pid` (el valor absoluto de pid).

  Un `OSError` se lanza con el valor de errno cuando syscall retorna -1.

  En Windows: espere a que se complete un proceso dado por el identificador de proceso pid, y retorna una tupla que contiene pid, y su estado de salida se desplazó a la izquierda en 8 bits (el desplazamiento facilita el uso de la función en la plataforma). A pid menor o igual que `0` no tiene un significado especial en Windows y genera una excepción. El valor de entero options no tiene ningún efecto. pid puede referirse a cualquier proceso cuya identificación sea conocida, no necesariamente un proceso hijo. Las funciones `spawn*` llamadas con `P_NOWAIT` retornan manejadores de proceso adecuados.

  `waitstatus_to_exitcode()` puede ser usado para convertir el estado de salida en el código de salida.

  Distinto en la versión 3.5: Si la llamada al sistema se interrumpe y el controlador de señal no genera una excepción, la función vuelve a intentar la llamada del sistema en lugar de generar una excepción `InterruptedError` (ver PEP 475 para la justificación).

`os.``wait3`(options)

  Similar a `waitpid()`, excepto que no se proporciona ningún argumento de identificación de proceso y se retorna una tupla de 3 elementos que contiene la identificación de proceso del niño, la indicación del estado de salida y la información de uso de recursos. Consulte `resource`. `getrusage()` para obtener detalles sobre la información de uso de recursos. El argumento de la opción es el mismo que se proporciona a `waitpid()` y `wait4()`.

  `waitstatus_to_exitcode()` puede ser usado para convertir el estado de salida al código de salida.

  Disponibilidad: Unix.

`os.``wait4`(pid, options)

  Similar a `waitpid()`, excepto una tupla de 3 elementos, que contiene la identificación del proceso del niño, la indicación del estado de salida y la información de uso de recursos. Consulte `resource`.`getrusage()` para obtener detalles sobre la información de uso de recursos. Los argumentos para `wait4()` son los mismos que los proporcionados para `waitpid()`.

  `waitstatus_to_exitcode()` puede ser usado para convertir el estado de salida al código de salida.

  Disponibilidad: Unix.

`os.``waitstatus_to_exitcode`(status)

  Convertir un estado de espera a un código de salida.

  En Unix:

  - Si el proceso termino con normalidad (if `WIFEXITED(status)` is true, se retornan el estado de salida del proceso (return `WEXITSTATUS(status)`): resultado mayor o igual a 0.

  - Si el proceso fue terminado por una señal (if `WIFSIGNALED(status)` is true), retorna `-signum` donde signum es el numero de la señal que cause que el proceso termine (return `-WTERMSIG(status)`): resultado menor que 0.

  - En el caso contrario, se lanza un `ValueError`.

  En Windows, retorna status desplazado a la derecha en 8 bits.

  En Unix, si el proceso esta siendo rastreado o si `waitpid()` fue llamado con la opción `WUNTRACED`, el que llama debe revisar primero si `WIFSTOPPED(status)` es verdadero. La función no debe de ser llamada si `WIFSTOPPED(status)` es verdadero.

  Ver también

  Funciones `WIFEXITED()`, `WEXITSTATUS()`, `WIFSIGNALED()`, `WTERMSIG()`, `WIFSTOPPED()`, `WSTOPSIG()`.

  Nuevo en la versión 3.9.

`os.``WNOHANG`

  La opción para `waitpid()` para regresar inmediatamente si no hay un estado de proceso secundario disponible de inmediato. La función retorna `(0, 0)` en este caso.

  Disponibilidad: Unix.

`os.``WCONTINUED`

  Esta opción hace que se informen los procesos secundarios si se han continuado desde una parada de control de trabajo desde la última vez que se informó su estado.

  Disponibilidad: algunos sistemas Unix.

`os.``WUNTRACED`

  Esta opción hace que se informen los procesos secundarios si se han detenido pero su estado actual no se ha informado desde que se detuvieron.

  Disponibilidad: Unix.

Las siguientes funciones toman un código de estado del proceso retornado por `system()`, `wait()`, o `waitpid()` como parámetro. Pueden usarse para determinar la disposición de un proceso.

`os.``WCOREDUMP`(status)

  Retorna `True` si se generó un volcado de núcleo para el proceso; de lo contrario, retorna `False`.

  Esta función debe emplearse solo si `WIFSIGNALED()` es verdadero.

  Disponibilidad: Unix.

`os.``WIFCONTINUED`(status)

  Retorna `True` si un niño detenido se ha reanudado mediante la entrega de `SIGCONT` (si el proceso se ha continuado desde una parada de control de trabajo), de lo contrario, retorna `False`.

  Ver opción `WCONTINUED`.

  Disponibilidad: Unix.

`os.``WIFSTOPPED`(status)

  Retorna `True` si el proceso se detuvo mediante la entrega de una señal; de lo contrario, retorna `False`.

  `WIFSTOPPED()` solo retorna `True` si la llamada `waitpid()` se realizó utilizando la opción `WUNTRACED` o cuando se rastrea el proceso (consulte ptrace(2))

  Disponibilidad: Unix.

`os.``WIFSIGNALED`(status)

  Retorna `True` si el proceso finalizó con una señal; de lo contrario, retorna `False`.

  Disponibilidad: Unix.

`os.``WIFEXITED`(status)

  Retorna `True` si el proceso finalizó normalmente, es decir, llamando a `exit()` o `_exit()`, o volviendo de `main()`; de lo contrario, retorna `False`.

  Disponibilidad: Unix.

`os.``WEXITSTATUS`(status)

  Retorna el estado de salida del proceso.

  Esta función debe emplearse solo si `WIFEXITED()` es verdadero.

  Disponibilidad: Unix.

`os.``WSTOPSIG`(status)

  Retorna la señal que hizo que el proceso se detuviera.

  Esta función debe emplearse solo si `WIFSTOPPED()` es verdadero.

  Disponibilidad: Unix.

`os.``WTERMSIG`(status)

  Retorna el número de la señal que provocó la finalización del proceso.

  Esta función debe emplearse solo si `WIFSIGNALED()` es verdadero.

  Disponibilidad: Unix.

## Interfaz al planificador

Estas funciones controlan cómo el sistema operativo asigna el tiempo de CPU a un proceso. Solo están disponibles en algunas plataformas Unix. Para obtener información más detallada, consulte las páginas de manual de Unix.

Nuevo en la versión 3.3.

Las siguientes políticas de programación están expuestas si son compatibles con el sistema operativo.

`os.``SCHED_OTHER`

  La política de programación predeterminada.

`os.``SCHED_BATCH`

  Política de programación para procesos intensivos en CPU que intenta preservar la interactividad en el resto de la computadora.

`os.``SCHED_IDLE`

  Política de programación para tareas en segundo plano de prioridad extremadamente baja.

`os.``SCHED_SPORADIC`

  Política de programación para programas de servidor esporádicos.

`os.``SCHED_FIFO`

  Una política de programación First In First Out.

`os.``SCHED_RR`

  Una política de programación round-robin.

`os.``SCHED_RESET_ON_FORK`

  Esta flag se puede OR con cualquier otra política de programación. Cuando un proceso con este indicador establece bifurcaciones, la política de programación y la prioridad de su hijo se restablecen a los valores predeterminados.

class `os.``sched_param`(sched_priority)

  Esta clase representa los parámetros de programación ajustables utilizados en `sched_setparam()`, `sched_setscheduler()` y `sched_getparam()`. Es inmutable.

  Por el momento, solo hay un parámetro posible:

  `sched_priority`

    La prioridad de programación para una política de programación.

`os.``sched_get_priority_min`(policy)

  Obtiene el valor de prioridad mínimo para policy. policy es una de las constantes de política de programación anteriores.

`os.``sched_get_priority_max`(policy)

  Obtiene el valor de prioridad máxima para policy. policy es una de las constantes de política de programación anteriores.

`os.``sched_setscheduler`(pid, policy, param)

  Establece la política de programación para el proceso con PID pid. Un pid de 0 significa el proceso de llamada. policy es una de las constantes de política de programación anteriores. param es una instancia de `sched_param`.

`os.``sched_getscheduler`(pid)

  Retorna la política de programación para el proceso con PID pid. Un pid de 0 significa el proceso de llamada. El resultado es una de las constantes de política de programación anteriores.

`os.``sched_setparam`(pid, param)

  Set the scheduling parameters for the process with PID pid. A pid of 0 means the calling process. param is a `sched_param` instance.

`os.``sched_getparam`(pid)

  Retorna los parámetros de programación como una instancia de `sched_param` para el proceso con PID pid. Un pid de 0 significa el proceso de llamada.

`os.``sched_rr_get_interval`(pid)

  Retorna el round-robin quantum en segundos para el proceso con PID pid. Un pid de 0 significa el proceso de llamada.

`os.``sched_yield`()

  Renunciar voluntariamente a la CPU.

`os.``sched_setaffinity`(pid, mask)

  Restringe el proceso con PID pid (o el proceso actual si es cero) a un conjunto de CPU. mask es un entero iterable que representa el conjunto de CPU a las que se debe restringir el proceso.

`os.``sched_getaffinity`(pid)

  Retorna el conjunto de CPU al proceso con PID pid (o el proceso actual si es cero) está restringido.

## Información miscelánea del sistema

`os.``confstr`(name)

  Retorna valores de configuración del sistema con valores de cadena. name especifica el valor de configuración para recuperar; puede ser una cadena que es el nombre de un valor de sistema definido; estos nombres se especifican en varios estándares (POSIX, Unix 95, Unix 98 y otros). Algunas plataformas también definen nombres adicionales. Los nombres conocidos por el sistema operativo host se dan como las claves del diccionario `confstr_names`. Para las variables de configuración no incluidas en esa asignación, también se acepta pasar un número entero para name.

  Si el valor de configuración especificado por name no está definido, se retorna `None`.

  Si name es una cadena y no se conoce, se excita `ValueError`. Si el sistema host no admite un valor específico para name, incluso si está incluido en `confstr_names`, se lanza un `OSError` con `errno.EINVAL` para el número de error .

  Disponibilidad: Unix.

`os.``confstr_names`

  Nombres de mapeo de diccionario aceptados por `confstr()` a los valores enteros definidos para esos nombres por el sistema operativo host. Esto se puede usar para determinar el conjunto de nombres conocidos por el sistema.

  Disponibilidad: Unix.

`os.``cpu_count`()

  Retorna el número de CPU en el sistema. Retorna `None` si no está determinado.

  Este número no es equivalente al número de CPU que puede utilizar el proceso actual. El número de CPU utilizables se puede obtener con `len(os.sched_getaffinity(0))`

  Nuevo en la versión 3.4.

`os.``getloadavg`()

  Retorna el número de procesos en la cola de ejecución del sistema promediada durante los últimos 1, 5 y 15 minutos o aumentos `OSError` si el promedio de carga no se pudo obtener.

  Disponibilidad: Unix.

`os.``sysconf`(name)

  Retorna valores de configuración del sistema con valores enteros. Si el valor de configuración especificado por name no está definido, se retorna `-1`. Los comentarios sobre el parámetro name para `confstr()` se aplican aquí también; El diccionario que proporciona información sobre los nombres conocidos viene dado por `sysconf_names`.

  Disponibilidad: Unix.

`os.``sysconf_names`

  Nombres de asignación de diccionario aceptados por `sysconf()` a los valores enteros definidos para esos nombres por el sistema operativo host. Esto se puede usar para determinar el conjunto de nombres conocidos por el sistema.

  Disponibilidad: Unix.

Los siguientes valores de datos se utilizan para admitir operaciones de manipulación de rutas. Estos están definidos para todas las plataformas.

Las operaciones de nivel superior en los nombres de ruta se definen en el módulo `os.path`.

`os.``curdir`

  La cadena constante utilizada por el sistema operativo para referirse al directorio actual. Esto es `'.'` Para Windows y POSIX. También disponible a través de `os.path`.

`os.``pardir`

  La cadena constante utilizada por el sistema operativo para hacer referencia al directorio principal. Esto es `'...'` para Windows y POSIX. También disponible a través de `os.path`.

`os.``sep`

  El carácter utilizado por el sistema operativo para separar los componentes del nombre de ruta. Esto es `'/'` para POSIX y `'\\'` para Windows. Tenga en cuenta que saber esto no es suficiente para poder analizar o concatenar nombres de ruta — use `os.path.split()` y `os.path.join()` — pero en ocasiones es útil. También disponible a través de `os.path`.

`os.``altsep`

  Un carácter alternativo utilizado por el sistema operativo para separar los componentes del nombre de ruta, o `None` si solo existe un carácter separador. Esto se establece en `'/'` en los sistemas Windows donde `sep` es una barra invertida. También disponible a través de `os.path`.

`os.``extsep`

  El carácter que separa el nombre de archivo base de la extensión; por ejemplo, el `'.'` en `os.py`. También disponible a través de `os.path`.

`os.``pathsep`

  El carácter utilizado convencionalmente por el sistema operativo para separar los componentes de la ruta de búsqueda (como en `PATH`), como `':'` para POSIX o `';'` para Windows. También disponible a través de `os.path`.

`os.``defpath`

  La ruta de búsqueda predeterminada utilizada por `exec*p*` y `spawn*p*` si el entorno no tiene una tecla `'RUTA'`. También disponible a través de `os.path`.

`os.``linesep`

  La cadena utilizada para separar (o, más bien, terminar) líneas en la plataforma actual. Este puede ser un solo carácter, como `'\n'` para POSIX, o varios caracteres, por ejemplo, `'\r\n'` para Windows. No utilice os.linesep como terminador de línea cuando escriba archivos abiertos en modo texto (el valor predeterminado); use un solo `'\n'` en su lugar, en todas las plataformas.

`os.``devnull`

  La ruta del archivo del dispositivo nulo. Por ejemplo: `'/dev/null'` para POSIX, `'nul'` para Windows. También disponible a través de `os.path`.

`os.``RTLD_LAZY`
`os.``RTLD_NOW`
`os.``RTLD_GLOBAL`
`os.``RTLD_LOCAL`
`os.``RTLD_NODELETE`
`os.``RTLD_NOLOAD`
`os.``RTLD_DEEPBIND`

  Flags para usar con las funciones `setdlopenflags()` y `getdlopenflags()`. Consulte la página del manual de Unix dlopen(3) para saber qué significan las diferentes flags.

  Nuevo en la versión 3.3.

## Números al azar

`os.``getrandom`(size, flags=0)

  Obtiene hasta size bytes aleatorios. La función puede retornar menos bytes que los solicitados.

  Estos bytes se pueden usar para generar generadores de números aleatorios en el espacio del usuario o para fines criptográficos.

  `getrandom()` se basa en la entropía obtenida de los controladores de dispositivos y otras fuentes de ruido ambiental. La lectura innecesaria de grandes cantidades de datos tendrá un impacto negativo en otros usuarios de los dispositivos `/dev/random` y `/dev/urandom`.

  El argumento de las flags es una máscara de bits que puede contener cero o más de los siguientes valores OR juntos:: py `os.GRND_RANDOM` y `GRND_NONBLOCK`.

  Consulte también la página del manual Linux getrandom().

  Disponibilidad: Linux 3.17 y más reciente.

  Nuevo en la versión 3.6.

`os.``urandom`(size)

  Return a bytestring of size random bytes suitable for cryptographic use.

  Esta función retorna bytes aleatorios de una fuente de aleatoriedad específica del sistema operativo. Los datos retornados deben ser lo suficientemente impredecibles para las aplicaciones criptográficas, aunque su calidad exacta depende de la implementación del sistema operativo.

  En Linux, si la llamada al sistema `getrandom()` está disponible, se usa en modo de bloqueo: bloquee hasta que el grupo de entropía urandom del sistema se inicialice (el núcleo recopila 128 bits de entropía). Ver el PEP 524 para la justificación. En Linux, la función `getrandom()` puede usarse para obtener bytes aleatorios en modo sin bloqueo (usando el indicador `GRND_NONBLOCK`) o para sondear hasta que el grupo de entropía urandom del sistema se inicialice.

  En un sistema tipo Unix, los bytes aleatorios se leen desde el dispositivo `/dev/urandom`. Si el dispositivo `/dev/urandom` no está disponible o no es legible, se genera la excepción `NotImplementedError`.

  En Windows, usará `CryptGenRandom()`.

  Ver también

  El módulo `secrets` proporciona funciones de nivel superior. Para obtener una interfaz fácil de usar con el generador de números aleatorios proporcionado por su plataforma, consulte `random.SystemRandom`.

  Distinto en la versión 3.6.0: En Linux, `getrandom()` ahora se usa en modo de bloqueo para aumentar la seguridad.

  Distinto en la versión 3.5.2: En Linux, si el syscall `getrandom()` bloquea (el grupo de entropía urandom aún no está inicializado), recurra a la lectura `/dev/urandom`.

  Distinto en la versión 3.5: En Linux 3.17 y versiones posteriores, la llamada al sistema `getrandom()` ahora se usa cuando está disponible. En OpenBSD 5.6 y posterior, ahora se usa la función C `getentropy()`. Estas funciones evitan el uso de un descriptor de archivo interno.

`os.``GRND_NONBLOCK`

  Por defecto, cuando lee desde `/dev/random`, `getrandom()` bloquea si no hay bytes aleatorios disponibles, y cuando lee desde `/dev/urandom`, bloquea si el grupo de entropía no tiene, sin embargo, se ha inicializado.

  Si se establece el indicador `GRND_NONBLOCK`, entonces `getrandom()` no se bloquea en estos casos, sino que inmediatamente genera `BlockingIOError`.

  Nuevo en la versión 3.6.

`os.``GRND_RANDOM`

  Si se establece este bit, los bytes aleatorios se extraen del grupo `/dev/random` en lugar del grupo `/dev/urandom`.

  Nuevo en la versión 3.6.