"os" — Diverses interfaces pour le système d'exploitation
*********************************************************

**Code source:** Lib/os.py

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

Ce module fournit une manière portable d'utiliser les fonctionnalités
dépendantes du système d'exploitation. Si vous voulez uniquement lire
ou écrire dans un fichier, voir "open()", si vous voulez manipuler des
chemins, voir le module "os.path", et si vous voulez lire toutes les
lignes de tous les fichiers listés par l'invite de commande, voir le
module "fileinput". Pour créer des fichiers temporaires, voir le
module "tempfile", et pour une manipulation haut niveau des fichiers
et dossiers, voir le module "shutil".

Notes sur la disponibilité de ces fonctions :

* La conception des modules natifs Python dépendants du système
  d'exploitation est qu'une même fonctionnalité utilise une même
  interface. Par exemple, la fonction "os.stat(path)" renvoie des
  informations sur les statistiques de *path* dans le même format (qui
  est originaire de l'interface POSIX).

* Les extensions propres à un certain système d'exploitation sont
  également disponible par le module "os", mais les utiliser est bien
  entendu une menace pour la portabilité.

* Toutes les fonctions acceptant les chemins ou noms de fichiers
  acceptent aussi bien des *bytes* que des *string*, et si un chemin
  ou un nom de fichier est renvoyé, il sera du même type.

Note:

  All functions in this module raise "OSError" (or subclasses thereof)
  in the case of invalid or inaccessible file names and paths, or
  other arguments that have the correct type, but are not accepted by
  the operating system.

exception os.error

   Un alias pour les exceptions natives "OSError".

os.name

   Le nom du module importé dépendant du système d'exploitation.  Les
   noms suivants ont actuellement été enregistrés : "'posix'", "'nt'",
   "'java'".

   Voir aussi:

     "sys.platform" a une granularité plus fine. "os.uname()" donne
     des informations de version dépendantes de système.

     Le module "platform" fournit des vérifications détaillées pour
     l'identité du système.


Noms de fichiers, arguments en ligne de commande, et variables d'environnement
==============================================================================

En Python, les noms de fichiers, les arguments en ligne de commandes,
et les variables d'environnement sont représentées en utilisant le
type *string*. Sur certains systèmes, décoder ces chaînes de
caractères depuis et vers des *bytes* est nécessaire avant de les
passer au système d'exploitation. Python utilise l'encodage du système
de fichiers pour réaliser ces conversions (voir
"sys.getfilesystemencoding()").

Modifié dans la version 3.1: Sur certains systèmes, les conversions
utilisant l'encodage du système de fichiers peut échouer. Dans ce cas,
Python utilise le surrogateescape encoding error handler (le
gestionnaire d'erreurs d'encodage *surrogateescape*), ce qui veut dire
que les bytes indécodables sont replacés par un caractère Unicode
U+DCxx au décodage, et ceux-ci sont retraduits en le bon octet à
l'encodage.

L'encodage du système de fichiers doit garantir de pouvoir décoder
correctement tous les octets en dessous de 128. Si l'encodage du
système de fichiers ne peut garantir cela, les fonctions de l'API
peuvent lever une UnicodeError.


Paramètres de processus
=======================

Ces fonctions et valeurs fournissent des informations et agissent sur
le processus actuel et sur l'utilisateur.

os.ctermid()

   Renvoie l'identifiant de fichier correspondant au terminal
   contrôlant le processus.

   Disponibilité : Unix.

os.environ

   Un objet *mapping* représentant les variables d'environnement. Par
   exemple "environ['HOME']" est le chemin vers votre répertoire
   d’accueil (sur certaines plate-formes), et est équivalent à
   "getenv("HOME")" en C.

   Ce *mapping* est capturé la première fois que le module "os" est
   importé, typiquement pendant le démarrage de Python, lors de
   l'exécution de "site.py". Les changements de l'environnement opérés
   après cette capture ne sont pas répercutés dans "os.environ", à
   part les modifications directes de "os.environ".

   Si la plate-forme prend en charge la fonction "putenv()", ce
   *mapping* peut être utilisé pour modifier l'environnement autant
   que pour l'interroger. "putenv()" sera appelée automatiquement
   quand le *mapping* sera modifié.

   Sur Unix, les clefs et les valeurs utilisent
   "sys.getfilesystemencoding()" et le gestionnaire d'erreurs
   "surrogateescape". Utilisez "environb" si vous désirez utiliser un
   encodage différent.

   Note:

     Appeler "putenv()" ne change pas directement "os.environ", donc
     il est préférable de modifier "os.environ".

   Note:

     Sur certaines plate-formes, dont FreeBSD et Mac OS X, procéder à
     des assignations sur "environ" peut causer des fuites de mémoire.
     Referez-vous à la documentation système de "putenv()".

   Si "putenv()" n'est pas fourni, une copie modifiée de ce
   dictionnaire peut être passé aux fonctions appropriées de création
   de processus pour forcer l'utilisation d'un environnement modifié
   pour le processus fils.

   Si la plate-forme prend en charge la fonction "unsetenv()", vous
   pouvez supprimer des éléments de ce dictionnaire pour supprimer des
   variables d'environnement. La fonction "unsetenv()" sera appelée
   automatiquement quand un élément est supprimé de "os.environ", ou
   quand l'une des méthodes "pop()" ou "clear()" est appelée.

os.environb

   Une version en *bytes* de "environ" : un *mapping* d'objets
   représentant l'environnement par des chaîne de *bytes*. "environ"
   et "environb" sont synchronisés (modifier "environ" modifie
   "environb", et vice-versa).

   "environb" is only available if "supports_bytes_environ" is "True".

   Nouveau dans la version 3.2.

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

   Ces fonctions sont décrites dans Fichiers et répertoires.

os.fsencode(filename)

   Encode le *chemin-compatible* *filename* vers l'encodage du système
   de fichiers avec une gestion d'erreurs "'surrogateescape'", ou
   "'strict'" sous Windows ; renvoie un objet "bytes" inchangé.

   "fsdecode()" est la fonction inverse.

   Nouveau dans la version 3.2.

   Modifié dans la version 3.6: Ajout de la prise en charge des objets
   implémentant l'interface "os.PathLike".

os.fsdecode(filename)

   Encode le *chemin-compatible* *filename* depuis l'encodage du
   système de fichiers avec une gestion d'erreurs "'surrogateescape'",
   ou "'strict'" sous Windows ; renvoie un objet "str" inchangé.

   "fsencode()" est la fonction inverse.

   Nouveau dans la version 3.2.

   Modifié dans la version 3.6: Ajout de la prise en charge des objets
   implémentant l'interface "os.PathLike".

os.fspath(path)

   Renvoie la représentation par le système de fichiers du chemin.

   Si un objet "str" ou "bytes" est passé, il est renvoyé inchangé.
   Autrement, "__fspath__()" est appelée et sa valeur renvoyée tant
   qu'elle est un objet "str" ou "bytes". Dans tous les autres cas,
   une "TypeError" est levée.

   Nouveau dans la version 3.6.

class os.PathLike

   Une *abstract base class* pour les objets représentant un chemin du
   système de fichiers, comme "pathlib.PurePath".

   Nouveau dans la version 3.6.

   abstractmethod __fspath__()

      Renvoie la représentation du chemin du système de fichiers de
      l'objet.

      La méthode ne devrait renvoyer que des objets "str" ou "bytes",
      avec une préférence pour les "str".

os.getenv(key, default=None)

   Renvoie la valeur de la variable d'environnement *key* si elle
   existe, ou *default* si elle n'existe pas. *key*, *default*, et la
   valeur de retour sont des *str*.

   Sur Unix, les clefs et les valeurs sont décodées avec
   "sys.getfilesystemencoding()" et le gestionnaire d'erreurs
   "surrogateescape". Utilisez "os.getenvb()" si vous voulez utiliser
   un encodage différent.

   Disponibilité : la plupart des dérivés Unix, Windows.

os.getenvb(key, default=None)

   Renvoie la valeur de la variable d'environnement *key* si elle
   existe, ou *default* si elle n'existe pas. *key*, *default*, et la
   valeur de retour sont des *bytes*.

   "getenvb()" is only available if "supports_bytes_environ" is
   "True".

   Disponibilité : la plupart des dérivés Unix.

   Nouveau dans la version 3.2.

os.get_exec_path(env=None)

   Renvoie la liste des dossier qui seront parcouru pour trouver un
   exécutable, similaire à un shell lorsque il lance un processus.
   *env*, quand spécifié, doit être un dictionnaire de variable
   d'environnement  afin d'y rechercher le PATH. Par défaut quand
   *env* est "None", "environ" est utilisé.

   Nouveau dans la version 3.2.

os.getegid()

   Renvoie l'identifiant du groupe effectif du processus actuel. Ça
   correspond au bit "*set id*" du fichier qui s'exécute dans le
   processus actuel.

   Disponibilité : Unix.

os.geteuid()

   Renvoie l'identifiant de l'utilisateur effectif du processus
   actuel.

   Disponibilité : Unix.

os.getgid()

   Renvoie l'identifiant de groupe réel du processus actuel.

   Disponibilité : Unix.

os.getgrouplist(user, group)

   Renvoie la liste d'identifiants de groupes auxquels *user*
   appartient. Si *group* n'est pas dans la liste, il y est inclus.
   Typiquement, *group* vaut le *group ID* de l'enregistrement
   *passwd* de *user*.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.getgroups()

   Renvoie une liste d'identifiants de groupes additionnels associés
   au processus actuel.

   Disponibilité : Unix.

   Note:

     Sur Mac OS X, le comportement de "getgroups()" diffère légèrement
     des autres plate-formes Unix. Si l'interpréteur Python était
     compilé avec une cible de déploiement de "10.5" ou moins,
     "getgroups()" renverrait la liste des identifiants de groupes
     effectifs associés au processus courant de l'utilisateur ; le
     nombre d'éléments de cette liste est limité par le système,
     typiquement 16, et peut être modifié par des appels à
     "setgroups()" si les privilèges ont été convenablement assignés.
     Si compilé avec une cible de déploiement supérieure à "10.5", la
     fonction "getgroups()" renvoie la liste des accès du groupe
     actuel pour l'utilisateur associé à l'identifiant utilisateur du
     processus ; la liste d'accès du groupe peut changer durant la vie
     du processus, elle n'est pas affectée par les appels à
     "setgroups()" et sa longueur n'est pas limitée à 16.  La valeur
     de la cible de déploiement, "MACOSX_DEPLOYMENT_TARGET", peut être
     obtenue par la fonction "sysconfig.get_config_var()".

os.getlogin()

   Renvoie le nom de l'utilisateur connecté sur le terminal contrôlant
   le processus. Dans la plupart des cas, il est plus utile d'utiliser
   "getpass.getuser()" puisque cette fonction consulte les variables
   d'environnement "LOGNAME" et "USERNAME" pour savoir qui est
   l'utilisateur, et se replie finalement sur
   "pwd.getpwduid(os.getuid())[0]" pour avoir le nom de connexion lié
   à l'identifiant de l'utilisateur courant.

   Disponibilité : Unix, Windows.

os.getpgid(pid)

   Renvoie l'identifiant de groupe de processus du processus de PID
   *pid*. Si *pid* vaut 0, l'identifiant de groupe de processus du
   processus actuel est renvoyé.

   Disponibilité : Unix.

os.getpgrp()

   Renvoie l'identifiant du groupe de processus actuel.

   Disponibilité : Unix.

os.getpid()

   Renvoie l'identifiant du processus actuel.

os.getppid()

   Renvoie l'identifiant du processus parent. Quand le processus
   parent est terminé, sur Unix, l'identifiant renvoyé est 1 pour le
   processus *init*, sur Windows, c'est toujours le même id, qui peut
   déjà avoir été réutilisé par un autre processus.

   Disponibilité : Unix, Windows.

   Modifié dans la version 3.2: Prise en charge sur Windows.

os.getpriority(which, who)

   Récupère la priorité d'ordonnancement des programmes. La valeur
   *which* est une des constantes suivantes : "PRIO_PROCESS",
   "PRIO_PGRP", ou "PRIO_USER", et la valeur *who* est interprétée par
   rapport à *which* (un id de processus pour "PRIO_PROCESS", un id de
   groupe de processus pour "PRIO_PGRP", et un id d'utilisateur pour
   "PRIO_USER"). Une valeur nulle pour *who* dénote (respectivement)
   le processus appelant, le groupe de processus du processus
   appelant, ou l'identifiant d'utilisateur réel du processus
   appelant.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.PRIO_PROCESS
os.PRIO_PGRP
os.PRIO_USER

   Paramètres pour les fonctions "getpriority()" et "setpriority()".

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.getresuid()

   Renvoie un *tuple* (*ruid*, *euid*, *suid*) dénotant les
   identifiants de l'utilisateur réel, effectif et sauvé du processus
   actuel.

   Disponibilité : Unix.

   Nouveau dans la version 3.2.

os.getresgid()

   Renvoie un *tuple* (*rgid*, *egid*, *sgid*) dénotant les
   identifiants des groupes de processus réel effectif, et sauvé du
   processus actuel.

   Disponibilité : Unix.

   Nouveau dans la version 3.2.

os.getuid()

   Renvoie l'identifiant réel du processus actuel.

   Disponibilité : Unix.

os.initgroups(username, gid)

   Appelle la fonction système *initgroups* pour initialiser la liste
   des groupes d'accès des groupes dont *username* est membre, plus le
   groupe spécifié par *gid*.

   Disponibilité : Unix.

   Nouveau dans la version 3.2.

os.putenv(key, value)

   Assigne la chaîne de caractères *value* à la variable
   d'environnement *key*. De tels changements à l'environnement
   affectent les sous-processus lancés par "os.system()", "popen()" ou
   "fork()" et "execv()".

   Disponibilité : la plupart des dérivés Unix, Windows.

   Note:

     Sur certaines plate-formes, incluant FreeBSD et Mac OS X,
     assigner "environ" peut causer des fuites de mémoire. Referez-
     vous à la documentation système de *putenv*.

   Quand "putenv()" est géré, les assignations d'éléments dans
   "os.environ" sont automatiquement traduites en appels
   correspondants à "putenv()". Cependant, des appels à "putenv()" ne
   mettent pas "os.environ" à jour. Il est donc préférable d'assigner
   les éléments de "os.environ".

os.setegid(egid)

   Définit l'identifiant du groupe de processus effectif du processus
   actuel.

   Disponibilité : Unix.

os.seteuid(euid)

   Définit l'identifiant de l'utilisateur effectif du processus
   actuel.

   Disponibilité : Unix.

os.setgid(gid)

   Définit l'identifiant du groupe de processus actuel.

   Disponibilité : Unix.

os.setgroups(groups)

   Place *groups* dans la liste d'identifiants de groupes additionnels
   associée. *groups* doit être une séquence, et chaque élément doit
   être un nombre entier identifiant un groupe. Cette opération est
   typiquement disponible uniquement pour le super utilisateur.

   Disponibilité : Unix.

   Note:

     Sur Mac OS X, la longueur de *groups* ne peut pas dépasser le
     nombre maximum d'identifiants effectifs de groupes défini par le
     système, typiquement 16. Voir la documentation de "getgroups()"
     pour les cas où *getgroups* ne renvoie pas la même liste de
     groupes que celle définie par l'appel à *setgroups*.

os.setpgrp()

   Produit l'appel système "setpgrp()" ou "setpgrp(0, 0)" selon la
   version implémentée (s'il y en a une). Voir le manuel Unix pour la
   sémantique de l'opération.

   Disponibilité : Unix.

os.setpgid(pid, pgrp)

   Produit l'appel système "setpgid()" pour placer l'identifiant du
   groupe de processus contenant le processus d'identifiant *pid* dans
   le groupe de processus d'identifiant *pgrp*. Voir le manuel Unix
   pour la sémantique.

   Disponibilité : Unix.

os.setpriority(which, who, priority)

   Définit la priorité d'ordonnancement des programmes. La valeur
   *which* est une des constantes suivantes : "PRIO_PROCESS",
   "PRIO_PGRP", ou "PRIO_USER", et *who* est interprété en fonction de
   *which* (un PID pour "PRIO_PROCESS", un identifiant de groupe de
   processus pour "PRIO_PGRP", et un identifiant d'utilisateur pour
   "PRIO_USER"). Une valeur nulle pour *who* dénote (respectivement)
   le processus appelant, le groupe de processus du processus
   appelant, ou l'identifiant de l'utilisateur réel du processus
   appelant. *priority* est une valeur comprise entre "-20" et "19".
   La priorité par défaut est 0 ; les priorités plus faibles amènent à
   un ordonnancement plus favorable.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.setregid(rgid, egid)

   Définit l'identifiant des groupes réel et effectif du processus
   actuel.

   Disponibilité : Unix.

os.setresgid(rgid, egid, sgid)

   Définit l'identifiant des groupes réel, effectif et sauvé du
   processus actuel.

   Disponibilité : Unix.

   Nouveau dans la version 3.2.

os.setresuid(ruid, euid, suid)

   Définit l'identifiant des utilisateurs réel, effectif et sauvé du
   processus actuel.

   Disponibilité : Unix.

   Nouveau dans la version 3.2.

os.setreuid(ruid, euid)

   Définit l'identifiant des utilisateurs réel et effectif du
   processus actuel.

   Disponibilité : Unix.

os.getsid(pid)

   Produit l'appel système "getsid()". Voir le manuel Unix pour la
   sémantique.

   Disponibilité : Unix.

os.setsid()

   Produit l'appel système "setsid()". Voir le manuel Unix pour la
   sémantique.

   Disponibilité : Unix.

os.setuid(uid)

   Définit l'identifiant de l'utilisateur du processus actuel.

   Disponibilité : Unix.

os.strerror(code)

   Renvoie le message d'erreur correspondant au code d'erreur *code*.
   Sur les plate-formes où "strerror()" renvoie "NULL" quand un numéro
   d'erreur inconnu est donné, une "ValueError" est levée.

os.supports_bytes_environ

   "True" si le type natif de l'environnement du système
   d'exploitation est *bytes* (par exemple : "False" sur Windows).

   Nouveau dans la version 3.2.

os.umask(mask)

   Définit le *umask* actuel et renvoie la valeur précédente.

os.uname()

   Renvoie des informations identifiant le système d'exploitation
   actuel. La valeur de retour est un objet à cinq attributs :

   * "sysname" — nom du système d'exploitation

   * "noedname" — nom de la machine sur le réseau (dépendant de
     l'implémentation)

   * "release" — *release* du système d'exploitation

   * "version" — version du système d'exploitation

   * "machine" — identifiant du matériel

   Pour la rétrocompatibilité, cet objet est également itérable, se
   comportant comme un quintuplet contenant "sysname", "nodename",
   "release", "version", et "machine" dans cet ordre.

   Certains systèmes tronquent "nodename" à 8 caractères ou à la
   composante dominante. Un meilleur moyen de récupérer le nom de
   l'hôte est "socket.gethostname()" ou encore
   "socket.gethostbyaddre(socket.gethostname())".

   Disponibilité : dérivés récents de Unix.

   Modifié dans la version 3.3: Type de retour changé d'un *tuple* en
   un objet compatible avec le type *tuple*, avec des attributs
   nommés.

os.unsetenv(key)

   Supprime la variable d'environnement appelée *key*. De tels
   changements à l'environnement affectent les sous-processus lancés
   avec "os.system()", "popen()" ou "fork()" et "execv()".

   Quand "unsetenv()" est gérée, la suppression d'éléments dans
   "os.environ" est automatiquement interprétée en un appel
   correspondant à "unsetenv()", mais les appels à "unsetenv()" ne
   mettent pas "os.environ" à jour. Donc il est préférable de
   supprimer les éléments de "os.environ".

   Disponibilité : la plupart des dérivés Unix.


Création de fichiers objets
===========================

Cette fonction crée de nouveaux *fichiers objets*. (Voir aussi
"open()" pour ouvrir des descripteurs de fichiers).

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

   Renvoie un fichier objet ouvert connecté au descripteur de fichier
   *fd*. C'est un alias de la primitive "open()" et accepte les mêmes
   arguments. La seule différence est que le premier argument de
   "fdopen()" doit toujours être un entier.


Opérations sur les descripteurs de fichiers
===========================================

Ces fonctions opèrent sur des flux d'entrées/sorties référencés par
des descripteurs de fichiers.

Les descripteurs de fichiers sont de petits entiers correspondant à un
fichier qui a été ouvert par le processus courant. Par exemple,
l'entrée standard est habituellement le descripteur de fichier 0, la
sortie standard est 1, et le flux standard d'erreur est 2. Les autres
fichiers ouverts par un processus vont se voir assigner 3, 4, 5, etc.
Le nom "descripteur de fichier" est légèrement trompeur : sur les
plate-formes Unix, les connecteurs (*socket* en anglais) et les tubes
(*pipe* en anglais) sont également référencés par des descripteurs.

La méthode "fileno()" peut être utilisée pour obtenir le descripteur
de fichier associé à un *file object* quand nécessaire. Notez
qu'utiliser le descripteur directement outrepasse les méthodes du
fichier objet, ignorant donc des aspects tels que la mise en tampon
interne des données.

os.close(fd)

   Ferme le descripteur de fichier *fd*.

   Note:

     Cette fonction est destinée aux opérations d'entrées/sorties de
     bas niveau et doit être appliquée à un descripteur de fichier
     comme ceux donnés par "os.open()" ou "pipe()". Pour fermer un
     "fichier objet" renvoyé par la primitive "open()", "popen()" ou
     "fdopen()", il faut utiliser sa méthode "close()".

os.closerange(fd_low, fd_high)

   Ferme tous les descripteurs de fichiers entre *fd_low* (inclus)
   jusque *fd_high* (exclus), en ignorant les erreurs. Équivalent
   (mais beaucoup plus rapide) à :

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

os.device_encoding(fd)

   Renvoie une chaîne de caractères décrivant l'encodage du
   périphérique associé à *fd* s'il est connecté à un terminal, sinon
   renvoie "None".

os.dup(fd)

   Renvoie une copie du descripteur de fichier *fd*. Le nouveau
   descripteur de fichier est non-héritable.

   Sur Windows, quand un flux standard est dupliqué (0 : *stdin*, 1 :
   *stdout*, 2 : *stderr*), le nouveau descripteur de fichier est
   héritable.

   Modifié dans la version 3.4: Le nouveau descripteur de fichier est
   maintenant non-héritable.

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

   Copie le descripteur de fichier *fd* dans *fd2*, en fermant le
   second d'abord si nécessaire. Renvoie *fd2*. Le nouveau descripteur
   de fichier est héritable par défaut, ou non-héritable si
   *inheritable* vaut "False".

   Modifié dans la version 3.4: Ajout du paramètre optionnel
   *inheritable*.

   Modifié dans la version 3.7: Renvoie *fd2* en cas de succès.
   Auparavant, "None" était toujours renvoyé.

os.fchmod(fd, mode)

   Change le mode du fichier donné par *fd* en la valeur numérique
   *mode*. Voir la documentation de "chmod()" pour les valeurs
   possibles de *mode*. Depuis Python 3.3, c'est équivalent à
   "os.chmod(fd, mode)".

   Disponibilité : Unix.

os.fchown(fd, uid, gid)

   Change le propriétaire et l'identifiant de groupe du fichier donné
   par *fd* en les valeurs numériques *uid* et *gid*. Pour laisser
   l'un des identifiants inchangés, mettez-le à "-1". Voir "chown()".
   Depuis Python 3.3, c'est équivalent à "os.chown(fd, uid, gid)".

   Disponibilité : Unix.

os.fdatasync(fd)

   Force l'écriture du fichier ayant le descripteur *fd* sur le
   disque. Ne force pas la mise à jour des méta-données.

   Disponibilité : Unix.

   Note:

     Cette fonction n'est pas disponible sur MacOS.

os.fpathconf(fd, name)

   Renvoie les informations de la configuration du système pour un
   fichier ouvert. *name* spécifie la valeur de la configuration à
   récupérer, ça peut être une chaîne de caractères avec le nom d'une
   valeur système définie ; ces valeurs sont spécifiées dans certains
   standards (POSIX.1, Unix 95, Unix 98, et d'autres). Certaines
   plate-formes définissent des noms additionnels également. Les noms
   connus par le système d'exploitation sont donnés dans le
   dictionnaire "pathconf_names". Pour les variables de configuration
   qui ne sont pas inclues dans ce *mapping*, passer un entier pour
   *name* est également accepté.

   Si *name* est une chaîne de caractères et n'est pas connu, une
   "ValueError" est levée. Si une valeur spécifique de *name* n'est
   pas gérée par le système hôte, même si elle est incluse dans
   "pathconf_names", une "OSError" est levée avec "errno.EINVAL" pour
   code d'erreur.

   Depuis Python 3.3, c'est équivalent à "os.pathconf(fd, name)".

   Disponibilité : Unix.

os.fstat(fd)

   Récupère le statut du descripteur de fichier *fd*. Renvoie un objet
   "stat_result".

   Depuis Python 3.3, c'est équivalent à "os.stat(fd)".

   Voir aussi: La fonction "stat()".

os.fstatvfs(fd)

   Renvoie des informations sur le système de fichier contenant le
   fichier associé au descripteur *fd*, comme "statvfs()". Depuis
   Python 3.3, c'est équivalent à "os.statvfs(fd)".

   Disponibilité : Unix.

os.fsync(fd)

   Force l'écriture du fichier ayant le descripteur *fd* sur le
   disque. Sur Unix, cet appel appel la fonction native "fsync()", sur
   Windows, la fonction MS "_commit()".

   Si vous débutez avec un *file object* Python mis en tampon *f*,
   commencez par faire "f.flush()" et seulement ensuite
   "os.fsync(f.fileno())" pour être sûr que tous les tampons internes
   associés à *f* soient écrits sur le disque.

   Disponibilité : Unix, Windows.

os.ftruncate(fd, length)

   Tronque le fichier correspondant au descripteur *fd* pour qu'il
   soit maximum long de *length* *bytes*. Depuis Python 3.3, c'est
   équivalent à "os.truncate(fd, length)".

   Disponibilité : Unix, Windows.

   Modifié dans la version 3.5: Prise en charge de Windows

os.get_blocking(fd)

   Récupère le mode bloquant du descripteur de fichier : "False" si
   l'indicateur "O_NONBLOCK" est mis, et "True" si l'indicateur est
   effacé.

   Voir également "set_blocking()" et "socket.socket.setblocking()".

   Disponibilité : Unix.

   Nouveau dans la version 3.5.

os.isatty(fd)

   Renvoie "True" si le descripteur de fichier *fd* est ouvert et
   connecté à un périphérique TTY (ou compatible), sinon "False".

os.lockf(fd, cmd, len)

   Applique, teste, ou retire un verrou POSIX sur un descripteur de
   fichier ouvert. *fd* est un descripteur de fichier ouvert. *cmd*
   spécifie la commande à utiliser (une des valeurs suivantes :
   "F_LOCK", "F_TLOCK", "F_ULOCK", ou "F_TEST"). *len* spécifie la
   section du fichier à verrouiller.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

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

   Indicateurs spécifiant quelle action "lockf()" va prendre.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.lseek(fd, pos, how)

   Place la position actuelle du descripteur de fichier *fd* à la
   position *pos*, modifié par *how* : "SEEK_SET" ou "0" pour placer
   la position à partir du début du fichier, "SEEK_CUR" ou "1" pour la
   placer à partir de la position actuelle, et "SEEK_END" ou "2" pour
   la placer par rapport à la fin du fichier. Renvoie la nouvelle
   position du curseur en bytes, à partir du début.

os.SEEK_SET
os.SEEK_CUR
os.SEEK_END

   Paramètres de la fonction "lseek()". Leur valeur est respectivement
   0, 1, et 2.

   Nouveau dans la version 3.3: Certains systèmes d'exploitation
   pourraient gérer des valeurs additionnelles telles que
   "os.SEEK_HOLE" ou "os.SEEK_DATA".

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

   Ouvre le fichier *path* et met certains indicateurs selon *flags*
   et éventuellement son mode selon *mode*. Lors de l'évaluation de
   *code*, ce *umask* actuel est d'abord masquée. Renvoie le
   descripteur de fichier du fichier nouvellement ouvert. Le nouveau
   descripteur de fichier est non-héritable.

   Pour une description des indicateurs et des valeurs des modes, voir
   la documentation de la bibliothèque standard du C. Les constantes
   d'indicateurs (telles que "O_RDONLY" et "O_WRONLY") sont définies
   dans le module "os". En particulier, sur Windows, ajouter
   "O_BINARY" est nécessaire pour ouvrir des fichiers en binaire.

   Cette fonction prend en charge des chemins relatifs à des
   descripteurs de répertoires avec le paramètre *dir_fd*.

   Modifié dans la version 3.4: Le nouveau descripteur de fichier est
   maintenant non-héritable.

   Note:

     Cette fonction est destinée aux E/S de bas-niveau. Pour un usage
     normal, utilisez la primitive "open()" qui renvoie un *file
     object* avec les méthodes "read()" et "write()" (et plein
     d'autres). Pour envelopper un descripteur de fichier dans un
     fichier objet, utilisez "fdopen()".

   Nouveau dans la version 3.3: L'argument *dir_fd*.

   Modifié dans la version 3.5: Si l'appel système est interrompu et
   que le gestionnaire de signal ne lève aucune exception, la fonction
   réessaye l'appel système au lieu de lever une "InterruptedError"
   (voir la **PEP 475** à propos du raisonnement).

   Modifié dans la version 3.6: Accepte un *path-like object*.

Les constantes suivantes sont optionnelles pour le paramètre *flag* à
la fonction "open()". Elles peuvent être combinées en utilisant
l'opérateur bit-à-bit OR "|". certains ne sont pas disponibles sur
toutes les plate-formes. Pour une description sur leur disponibilité
et leur usage, consultez la page de manuel Unix *open(2)* ou la MSDN
sur Windows.

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

   Les constantes ci-dessus sont disponibles sur Unix et Windows.

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

   Les constantes ci-dessus sont uniquement disponibles sur Unix.

   Modifié dans la version 3.3: Ajout de la constante "O_CLOCEXEC".

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

   Les constantes ci-dessus sont uniquement disponibles sur 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

   Les constantes ci-dessus sont des extensions et ne sont pas
   présentes si elles ne sont pas définies par la bibliothèque C.

   Modifié dans la version 3.4: Ajout de "O_PATH" sur les systèmes qui
   le gèrent. Ajout de "O_TMPFILE", uniquement disponible sur Linux
   Kernel 3.11 ou plus récent.

os.openpty()

   Ouvre une nouvelle paire pseudo-terminal. Renvoie une paire de
   descripteurs de fichiers "(master, slave)" pour le PTY et le TTY
   respectivement. Les nouveaux descripteurs de fichiers sont non-
   héritables. Pour une approche (légèrement) plus portable, utilisez
   le module "pty".

   Disponibilité : certains dérivés Unix.

   Modifié dans la version 3.4: Les nouveaux descripteurs de fichiers
   sont maintenant non-héritables.

os.pipe()

   Crée un *pipe* (un tube). Renvoie une paire de descripteurs de
   fichiers "(r, w)" utilisables respectivement pour lire et pour
   écrire. Les nouveaux descripteurs de fichiers sont non-héritables.

   Disponibilité : Unix, Windows.

   Modifié dans la version 3.4: Les nouveaux descripteurs de fichiers
   sont maintenant non-héritables.

os.pipe2(flags)

   Crée un *pipe* avec *flags* mis atomiquement. *flags* peut être
   construit en appliquant l'opérateur "|" (OU) sur une ou plus de ces
   valeurs : "O_NONBLOCK", "O_CLOEXEC". Renvoie une paire de
   descripteurs de fichiers "(r, w)" utilisables respectivement pour
   lire et pour écrire.

   Disponibilité : certains dérivés Unix.

   Nouveau dans la version 3.3.

os.posix_fallocate(fd, offset, len)

   Assure que suffisamment d'espace sur le disque est alloué pour le
   fichier spécifié par *fd* partant de *offset* et continuant sur
   *len* bytes.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

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

   Annonce une intention d'accéder à des données selon un motif
   spécifique, et donc permettant au noyau de faire des optimisations.
   Le conseil *advice* s'applique à la région spécifiée par *fd*,
   démarrant à *offset* et continuant sur *len* bytes. *advice* est
   une des valeurs suivantes : "POSIX_FADV_NORMAL",
   "POSIX_FADV_SEQUENTIAL", "POSIX_FADV_RANDOM", "POSIX_FADV_NOREUSE",
   "POSIX_FADV_WILLNEED", ou "POSIX_FADV_DONTNEED".

   Disponibilité : Unix.

   Nouveau dans la version 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

   Indicateurs qui peuvent être utilisés dans *advice* dans la
   fonction "posix_fadvise()" et qui spécifient le motif d'accès qui
   est censé être utilisé.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.pread(fd, n, offset)

   Lit au maximum *n* octets depuis le descripteur de fichier *fd* à
   la position *offset* sans modifier cette position.

   Renvoie une chaîne d'octets contenant les octets lus, ou une chaîne
   d'octets vide si la fin du fichier pointé par *fd* est atteinte.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

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

   Lit depuis un descripteur de fichier *fd*, à la position *offset*
   dans des *objets bytes-compatibles* muables *buffers*, sans
   modifier la position dans le fichier. Les données sont transférées
   dans chaque tampon, jusqu'à ce qu'il soit plein, tour à tour.

   L'argument *flags* contient un OU logique bit-à-bit de zéro ou
   plusieurs des indicateurs suivants :

   * "RWF_HIPRI"

   * "RWF_NOWAIT"

   Renvoie le nombre total d'octets réellement lus, qui peut être
   inférieur à la capacité totale de tous les objets.

   Le système d'exploitation peut définir une limite (valeur
   "sysconf()" "'SC_IOV_MAX'") sur le nombre de mémoires tampons
   pouvant être utilisées.

   Combine les fonctionnalités de "os.readv()" et "os.pread()".

   Disponibilité : Linux 2.6.30 et plus récent, FreeBSD 6.0 et plus
   récent, OpenBSD 2.7 et plus récent. L'utilisation de *flags*
   requiert Linux 4.6 ou plus récent.

   Nouveau dans la version 3.7.

os.RWF_NOWAIT

   Ne pas attendre pour des données qui ne sont pas immédiatement
   disponibles. Si cette option est spécifiée, l'appel système
   retourne instantanément s'il doit lire les données du stockage
   sous-jacent ou attendre un verrou.

   Si certaines données ont été lues avec succès, le nombre d'octets
   lus est renvoyé. Si aucun octet n'a été lu, renvoie "-1" et affecte
   à *errno* la valeur "errno.EAGAIN".

   Disponibilité : Linux 4.14 et ultérieures.

   Nouveau dans la version 3.7.

os.RWF_HIPRI

   Lecture/écriture haute priorité. Permet aux systèmes de fichiers de
   type bloc d'utiliser le *polling* du périphérique, qui fournit une
   latence inférieure, mais peut utiliser des ressources
   supplémentaires.

   Actuellement, sous Linux, cette fonctionnalité est utilisable
   uniquement sur un descripteur de fichier ouvert à l'aide de
   l'option "O_DIRECT".

   Disponibilité : Linux 4.6 et ultérieures.

   Nouveau dans la version 3.7.

os.pwrite(fd, str, offset)

   Écrit la chaîne d'octets de *str* dans le descripteur de fichier
   *fd* à la position *offset* en laissant la position dans le fichier
   inchangée.

   Renvoie le nombre d'octets effectivement écrits.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

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

   Écrit le contenu de *buffers* vers le descripteur de fichier *fd* à
   la position *offset*, en laissant la position du fichier inchangée.
   *buffers* doit être une séquence de *objets bytes-compatibles*. Les
   tampons sont traités dans l'ordre du tableau. Le contenu entier du
   premier tampon est écrit avant le traitement du second, etc.

   L'argument *flags* contient un OU logique bit-à-bit de zéro ou
   plusieurs des indicateurs suivants :

   * "RWF_DSYNC"

   * "RWF_SYNC"

   Renvoie le nombre total d'octets effectivement écrits.

   Le système d'exploitation peut définir une limite (valeur
   "sysconf()" "'SC_IOV_MAX'") sur le nombre de mémoires tampons
   pouvant être utilisées.

   Combine les fonctionnalités de "os. writev()" et "os. pwrite()".

   Disponibilité : Linux 2.6.30 et plus récent, FreeBSD 6.0 et plus
   récent, OpenBSD 2.7 et plus récent. L'utilisation de *flags*
   requiert Linux 4.6 ou plus récent.

   Nouveau dans la version 3.7.

os.RWF_DSYNC

   Fournit un équivalent par écriture de l'option "O_DSYNC" de
   "open(2)". L' effet de cette option s'applique uniquement à la
   plage de données écrite par l'appel système.

   Disponibilité : Linux 4.7 et ultérieures.

   Nouveau dans la version 3.7.

os.RWF_SYNC

   Fournit un équivalent par écriture de l'option  "O_SYNC" de
   "open(2)". L'effet de cette option s'applique uniquement à la plage
   de données écrite par l'appel système.

   Disponibilité : Linux 4.7 et ultérieures.

   Nouveau dans la version 3.7.

os.read(fd, n)

   Lit au maximum *n* octets du descripteur de fichier *fd*.

   Renvoie une chaîne d'octets contenant les octets lus, ou une chaîne
   d'octets vide si la fin du fichier pointé par *fd* est atteinte.

   Note:

     Cette fonction est destinée aux E/S bas niveau et doit être
     appliquée à un descripteur de fichier comme renvoyé par
     "os.open()" ou "pipe()". Pour lire dans un "fichier objet"
     renvoyé par la primitive "open()", "popen()" ou "fdopen()", ou
     par "stdin", utilisez sa méthode "read()" ou "readline()".

   Modifié dans la version 3.5: Si l'appel système est interrompu et
   que le gestionnaire de signal ne lève aucune exception, la fonction
   réessaye l'appel système au lieu de lever une "InterruptedError"
   (voir la **PEP 475** à propos du raisonnement).

os.sendfile(out, in, offset, count)
os.sendfile(out, in, offset, count[, headers][, trailers], flags=0)

   Copie *count* bytes depuis un descripteur de fichier *in* dans un
   descripteur de fichier *out* en démarrant à *offset*. Renvoie le
   nombre de bytes envoyés. Quand EOF est atteint, renvoie 0.

   La première notation de fonction est prise en charge par toutes les
   plate-formes qui définissent "sendfile()".

   Sur Linux, si *offset* est donné par "None", les bytes sont lus
   depuis la position actuelle de *in* et la position de *in* est mise
   à jour.

   Le second cas peut être utilisé sur Mac OS X et FreeBSD où
   *headers* et *trailers* sont des séquences arbitraires de tampons
   qui sont écrites avant et après que les données de *in* ne soient
   écrites. Renvoie la même chose que le premier cas.

   Sur Mac OS X et FreeBSD, une valeur de 0 pour *count* spécifié
   d'envoyer jusqu'à ce que la fin de *in* ne soit atteinte.

   Toutes les plate-formes gèrent les connecteurs comme des
   descripteurs de fichier *out*, et certaines plate-formes autorisent
   d'autres types (par exemple, un fichier normal ou un tube)
   également.

   Les applications multiplate-formes ne devraient pas utiliser les
   arguments  *headers*, *trailers*, et *flags*.

   Disponibilité : Unix.

   Note:

     Pour une interface de plus haut niveau de "sendfile()", voir
     "socket.socket.setfile()".

   Nouveau dans la version 3.3.

os.set_blocking(fd, blocking)

   Définit le mode bloquant d'un descripteur de fichier spécifié.
   Assigne l'indicateur "O_NONBLOCK" si *blocking* vaut "False",
   efface l'indicateur sinon.

   Voir aussi "get_blocking()" et "socket;socket.setblocking()".

   Disponibilité : Unix.

   Nouveau dans la version 3.5.

os.SF_NODISKIO
os.SF_MNOWAIT
os.SF_SYNC

   Paramètres de la fonction "sendfile()", si l'implémentation les
   gère.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.readv(fd, buffers)

   Lit depuis un descripteur de fichier *fd* dans une séquence
   d'*objets bytes-compatibles* muables : *buffers*. Les données sont
   transférées dans chaque tampon, jusqu'à ce qu'il soit plein, tour à
   tour.

   Renvoie le nombre total d'octets réellement lus, qui peut être
   inférieur à la capacité totale de tous les objets.

   Le système d'exploitation peut définir une limite (valeur
   "sysconf()" "'SC_IOV_MAX'") sur le nombre de mémoires tampons
   pouvant être utilisées.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.tcgetpgrp(fd)

   Renvoie le groupe de processus associé au terminal donné par *fd*
   (un descripteur de fichier ouvert comme renvoyé par "os.open()").

   Disponibilité : Unix.

os.tcsetpgrp(fd, pg)

   Place *pg* dans le groupe de processus associé au terminal donné
   par *fd* (un descripteur de fichier ouvert comme renvoyé par
   "os.open()").

   Disponibilité : Unix.

os.ttyname(fd)

   Renvoie une chaîne de caractères spécifiant le périphérique
   terminal associé au descripteur de fichier *fd*. Si *fd* n'est pas
   associé à un périphérique terminal, une exception est levée.

   Disponibilité : Unix.

os.write(fd, str)

   Écrit la chaîne d'octets de *str* vers le descripteur de fichier
   *fd*.

   Renvoie le nombre d'octets effectivement écrits.

   Note:

     Cette fonction est destinée aux entrées-sorties bas niveau et
     doit être appliquée à un descripteur de fichier comme renvoyé par
     "os.open()" ou "pipe()". Pour écrire dans un "fichier objet"
     renvoyé par la primitive "open()", "popen()", ou par "fdopen()",
     ou par "sys.stdout" ou "sys.stderr", utilisez sa méthode
     "write()".

   Modifié dans la version 3.5: Si l'appel système est interrompu et
   que le gestionnaire de signal ne lève aucune exception, la fonction
   réessaye l'appel système au lieu de lever une "InterruptedError"
   (voir la **PEP 475** à propos du raisonnement).

os.writev(fd, buffers)

   Écrit le contenu de *buffers* vers le descripteur de fichier *fd*.
   *buffers* doit être une séquence d'*objets bytes-compatibles*. Les
   tampons sont traités dans l'ordre du tableau. Le contenu entier du
   premier tampon est écrit avant le traitement du second, etc.

   Renvoie le nombre total d'octets effectivement écrits.

   Le système d'exploitation peut définir une limite (valeur
   "sysconf()" "'SC_IOV_MAX'") sur le nombre de mémoires tampons
   pouvant être utilisées.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.


Demander la taille d'un terminal
--------------------------------

Nouveau dans la version 3.3.

os.get_terminal_size(fd=STDOUT_FILENO)

   Renvoie la taille du terminal comme un couple "(columns, lines)" de
   type "terminal_size".

   L'argument optionnel "fd" (par défaut  : "STDOUT_FILENO", ou la
   sortie standard) spécifie le descripteur de fichier auquel la
   requête doit être envoyée.

   Si le descripteur de fichier  n'est pas connecté à un terminal, une
   "OSError" est levée.

   "shutil.get_terminal_size()" est la fonction haut-niveau qui
   devrait normalement être utilisée, "os.get_terminal_size" en est
   l'implémentation bas-niveau.

   Disponibilité : Unix, Windows.

class os.terminal_size

   Une sous-classe de *tuple*, contenant "(columns, lines)", la taille
   du terminal.

   columns

      Longueur du terminal en caractères.

   lines

      Hauteur du terminal en caractères.


Héritage de descripteurs de fichiers
------------------------------------

Nouveau dans la version 3.4.

Un descripteur de fichier a un indicateur indiquant s'il peut être
hérité par les processus-fils. Depuis Python 3.4, les descripteurs de
fichiers créés par Python ne sont pas héritable par défaut.

Sur UNIX, les descripteurs de fichiers non-héritables sont fermés dans
les processus-fils à l'exécution, les autres descripteurs sont
hérités.

Sur Windows, les fichiers et identificateurs non-héritables sont
fermés dans les processus-fils, à part les flux standards
(descripteurs 0, 1, et 2 : *stdin*, *stdout* et *stderr*) qui sont
toujours hérités. En utilisant les fonctions "spawn*", tous les
identificateurs héritables et les descripteurs de fichiers héritables
sont hérités. En utilisant le module "subprocess", tous les
descripteurs de fichiers (à part les flux standards) sont fermés, et
les identificateurs héritables sont hérités seulement si le paramètre
*close_fds* vaut "False".

os.get_inheritable(fd)

   Récupère le marqueur "héritable" (booléen) du descripteur de
   fichier spécifié.

os.set_inheritable(fd, inheritable)

   Définit le marqueur "héritable" du descripteur de fichier spécifié.

os.get_handle_inheritable(handle)

   Récupère le marqueur "héritable" (booléen) de l'identificateur
   spécifié.

   Disponibilité : Windows.

os.set_handle_inheritable(handle, inheritable)

   Définit le marqueur "héritable" de l'identificateur spécifié.

   Disponibilité : Windows.


Fichiers et répertoires
=======================

Sur certaines plate-formes Unix, beaucoup de ces fonctions gèrent une
ou plusieurs des fonctionnalités suivantes :

* **spécifier un descripteur de fichier :** pour certaines fonctions,
  l'argument *path* peut être non seulement une chaîne de caractères
  donnant le chemin vers le fichier, mais également un descripteur de
  fichier. La fonction opérera alors sur le fichier référencé par le
  descripteur. (Pour les systèmes POSIX, Python appellera la version
  "f..." de la fonction.)

  Vous pouvez vérifier si *path* peut être donné par un descripteur de
  fichier sur votre plate-forme en utilisant "os.supports_fd". Si
  c'est indisponible, l'utiliser lèvera une "NotImplementedError".

  Si la fonction gère également les arguments *dir_fd* ou
  *follow_symlinks*, spécifier l'un de ces arguments est une erreur
  quand *path* est donné en tant que  descripteur de fichier.

* **Chemins relatifs vers des descripteurs de répertoires :** si
  *dir_fd* n'est pas "None", il devrait être un descripteur de fichier
  référençant un répertoire, et le chemin sur lequel opérer devrait
  être relatif. Le chemin est donc relatif à ce répertoire. Si le
  chemin est absolu, *dir_fd* est ignoré. (Pour les systèmes POSIX,
  Python appellera la version "...at" ou "f...at" de la fonction.)

  Vous pouvez vérifier si *dir_fd* est géré sur votre plate-forme en
  utilisant "os.supports_dir_fd". Si c'est indisponible, l'utiliser
  lèvera une "NotImplementedError".

* **Non-suivi des symlinks (liens symboliques) :** si
  *follow_symlinks* vaut "False" et le dernier élément du chemin sur
  lequel opérer est un lien symbolique, la fonction opérera sur le
  lien symbolique et pas sur le fichier pointé par le lien. (Pour les
  systèmes POSIX, Python appellera la version "l..." de la fonction.)

  Vous pouvez voir si *follow_symlinks* est géré sur votre plate-forme
  en utilisant "os.supports_follow_symlinks". Si c'est indisponible,
  l'utiliser lèvera une "NotImplementedError".

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

   Utilise l'*uid*/*gid* réel pour tester l'accès à *path*. Notez que
   la plupart des opérations utiliseront l'*uid*/*gid* effectif, dès
   lors cette méthode peut être utilisée dans un environnement
   *suid*/*sgid* pour tester si l'utilisateur invoquant a les droits
   d'accès pour accéder à *path*. *mode* devrait être "F_OK" pour
   tester l'existence de *path*, ou il peut être le OR (OU inclusif)
   d'une ou plusieurs des constantes suivantes : "R_OK", "W_OK", et
   "X_OK" pour tester les permissions. Renvoie "True" si l'accès est
   permis, et "False" s'il ne l'est pas. Voir la page de manuel Unix
   *access(2)* pour plus d'informations.

   Cette fonction peut gérer la spécification de chemins relatifs vers
   des descripteurs de fichiers et le suivi des liens symboliques.

   Si *effective_id* vaut "True", "access()" effectuera ses
   vérifications d'accès en utilisant l'*uid*/*gid* effectif à la
   place de l'*uid*/*gid* réel. *effective_ids* peut ne pas être géré
   sur votre plate-forme, vous pouvez vérifier s'il est disponible en
   utilisant "os.supports_effective_ids". S'il est indisponible,
   l'utiliser lèvera une "NotImplementedError".

   Note:

     Utiliser "access()" pour vérifier si un utilisateur est autorisé
     (par exemple) à ouvrir un fichier avant d'effectivement le faire
     en utilisant "open()" crée une faille de sécurité : l'utilisateur
     peut exploiter le court intervalle de temps entre la vérification
     et l'ouverture du fichier pour le manipuler. Il est préférable
     d'utiliser les techniques *EAFP*. Par exemple :

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

     est mieux écrit comme suit :

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

   Note:

     Les opérations d'entrées/sorties peuvent échouer même quand
     "access()" indique qu'elles devraient réussir, particulièrement
     pour les opérations sur les systèmes de fichiers réseaux qui
     peuvent avoir une sémantique de permissions au-delà du modèle de
     bits de permission usuel POSIX.

   Modifié dans la version 3.3: Paramètres *dir_fd*, *effective_ids*,
   et *follow_symlinks* ajoutés.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Valeurs à passer au paramètre *mode* de "access()" pour tester
   respectivement l'existence, les droits de lecture, d'écriture et
   d'exécution.

os.chdir(path)

   Change le répertoire de travail actuel par *path*.

   Cette fonction prend en charge la spécification d'un descripteur de
   fichier. Le descripteur doit référencer un répertoire ouvert, pas
   un fichier ouvert.

   This function can raise "OSError" and subclasses such as
   "FileNotFoundError", "PermissionError", and "NotADirectoryError".

   Nouveau dans la version 3.3: Prise en charge de la spécification de
   *path* par un descripteur de fichier sur certaines plate-formes.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Définit les marqueurs de *path* par la valeur numérique *flags*.
   *flags* peut prendre une combinaison (OU bit-à-bit) des valeurs
   suivantes (comme défini dans le module "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"

   Cette fonction prend en charge le suivi des liens symboliques.

   Disponibilité : Unix.

   Nouveau dans la version 3.3: L'argument *follow_symlinks*.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Change le mode de *path* par la valeur numérique *mode*. *mode*
   peut prendre une des valeurs suivantes (comme défini dans le module
   "stat") ou une combinaison (OU bit-à-bit) de ces valeurs :

   * "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"

   Cette fonction prend en charge la spécification d'un descripteur de
   fichier, les chemins relatifs à des descripteurs de répertoires, et
   le non-suivi des liens symboliques.

   Note:

     Bien que Windows gère "chmod()", vous ne pouvez y définir que le
     marqueur de lecture-seule du fichier (via les constantes
     "stat.S_IWRITE" et "stat.S_IREAD" ou une constante entière
     correspondante). Tous les autres bits sont ignorés.

   Nouveau dans la version 3.3: Prise en charge de la spécification de
   *path* par un répertoire ouvert et des arguments *dir_fd* et
   *follow_symlinks* ajoutés.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Change l'identifiant du propriétaire et du groupe de *path* par les
   valeurs numériques *uid* et *gid*. Pour laisser l'un de ces
   identifiants inchangé, le définir à "-1".

   Cette fonction prend en charge la spécification d'un descripteur de
   fichier, les chemins relatifs à des descripteurs de répertoires, et
   le non-suivi des liens symboliques.

   Voir "shutil.chown()" pour une fonction de plus haut-niveau qui
   accepte des noms en plus des identifiants numériques.

   Disponibilité : Unix.

   Nouveau dans la version 3.3: Prise en charge de la spécification de
   *path* par un descripteur de fichier ouvert et des arguments
   *dir_fd* et *follow_symlinks* ajoutés.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.chroot(path)

   Change le répertoire racine du processus actuel par *path*.

   Disponibilité : Unix.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.fchdir(fd)

   Change le répertoire de travail actuel par le répertoire représenté
   par le descripteur de fichier *fd*. Le descripteur doit référencer
   un répertoire ouvert, pas un fichier ouvert. Depuis Python 3.3,
   c'est équivalent à "os.chdir(fd)".

   Disponibilité : Unix.

os.getcwd()

   Renvoie une chaîne de caractères représentant le répertoire de
   travail actuel.

os.getcwdb()

   Renvoie une chaîne de *bytes* représentant le répertoire de travail
   actuel.

os.lchflags(path, flags)

   Définit les marqueurs de *path* par la valeur numérique *flags*,
   comme "chflags()", mais ne suit pas les liens symboliques. Depuis
   Python 3.3, c'est équivalent à "os.chflags(path, flags,
   follow_symlinks=False)".

   Disponibilité : Unix.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.lchmod(path, mode)

   Change le mode de *path* par la valeur numérique *mode*. Si *path*
   est un lien symbolique, ça affecte le lien symbolique à la place de
   la cible. Voir la documentation pour les valeurs possibles de
   *mode* pour "chmod()". Depuis Python 3.3, c'est équivalent à
   "os.chmod(path, mode, follow_symlinks=False)".

   Disponibilité : Unix.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.lchown(path, uid, gid)

   Change les identifiants du propriétaire et du groupe de *path* par
   *uid* et *gid*. Cette fonction ne suivra pas les liens symboliques.
   Depuis Python 3.3, c'est équivalent à "os.chown(path, uid, gid,
   follow_symlinks=False)".

   Disponibilité : Unix.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Crée un lien matériel appelé *dst* pointant sur *src*.

   Cette fonction prend en charge la spécification *src_dir_fd* et/ou
   *dst_dir_fd* pour préciser des chemins relatifs à des descripteurs
   de répertoires, et le non-suivi des liens symboliques.

   Disponibilité : Unix, Windows.

   Modifié dans la version 3.2: Prise en charge de Windows.

   Nouveau dans la version 3.3: Arguments *src_dir_fd*, *dst_dir_fd*,
   et *follow_symlinks* ajoutés.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *src* et *dst*.

os.listdir(path='.')

   Renvoie une liste contenant le nom des entrées dans le répertoire
   donné par *path*. La liste est dans un ordre arbitraire et n'inclut
   pas les entrées spéciales "'.'" et "'..'" même si elles sont
   présentes dans le répertoire.

   *path* peut être un *path-like object*.  Si *path* est de type
   "bytes" (directement ou indirectement à travers une interface
   "PathLike"), les noms de fichiers renvoyés seront aussi de type
   "bytes" ; dans toutes les autres circonstances, ils seront de type
   "str".

   Cette fonction peut également gérer la spécification de
   descripteurs de fichiers. Le descripteur doit référencer un
   répertoire.

   Note:

     Pour encoder des noms de fichiers de type "str" en "bytes",
     utilisez la fonction "encode()".

   Voir aussi:

     La fonction "scandir()" renvoie les entrées du répertoire ainsi
     que leurs attributs , offrant une meilleure performance pour
     beaucoup de cas utilisés fréquemment.

   Modifié dans la version 3.2: Le paramètre *path* est devenu
   optionnel.

   Nouveau dans la version 3.3: Prise en charge de la spécification
   d'un descripteur de répertoire pour *path* ajouté.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Effectue l'équivalent d'un appel système "lstat()" sur le chemin
   donné. Similaire à "stat()" mais ne suit pas les liens symboliques.
   Renvoie un objet de type "stat_result".

   Sur les plate-formes qui ne gérant pas les liens symboliques, c'est
   un alias pour "stat()".

   Depuis Python 3.3, c'est équivalent à "os.stat(path, dir_fd=dir_fd,
   follow_symlinks=False)".

   Cette fonction peut également gérer des chemins relatifs à des
   descripteurs de répertoires.

   Voir aussi: La fonction "stat()".

   Modifié dans la version 3.2: Prise en charge des les liens
   symboliques sur Windows 6.0 (Vista).

   Modifié dans la version 3.3: Paramètre *dir_fd* ajouté.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *src* et *dst*.

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

   Crée un répertoire appelé *path* avec pour mode, la valeur
   numérique *mode*.

   Si le répertoire existe déjà, "FileExistsError" est levée.

   Sous certains systèmes, *mode* est ignoré.  Quand il est utilisé,
   il lui est premièrement appliqué le masque courant *umask*.  Si des
   bits autres que les 9 derniers sont activés (i.e. les 3 derniers
   chiffres de la représentation octale de *mode*), leur signification
   sera dépendante de la plate-forme.  Sous certaines plate-formes,
   ils seront ignorés et vous devrez appeler explicitement "chmod()"
   pour les modifier.

   Cette fonction peut également gérer des chemins relatifs à des
   descripteurs de répertoires.

   Il est également possible  de créer des répertoires temporaires,
   voir la fonction "tempfile.mkdtemp()" du module "tempfile".

   Nouveau dans la version 3.3: L'argument *dir_fd*.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Fonction de création récursive de répertoires. Comme "mkdir()" mais
   crée tous les répertoires de niveau intermédiaire nécessaires pour
   contenir le répertoire "feuille".

   Le paramètre *mode* est passé à "mkdir()" pour créer le répertoire
   feuille ; reportez-vous à la description de mkdir() pour la manière
   dont il est interprété. Pour définir les bits de permissions des
   répertoires intermédiaires nouvellement créés, vous pouvez définir
   la valeur de *umask* avant d'invoquer "makedirs()". Les bits de
   permissions des répertoires intermédiaires déjà existants ne sont
   pas modifiés.

   If *exist_ok* is "False" (the default), an "FileExistsError" is
   raised if the target directory already exists.

   Note:

     Un appel à "makedirs()" est confus si les éléments du chemin à
     créer contiennent "pardir" (par exemple, ".." sur les systèmes
     UNIX).

   Cette fonction gère les chemins UNC correctement.

   Nouveau dans la version 3.2: Le paramètre *exist_ok*.

   Modifié dans la version 3.4.1: Avant Python 3.4.1, si *exist_ok*
   valait "True" et le répertoire à créer existait, "makedirs()"
   aurait levé une erreur si *mode* n'était pas équivalent au mode du
   répertoire existant. Puisque ce comportement n'était pas possible )
   implémenter de manière sécurisée, il a été retiré pour Python
   3.4.1. Voir bpo-21082.

   Modifié dans la version 3.6: Accepte un *path-like object*.

   Modifié dans la version 3.7: L'argument *mode* n'affecte plus les
   bits d'autorisation de fichier des répertoires intermédiaires
   créés.

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

   Crée un FIFO (*First In, First Out*, ou un tube (*pipe* en anglais)
   nommé) appelé *path* avec le mode numérique *mode*. La valeur
   actuelle de *umask* est d'abord masquée du mode.

   Cette fonction peut également gérer des chemins relatifs à des
   descripteurs de répertoires.

   Les FIFOs sont des tubes qui peuvent être accédés comme des
   fichiers normaux. Les FIFOs existent jusqu'à ce qu'ils soient
   retirés (par exemple, à l'aide de "os.unlink()"). Généralement, les
   FIFOs sont utilisé comme communication entre des processus de type
   "client" et "serveur" : le serveur ouvre le FIFO pour le lire, et
   le client l'ouvre pour écrire dedans. Notez que "mkfifo()" n'ouvre
   pas le FIFO — il crée juste un point de rendez-vous.

   Disponibilité : Unix.

   Nouveau dans la version 3.3: L'argument *dir_fd*.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Crée un nœud du système de fichiers (fichier, périphérique, fichier
   spécial, ou tuyau nommé) appelée *path*. *mode* spécifie à la fois
   les permissions à utiliser et le type de nœud à créer, en étant
   combiné (OR bit-à-bit) avec l'une des valeurs suivantes :
   "stat.S_IFREG", "stat.S_IFCHR", "stat.S_IFBLK", et "stat.S_IFIFO"
   (ces constantes sont disponibles dans le module "stat"). Pour
   "stat.S_IFCHR" et "stat.S_IFBLK", *device* définit le fichier
   spécial de périphérique tout juste créé (probablement en utilisant
   "os.makedev()"), sinon, cet argument est ignoré.

   Cette fonction peut également gérer des chemins relatifs à des
   descripteurs de répertoires.

   Disponibilité : Unix.

   Nouveau dans la version 3.3: L'argument *dir_fd*.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.major(device)

   Extrait le nombre majeur de périphérique d'un nombre de
   périphérique brut (habituellement le champ "st_dev" ou "st_rdev" de
   "stat").

os.minor(device)

   Extrait le nombre mineur de périphérique d'un nombre de
   périphérique brut (habituellement le champ "st_dev" ou "st_rdev" de
   "stat").

os.makedev(major, minor)

   Compose un nombre de périphérique brut à partir des nombres de
   périphérique mineur et majeur.

os.pathconf(path, name)

   Renvoie des informations sur la configurations relatives à un
   fichier déterminé. *name* spécifie la valeur de configuration à
   récupérer ; ce peut être une chaîne de caractères qui est le nom
   d'une valeur système particulière. Ces noms sont spécifiés dans
   certains standards (POSIX.1, Unix 95, Unix 98, etc). Certaines
   plate-formes définissent des noms supplémentaires également. Les
   noms connus du système d'exploitation hôte sont donnés dans le
   dictionnaire "pathconf_names". Pour les variables de configuration
   non incluses dans ce *mapping*, passer un entier pour *name* est
   également accepté.

   Si *name* est une chaîne de caractères et n'est pas connu, une
   "ValueError" est levée. Si une valeur spécifique de *name* n'est
   pas gérée par le système hôte, même si elle est incluse dans
   "pathconf_names", une "OSError" est levée avec "errno.EINVAL" pour
   code d'erreur.

   Cette fonction prend en charge la spécification d'un descripteur de
   fichier.

   Disponibilité : Unix.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.pathconf_names

   Dictionnaire liant les noms acceptés par les fonctions "pathconf()"
   et "fpathconf()" aux valeurs entières définies pour ces noms par le
   système d'exploitation hôte. Cette variable peut être utilisée pour
   déterminer l'ensemble des noms connus du système d'exploitation.

   Disponibilité : Unix.

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

   Renvoie une chaîne de caractères représentant le chemin vers lequel
   le lien symbolique pointe. Le résultat peut être soit un chemin
   relatif, soit un chemin absolu. S'il est relatif, il peut être
   converti en chemin absolu en utilisant
   "os.path.join(os.path.dirname(path), result)".

   Si *path* est une chaîne de caractères (directement ou
   indirectement à travers une interface "PathLike"), le résultat sera
   aussi une chaîne de caractères, et l'appel pourra lever une
   UnicodeDecodeError. Si *path* est une chaîne d'octets (directement
   ou indirectement), le résultat sera une chaîne d'octets.

   Cette fonction peut également gérer des chemins relatifs à des
   descripteurs de répertoires.

   Disponibilité : Unix, Windows.

   Modifié dans la version 3.2: Prise en charge des les liens
   symboliques sur Windows 6.0 (Vista).

   Nouveau dans la version 3.3: L'argument *dir_fd*.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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.

   Cette fonction prend en charge des chemins relatifs à des
   descripteurs de répertories.

   Sur Windows, tenter de retirer un fichier en cours d'utilisation
   cause la levée d'une exception, sur Unix, l'entrée du répertoire
   est supprimé mais l'espace de stockage alloué au fichier ne sera
   pas disponible avant que le fichier original ne soit plus utilisé.

   La fonction est sémantiquement identique à "unlink()".

   Nouveau dans la version 3.3: L'argument *dir_fd*.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.removedirs(name)

   Supprime des répertoires récursivement. Fonctionne comme "rmdir()"
   si ce n'est que si le répertoire feuille est retiré avec succès,
   "removedirs()" essaye de supprimer successivement chaque répertoire
   parent mentionné dans *path* jusqu'à ce qu'un erreur ne soit levée
   (ce qui est ignoré car la signification générale en est qu'un
   répertoire parent n'est pas vide). Par exemple,
   "os.removedirs('foo/bar/baz')" supprimera d'abord le répertoire
   "'foo/bar/baz'", et ensuite supprimera "'foo/bar'" et puis "'foo'"
   s'ils sont vides. Lève une "OSError" si le répertoire feuille n'a
   pas pu être supprimé avec succès.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Rename the file or directory *src* to *dst*. If *dst* exists, the
   operation will fail with an "OSError" subclass in a number of
   cases:

   On Windows, if *dst* exists a "FileExistsError" is always raised.

   On Unix, if *src* is a file and *dst* is a directory or vice-versa,
   an "IsADirectoryError" or a "NotADirectoryError" will be raised
   respectively.  If both are directories and *dst* is empty, *dst*
   will be silently replaced.  If *dst* is a non-empty directory, an
   "OSError" is raised. If both are files, *dst* it will be replaced
   silently if the user has permission.  The operation may fail on
   some Unix flavors if *src* and *dst* are on different filesystems.
   If successful, the renaming will be an atomic operation (this is a
   POSIX requirement).

   Cette fonction prend en charge les spécifications *src_dir_fd*
   et/ou *dst_dir_fd* pour fournir des chemins relatifs à des
   descripteurs de fichiers.

   Si cous désirez un écrasement multiplate-forme de la destination,
   utilisez la fonction "replace()".

   Nouveau dans la version 3.3: Les arguments *src_dir_fd* et
   *dst_dir_fd*.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *src* et *dst*.

os.renames(old, new)

   Fonction récursive de renommage de fichiers ou répertoires.
   Fonctionne comme "rename()", si ce n'est que la création d'un
   répertoire intermédiaire nécessaire pour rendre le nouveau chemin
   correct est essayé en premier. Après le renommage, les répertoires
   correspondant aux segments de chemin les plus à droite de l'ancien
   nom seront élagués en utilisant "removedirs()".

   Note:

     Cette fonction peut échouer avec la nouvelle structure de
     dictionnaire définie si vous n'avez pas les permissions
     nécessaires pour supprimer le répertoire ou fichier feuille.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *old* et *new*.

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

   Renomme le fichier ou le répertoire *src* en *dst*. Si *dst* est un
   répertoire, une "OSError" est levée. Si *dst* existe et est un
   fichier, il sera remplacé silencieusement si l'utilisateur en a les
   permissions. L'opération peut échouer si *src* et *dst* sont sur un
   système de fichiers différent. Si le renommage est effectué avec
   succès, il est une opération atomique (nécessité POSIX).

   Cette fonction prend en charge les spécifications *src_dir_fd*
   et/ou *dst_dir_fd* pour fournir des chemins relatifs à des
   descripteurs de fichiers.

   Nouveau dans la version 3.3.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *src* et *dst*.

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

   Remove (delete) the directory *path*.  If the directory does not
   exist or is not empty, an "FileNotFoundError" or an "OSError" is
   raised respectively.  In order to remove whole directory trees,
   "shutil.rmtree()" can be used.

   Cette fonction prend en charge des chemins relatifs à des
   descripteurs de répertories.

   Nouveau dans la version 3.3: Le paramètre *dir_fd*.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.scandir(path='.')

   Renvoie un itérateur d'objets "os.DirEntry" correspondant aux
   entrées dans le répertoire indiqué par *path*. Les entrées sont
   produites dans un ordre arbitraire, et les entrées spéciales "'.'"
   et "'..'" ne sont pas incluses.

   Utiliser "scandir()" plutôt que "listdir()" peut significativement
   améliorer les performances des codes qui nécessitent aussi l'accès
   aux types des fichiers ou à leurs attributs, puisque les objets
   "os.DirEntry" exposent ces informations si le système
   d'exploitation les fournit en scannant le répertoire. Toutes les
   méthodes de "os.DirEntry" peuvent réaliser un appel système, mais
   "is_dir()" et "is_file()" n'en requièrent normalement un que pour
   les liens symboliques ; "os.DirEntry.stat()" nécessite toujours un
   appel système sous Unix, mais seulement pour les liens symboliques
   sous Windows.

   *path* peut être un *path-like object*.  Si *path* est de type
   "bytes" (directement ou indirectement à travers une interface
   "PathLike"), le type des attributs "name" et "path" de chaque
   "os.DirEntry" sera "bytes" ; dans toutes les autres circonstances,
   ils seront de type "str".

   Cette fonction peut également gérer la spécification de
   descripteurs de fichiers. Le descripteur doit référencer un
   répertoire.

   L'itérateur "scandir()" gère le protocole *context manager* et
   possède la méthode suivante :

   scandir.close()

      Ferme l'itérateur et libère les ressources acquises.

      Elle est appelée automatiquement quand l'itérateur est
      entièrement consommé ou collecté par le ramasse-miettes, ou
      quand une erreur survient durant l'itération.  Il est cependant
      conseillé de l'appeler explicitement ou d'utiliser l'instruction
      "with".

      Nouveau dans la version 3.6.

   L'exemple suivant montre une utilisation simple de "scandir()" pour
   afficher tous les fichiers (à part les répertoires) dans le chemin
   donné par *path* et ne débutant pas par "'.'". L'appel
   "entry.is_file()" ne va généralement pas faire d'appel système
   supplémentaire :

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

   Note:

     Sur les systèmes inspirés de Unix, "scandir()" utilise les
     fonctions système opendir() et readdir() Sur Windows, la fonction
     utilise les fonctions Win32 FindFirstFileW et FindNextFileW.

   Nouveau dans la version 3.5.

   Nouveau dans la version 3.6: Prise en charge du protocole *context
   manager* et de la méthode "close()".  Si un itérateur sur
   "scandir()" n'est ni entièrement consommé ni explicitement fermé,
   un "ResourceWarning" sera émis dans son destructeur.La fonction
   accepte un *path-like object*.

   Modifié dans la version 3.7: Ajout de la gestion des descripteurs
   de fichiers sur Unix.

class os.DirEntry

   Objet donné par "scandir()" pour exposer le chemin du fichier et
   d'autres attributs de fichier d'une entrée du répertoire.

   "scandir()" fournira autant d'informations que possible sans faire
   d'appels système additionnels. Quand un appel système "stat()" ou
   "lstat()" est réalisé, l'objet "os.DirEntry" mettra le résultat en
   cache.

   Les instances "os.DirEntry" ne sont pas censées être stockées dans
   des structures de données à longue durée de vie ; si vous savez que
   les métadonnées du fichier ont changé ou si un certain temps s'est
   écoulé depuis l'appel à "scandir()", appelez "os.stat(entry.path)"
   pour mettre à jour ces informations.

   Puisque les méthodes de "os.DirEntry" peuvent réaliser des appels
   système, elles peuvent aussi lever des "OSError". Si vous avez
   besoin d'un contrôle fin des erreurs, vous pouvez attraper les
   "OSError" en appelant les méthodes de "os.DirEntry" et les traiter
   comme il vous semble.

   Pour être directement utilisable comme un *path-like object*,
   "os.DirEntry" implémente l'interface "PathLike".

   Les attributs et méthodes des instances de "os.DirEntry" sont les
   suivants :

   name

      Le nom de fichier de base de l'entrée, relatif à l'argument
      *path* de "scandir()".

      L'attribut "name" sera de type "bytes" si l'argument *path* de
      "scandir()" est de type "bytes", sinon il sera de type "str".
      Utilisez "fsdecode()" pour décoder des noms de fichiers de types
      *byte*.

   path

      Le nom entier de l'entrée : équivalent à
      "os.path.join(scandir_path, entry.name)" où *scandir_path* est
      l'argument *path* de "scandir()". Le chemin est absolu
      uniquement si l'argument *path* de "scandir()" était absolu. Si
      l'argument *path* à la fonction "scandir()" est un descripteur
      de fichier l'attribut "path" sera égal à l'attribut "name".

      L'attribut "path" sera de type "bytes" si l'argument *path* de
      la fonction "scandir()" est de type "bytes", sinon il sera de
      type "str". Utilisez "fsdecode()" pour décoder des noms de
      fichiers de type *bytes*.

   inode()

      Renvoie le numéro d'*inode* de l'entrée.

      Le résultat est mis en cache dans l'objet "os.DirEntry".
      Utilisez "os.stat(entry.path, follow_symlinks=False).st_ino"
      pour obtenir l'information à jour.

      Au premier appel non mis en cache, un appel système est requis
      sur Windows, mais pas sur Unix.

   is_dir(*, follow_symlinks=True)

      Renvoie "True" si cette entrée est un répertoire ou un lien
      symbolique pointant vers un répertoire ; renvoie "False" si
      l'entrée est (ou pointe vers) un autre type de fichier, ou s'il
      n'existe plus.

      Si *follow_symlinks* vaut "False", renvoie "True" uniquement si
      l'entrée est un répertoire (sans suivre les liens symboliques) ;
      renvoie "False" si l'entrée est n'importe quel autre type de
      fichier ou s'il n'existe plus.

      Le résultat est mis en cache dans l'objet "os.DirEntry", avec un
      cache séparé pour les valeurs "True" ou "False" de
      *follow_symlinks*. Appelez "os.stat()" avec "stat.S_ISDIR()"
      pour obtenir l'information à jour.

      Au premier appel non mis en cache, aucun appel système n'est
      requis dans la plupart du temps. Spécifiquement, sans les liens
      symboliques, ni Windows, ni Unix ne requiert l'appel système,
      sauf sur certains systèmes de fichiers sur Unix, comme les
      système de fichiers de réseau qui renvoient "dirent.d_type ==
      DT_UNKNOWN". Si l'entrée est un lien symbolique, un appel
      système sera requis pour suivre le lien symbolique, à moins que
      *follow_symlinks* vaille "False".

      Cette méthode peut lever une "OSError" tout comme une
      "PermissionError", mais "FileNotFoundError" est attrapé et pas
      levé.

   is_file(*, follow_symlinks=True)

      Renvoie "True" si l'entrée est un fichier ou un lien symbolique
      pointant vers un fichier, renvoie "False" si l'entrée pointe est
      (ou pointe sur) sur un dossier ou sur un répertoire ou autre
      entrée non-fichier, ou s'il n'existe plus.

      Si *follow_symlinks* vaut "False", renvoie "True" uniquement si
      cette entrée est un fichier (sans suivre les liens symboliques).
      Renvoie "False" si l'entrée est un répertoire ou une autre
      entrée non-fichier, ou s'il n'existe plus.

      Le résultat est mis en cache dans l'objet "os.DirEntry". La mise
      en cache, les appels système réalisés, et les exceptions levées
      sont les mêmes que pour "is_dir()".

   is_symlink()

      Renvoie "True" si l'entrée est un lien symbolique (même cassé).
      Renvoie "False" si l'entrée pinte vers un répertoire ou tout
      autre type de fichier, ou s'il n'existe plus.

      Le résultat est mis en cache dans l'objet "os.DirEntry". Appelez
      "os.path.islink()" pour obtenir l'information à jour.

      Au premier appel non mis en cache, aucun appel système n'est
      requis. Spécifiquement, ni Windows ni Unix ne requiert d'appel
      système, excepté sur certains systèmes de fichiers Unix qui
      renvoient "dirent.d_type == DT_UNKNOWN".

      Cette méthode peut lever une "OSError" tout comme une
      "PermissionError", mais "FileNotFoundError" est attrapé et pas
      levé.

   stat(*, follow_symlinks=True)

      Renvoie un objet de type "stat.result" pour cette entrée. Cette
      méthode suit les liens symboliques par défaut. Pour avoir les
      statistiques sur un lien symbolique, ajouter l'argument
      "follow_symlinks=False".

      Sur Unix, cette méthode requiert toujours un appel système. Sur
      Windows, cela requiert uniquement un appel système si
      *follow_symlinks* vaut "True" et l'entrée n'est pas un lien
      symbolique.

      Sur Windows, les attributs "st_ino", "st_dev" et "st_nlink" de
      la classe "stat_result" sont toujours définis à 0. Appelez la
      fonction "os.stat()" pour avoir ces attributs.

      Le résultat est mis en cache dans l'objet "os.DirEntry", avec un
      cache séparé pour les valeurs "True" ou "False" de
      *follow_symlinks*. Appelez "os.stat()" pour obtenir
      l'information à jour.

   Notez qu'il y a une correspondance entre différents attributs et
   méthodes de "os.DirEntry" et "pathlib.Path".  En particulier,
   l'attribut "name" a la même signification, ainsi que les méthodes
   "is_dir()", "is_file()", "is_symlink()" et "stat()".

   Nouveau dans la version 3.5.

   Modifié dans la version 3.6: Prise en charge de l'interface
   "PathLike".  Ajout du support des chemins "bytes" sous Windows.

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

   Récupère le statut d'un fichier ou d'un descripteur de fichier.
   Réalise l'équivalent d'un appel système "stat()" sur le chemin
   donné. *path* peut être exprimé comme une chaîne de caractères ou
   d'octets -- directement ou indirectement à travers une interface
   "PathLike" -- ou comme un descripteur de fichier ouvert. Renvoie un
   objet "stat_result".

   Cette fonction suit normalement les liens symboliques. Pour
   récupérer les informations d'un lien symbolique, ajoutez l'argument
   "follow_symlinks=False" ou utilisez la fonction "lstat()".

   Cette fonction peut supporter la spécification d'un descripteur de
   fichier et le non-suivi des liens symboliques.

   Exemple :

      >>> 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

   Voir aussi: les fonctions "fstat()" et "lstat()".

   Nouveau dans la version 3.3: Les arguments *dir_fd* et
   *follow_symlinks* ont été ajoutés, spécification d'un descripteur
   de fichier à la place d'un chemin ajoutée également.

   Modifié dans la version 3.6: Accepte un *path-like object*.

class os.stat_result

   Objet dont les attributs correspondent globalement aux membres de
   la structure "stat()". Utilisé pour le résultat des fonctions
   "os.stat()", "os.fstat()", et "os.lstat()".

   Attributs :

   st_mode

      Mode du fichier : type du fichier et bits de mode du fichier
      (permissions).

   st_ino

      Dépendant de la plateforme, mais lorsqu'il ne vaut pas zéro il
      identifie de manière unique le fichier pour une certaine valeur
      de "st_dev". Typiquement :

      * le numéro d'*inode* sur Unix,

      * l’index de fichier sur Windows

   st_dev

      Identifiant du périphérique sur lequel ce fichier se trouve.

   st_nlink

      Nombre de liens matériels.

   st_uid

      Identifiant d'utilisateur du propriétaire du fichier.

   st_gid

      Identifiant de groupe du propriétaire du fichier.

   st_size

      Taille du fichier en *bytes* si c'est un fichier normal ou un
      lien symbolique. La taille d'un lien symbolique est la longueur
      du nom de chemin qu'il contient sans le byte nul final.

   Horodatages :

   st_atime

      Moment de l'accès le plus récent, exprimé en secondes.

   st_mtime

      Moment de la modification de contenu la plus récente, exprimé en
      secondes.

   st_ctime

      Dépendant de la plate-forme :

      * le moment du changement de méta-données le plus récent sur
        Unix,

      * le moment de création sur Windows, exprimé en secondes.

   st_atime_ns

      Moment de l'accès le plus récent, exprimé en nanosecondes, par
      un entier.

   st_mtime_ns

      Moment de la modification de contenu la plus récente, exprimé en
      nanosecondes, par un entier.

   st_ctime_ns

      Dépendant de la plate-forme :

      * le moment du changement de méta-données le plus récent sur
        Unix,

      * le moment de création sur Windows, exprimé en nanosecondes,
        par un entier.

   Note:

     La signification et la précision exacte des attributs "st_atime",
     "st_mtime", et "st_ctime" dépendent du système d'exploitation et
     du système de fichier. Par exemple sur les systèmes Windows qui
     utilisent un système de fichier FAT ou FAT32, "st_mtime" a une
     précision de 2 secondes, et "st_atime" a une précision de 1 jour.
     Regardez la documentation de votre système d'exploitation pour
     plus de détails.De manière similaire, bien que "st_atime_ns",
     "st_mtime_ns", et "st_ctime_ns" soient toujours exprimés en
     nanosecondes, beaucoup de systèmes ne fournissent pas une
     précision à la nanoseconde près.Sur les systèmes qui fournissent
     une telle précision, l'objet à virgule flottante utilisé pour
     stocker "st_atime", "st_mtime", et "st_ctime" ne peut pas le
     contenir en entier, et donc sera légèrement inexact. Si vous avez
     besoin d'horodatages exacts, vous devriez toujours utiliser
     "st_atime_ns", "st_mtime_ns", et "st_ctime_ns".

   Sur certains systèmes Unix (tels que Linux), les attributs suivants
   peuvent également être disponibles :

   st_blocks

      Nombre de blocs de 512 *bytes* alloués pour le fichier. Cette
      valeur peut être inférieure à "st_size"/512 quand le fichier a
      des trous.

   st_blksize

      Taille de bloc "préférée" pour des E/S efficaces avec le système
      de fichiers. Écrire dans un fichier avec des blocs plus petits
      peut causer des modifications (lecture-écriture-réécriture)
      inefficaces.

   st_rdev

      Type de périphérique si l'*inode* représente un périphérique.

   st_flags

      Marqueurs définis par l'utilisateur pour le fichier.

   Sur d'autres systèmes Unix (tels que FreeBSD), les attributs
   suivants peuvent être disponibles (mais peuvent être complétés
   uniquement lorsque le super-utilisateur *root* tente de les
   utiliser) :

   st_gen

      Nombre de génération de fichier.

   st_birthtime

      Moment de la création du fichier.

   Sur les systèmes Solaris et dérivés, les attributs suivants peuvent
   également être disponibles :

   st_fstype

      Chaîne qui identifie de manière unique le type du système de
      fichiers qui contient le fichier.

   Sur les systèmes Mac OS, les attributs suivants peuvent également
   être disponibles :

   st_rsize

      Taillé réelle du fichier.

   st_creator

      Créateur du fichier.

   st_type

      Type du fichier.

   Sur les systèmes Windows, les attributs suivants sont également
   disponibles :

   st_file_attributes

      Attributs de fichiers Windows : membre "dwFileAttributes" de la
      structure "BY_HANDLE_FILE_INFORMATION" renvoyée par
      "GetileInformationByHandle()". Soir les constantes
      "FILE_ATTRIBUTE_*" du module "stat".

   Le module standard "stat" définit des fonctions et des constantes
   qui sont utiles pour l'extraction d'informations d'une structure
   "stat". (Sur Windows, certains éléments sont remplis avec des
   valeurs factices.)

   Pour des raisons de rétro-compatibilité, une instance du
   "stat_result" est également accessible comme un tuple d'au moins 10
   valeurs entières donnant les membres les plus importants (et
   portables) de la structure "stat", dans l'ordre : "st_mode",
   "st_ino", "st_dev", "st_nlink", "st_uid", "st_gid", "st_size",
   "st_atime", "st_mtime", "st_ctime". Plus d'éléments peuvent être
   ajoutés à la fin par certaines implémentations. Pour une
   compatibilité avec les anciennes versions de Python, accéder à un
   élément de type "stat_result" comme un tuple donne toujours des
   entiers.

   Nouveau dans la version 3.3: Les attributs "st_atime_ns",
   "st_mtime_ns", et "st_ctime_ns" ont été ajoutés.

   Nouveau dans la version 3.5: L'attribut "st_file_attributes" a été
   ajouté sur Windows.

   Modifié dans la version 3.5: Windows renvoie maintenant l'index du
   fichier dans l'attribut "st_ino", lorsqu'il est disponible.

   Nouveau dans la version 3.7: Ajout de l'attribut "st_fstype" sur
   Solaris et dérivés.

os.statvfs(path)

   Exécute un appel système "statvfs()" sur le chemin donné par
   *path*. La valeur de retour est un objet dont les attributs
   décrivent le système de fichiers pour le chemin donné, et
   correspondent aux membres de la structure "statvfs", c'est-à-dire :
   "f_bsize", "f_frsize", "f_blocks", "f_bfree", "f_bavail",
   "f_files", "f_ffree", "f_favail", "f_flag", "f_namemax", "f_fsid".

   Deux constantes de module sont définies pour le champ-de-bits de
   l'attribut "f_flag" : si "SR_RDONLY" est activé, le système de
   fichiers est monté en lecture-seule, et si "ST_NOSUID" est activé,
   la sémantique des bits de *setuid* / *getuid* est désactivée ou non
   gérée.

   Des constantes de module supplémentaires sont définies pour les
   systèmes basés sur GNU/glibc. Ces constantes sont "ST_NODEV"
   (interdit l'accès aux fichiers spéciaux du périphérique),
   "ST_NOEXEC" (interdit l'exécution de programmes), "ST_SYNCHRONOUS"
   (les écritures sont synchronisées en une fois), "ST_MANDLOCK"
   (permet les verrous impératifs sur un système de fichiers),
   "ST_WRITE" (écrit sur les fichiers/répertoires/liens symboliques),
   "ST_APPEND" (fichiers en ajout-seul), "ST_IMMUTABLE" (fichiers
   immuables), "ST_NOATIME" (ne met pas à jour les moments d'accès),
   "ST_NODIRATIME" (ne met pas à jour les moments d'accès aux
   répertoires), "ST_REALTIME" (Met *atime* à jour relativement à
   *mtime* / *ctime*).

   Cette fonction prend en charge la spécification d'un descripteur de
   fichier.

   Disponibilité : Unix.

   Modifié dans la version 3.2: Ajout des constantes "ST_RDONLY" et
   "ST_NOSUID".

   Nouveau dans la version 3.3: Prise en charge de la spécification
   d'un descripteur de répertoire pour *path* ajouté.

   Modifié dans la version 3.4: Ajout des constantes "ST_NODEV",
   "ST_NOEXEC", "ST_SYNCHRONOUS", "ST_MANDLOCK", "ST_WRITE",
   "ST_APPEND", "ST_IMMUTABLE", "ST_NOATIME", "ST_NODIRATIME", et
   "ST_RELATIME".

   Modifié dans la version 3.6: Accepte un *path-like object*.

   Nouveau dans la version 3.7: Ajout de "f_fsid".

os.supports_dir_fd

   Un objet de type "Set" indiquant quels fonctions du module "os"
   permettent l'utilisation du paramètre *dir_fd*. Des plate-formes
   différentes fournissent des fonctionnalités différentes, et une
   option qui peut fonctionner sur l'une peut ne pas être gérée sur
   une autre. Pour des raisons de cohérence, les fonctions qui gèrent
   *dir_fd* permettent toujours de spécifier le paramètre, mais lèvent
   une exception si la fonctionnalité n'est pas réellement accessible.

   Pour vérifier si une fonction en particulier permet de
   l'utilisation de son paramètre *dir_fd*, utilisez l'opérateur "in"
   sur "supports_dir_fd". Par exemple, l'expression détermine si le
   paramètre *dir_fd* de la fonction "os.stat()" est disponible :

      os.stat in os.supports_dir_fd

   Actuellement, le paramètre *dir_fd* ne fonctionne que sur les
   plate-formes Unix. Il ne fonctionne jamais sur Windows.

   Nouveau dans la version 3.3.

os.supports_effective_ids

   Un objet de type "collections.abc.Set" indiquant quelles fonction
   du module "ps" permettent l'utilisation du paramètre
   *effective_ids* pour "os.access()". Si la plate-forme le gère, la
   collection contiendra "os.access()", sinon elle sera vide.

   Pour vérifier si vous pouvez utiliser le paramètre *effective_ids*
   pour "os.access()", utilisez l'opérateur "in" sur
   "supports_effective_ids", comme tel :

      os.access in os.supports_effective_ids

   Actuellement, *effective_ids* ne fonctionne que sur les plate-
   formes Unix, ça ne fonctionne pas sur Windows.

   Nouveau dans la version 3.3.

os.supports_fd

   Un objet de type "Set" indiquant quelles fonctions du module "os"
   permettent de spécifier le paramètre de chemin *path* par un
   descripteur de fichier ouvert. Différentes plate-formes fournissent
   différentes fonctionnalités, et une option qui peut fonctionner sur
   l'une peut ne pas être gérée sur une autre. Pour des raisons de
   cohérence, les fonctions qui gèrent *fd* permettent toujours de
   spécifier le paramètre, mais elles lèveront une exception si la
   fonctionnalité n'est pas réellement disponible.

   Pour vérifier si une fonction en particulier permet de spécifier un
   descripteur de fichier ouvert pour son paramètre *path*, utilisez
   l'opérateur "in" sur "supports_fd". Par exemple, cette expression
   détermine si "os.chdir()" accepte un descripteur de fichier ouvert
   quand appelée sur votre plate-forme actuelle :

      os.chdir in os.supports_fd

   Nouveau dans la version 3.3.

os.supports_follow_symlinks

   Un objet de type "collections.abc.Set" indiquant quelles fonctions
   du module "os" permettent d'utiliser leur paramètre
   *follow_symlinks*. Différentes plate-formes fournissent des
   fonctionnalités différentes, et une option qui fonctionne sur l'une
   peut ne pas fonctionner sur une autre. Pour des raisons de
   cohérence, les fonctions qui gèrent *follow_symlinks* permettent
   toujours de spécifier le paramètre, mais lèvent une exception si la
   fonctionnalité n'est pas réellement disponible.

   Pour vérifier s une fonction en particulier permet l'utilisation du
   paramètre *follow_symlinks*, utilisez l'opérateur "in" sur
   "supports_follow_symlinks". Par exemple, cette expression détermine
   si le paramètre *follow_symlink* de "os.stat()" est disponible :

      os.stat in os.supports_follow_symlinks

   Nouveau dans la version 3.3.

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

   Crée un lien symbolique pointant vers *src* et appelé *dst*.

   Sur Windows, un lien symbolique représente soit lien vers un
   fichier, soit lien vers un répertoire mais ne s'adapte pas
   dynamiquement au type de la cible. Si la cible existe le lien sera
   crée du même type que sa cible. Dans le cas où cible n'existe pas,
   si *target_is_directory* vaut "True" le lien symbolique sera créé
   comme un répertoire, sinon comme un fichier (par défaut). Sur les
   autres plateformes, *target_id_directory* est ignoré.

   Introduction de la prise en charge des liens symboliques dans
   Windows 6.0 (Vista). "symlink()" lèvera une exception
   "NotImplementedError" sur les versions de Windows inférieures à
   6.0.

   Cette fonction prend en charge des chemins relatifs à des
   descripteurs de répertories.

   Note:

     Sur Windows, le *SeCreateSymbolicLinkPrivilege* est requis pour
     créer des liens symboliques avec succès. Ce privilège n'est pas
     typiquement garanti aux utilisateurs réguliers mais est
     disponible aux comptes qui peuvent escalader les privilèges
     jusqu'au niveau administrateur. Tant obtenir le privilège que
     lancer votre application en administrateur sont des moyens de
     créer des liens symboliques avec succès."OSError" est levée quand
     la fonction est appelée par un utilisateur sans privilèges.

   Disponibilité : Unix, Windows.

   Modifié dans la version 3.2: Prise en charge des les liens
   symboliques sur Windows 6.0 (Vista).

   Nouveau dans la version 3.3: Ajout de l'argument *dir_fd* et
   maintenant, permission de *target_is_directory* sur les plate-
   formes non Windows.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *src* et *dst*.

os.sync()

   Force l'écriture de tout sur le disque.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.truncate(path, length)

   Tronque le fichier correspondant à *path*, afin qu'il soit au
   maximum long de *length* bytes.

   Cette fonction prend en charge la spécification d'un descripteur de
   fichier.

   Disponibilité : Unix, Windows.

   Nouveau dans la version 3.3.

   Modifié dans la version 3.5: Prise en charge de Windows

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Supprime (retire) le fichier *path*. Cette fonction est
   sémantiquement identique à "remove()". Le nom "unlink" est un nom
   Unix traditionnel. Veuillez voir la documentation de "remove()"
   pour plus d'informations.

   Nouveau dans la version 3.3: Le paramètre *dir_fd*.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Voir les derniers moments d'accès et de modification du fichier
   spécifiés par *path*.

   La fonction "utime()" prend deux paramètres optionnels, *times* et
   *ns*. Ils spécifient le temps mis pour *path* et est utilisé comme
   suit :

   * Si *ns* est spécifié, ce doit être un couple de la forme
     "(atime_ns, mtime_ns)" où chaque membre est un entier qui exprime
     des nanosecondes.

   * Si *times* ne vaut pas "None", ce doit être un couple de la forme
     "(atime, mtime)" où chaque membre est un entier ou une expression
     à virgule flottante.

   * Si *times* vaut "None", et *ns* est non-spécifié. C'est
     équivalent à spécifier "ns = (atime_ns, mtime_ns)" où les deux
     moments sont le moment actuel.

   Il est erroné de spécifier des tuples pour *times* et *ns* à la
   fois.

   Le fait qu'un répertoire puisse être donné pour *path* dépend du
   fait que le système d'exploitation implémente les répertoires comme
   des fichiers (par exemple, Windows ne le fait pas). Notez que
   l'instant exact que vous définissez ici peut ne pas être renvoyé
   lors d'un futur appel à "stat()", selon la précision avec laquelle
   votre système d'exploitation mémorise les moments d'accès et de
   modification ; voir "stat()". Le meilleur moyen de préserver des
   moments exacts est d'utiliser les champs *st_atime_ns* et
   *st_mtime_ns* de l'objet résultat de la fonction "os.stat()" avec
   le paramètre *ns* valant *utime*.

   Cette fonction prend en charge la spécification d'un descripteur de
   fichier, les chemins relatifs à des descripteurs de répertoires, et
   le non-suivi des liens symboliques.

   Nouveau dans la version 3.3: Prise en charge de la spécification
   d'un descripteur de fichier pour *path* et les paramètres *dir_fd*,
   *follow_symlinks*, et *ns* ajoutés.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Génère les noms de fichier dans un arbre de répertoire en
   parcourant l'arbre soit de bas-en-haut, soit de haut-en-bas. Pour
   chaque répertoire dans l'arbre enraciné en le répertoire *rop*
   (incluant ledit répertoire *top*), fournit un triplet "(dirpath,
   dirnames, filenames)".

   *dirpath* est une chaîne de caractères contenant le chemin vers le
   répertoire. *dirnames* est une liste de noms de sous-répertoires
   dans *dirpath* (en excluant "'.'" et "'..'"). *filenames* est une
   liste de fichiers (non-répertoires) dans *dirpath*. Notez que les
   noms dans la liste ne contiennent aucune composante de chemin. Pour
   récupérer le chemin complet (qui commence à *top*) vers un
   répertoire dans *dirpath*, faites "os.path.join(dirpath, name)".

   Si l'argument optionnel *topdown* vaut "True" ou n'est pas
   spécifié, le triplet pour un répertoire est généré avant les
   triplets de tous ses sous-répertoires (les répertoires sont générés
   de haut-en-bas). Si *topdown* vaut "False", le triplet pour un
   répertoire est généré après les triplets de tous ses sous-
   répertoires (les répertoires sont générés de bas-en-haut). Peu
   importe la valeur de *topdown*, la liste des sous-répertoires est
   récupérée avant que les tuples pour le répertoires et ses sous-
   répertoires ne soient générés.

   Quand *topdown* vaut "True", l'appelant peut modifier la liste
   *dirnames* en place (par exemple en utilisant "del" ou
   l'assignation par *slicing* (par tranches)) et "walk()" ne fera sa
   récursion que dans les sous-répertoires dont le nom reste dans
   *dirnames* ; cela peut être utilisé pour élaguer la recherche,
   imposer un ordre particulier de visite, ou encore pour informer
   "walk()" des répertoires créés par l'appelant ou renommés avant
   qu'il quitte "walk()" à nouveau. Modifier *dirnames* quand
   *topdown* vaut "False" n'a aucun effet dur le comportement du
   parcours parce qu'en mode bas-en-haut, les répertoires dans
   *dirnames* sont générés avant que *dirpath* ne soit lui-même
   généré.

   Par défaut, les erreurs d'un appel à "scandir()" sont ignorées. Si
   l'argument optionnel *onerror* est spécifié, il doit être une
   fonction qui sera appelée avec un seul argument, une instance de
   "OSError". Elle peut rapporter l'erreur et continuer le parcours,
   ou lever l'exception pour avorter le parcours. Notez que le nom de
   fichier est disponible dans l'attribut "filename" de l'objet
   exception.

   Par défaut, "walk()" ne parcourra pas les liens symboliques qui
   mènent à un répertoire. Définissez *followlinks* avec "True" pour
   visiter les répertoires pointés par des liens symboliques sur les
   systèmes qui le gère.

   Note:

     Soyez au courant que définir *followlinks* avec "True" peut mener
     à une récursion infinie si un lien pointe vers un répertoire
     parent de lui-même. "walk()" ne garde pas de trace des
     répertoires qu'il a déjà visité.

   Note:

     Si vous passez un chemin relatif, ne changer pas le répertoire de
     travail actuel entre deux exécutions de "walk()". "walk()" ne
     change jamais le répertoire actuel, et suppose que l'appelant ne
     le fait pas non plus.

   Cet exemple affiche le nombre de bytes pris par des fichiers non-
   répertoires dans chaque répertoire à partir du répertoire de
   départ, si ce n'est qu'il ne cherche pas après un sous-répertoire
   CSV :

      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

   Dans l'exemple suivant (simple implémentation d'un
   "shutil.rmtree()"), parcourir l'arbre de bas-en-haut est essentiel
   : "rmdir()" ne permet pas de supprimer un répertoire avant qu'un ne
   soit vide :

      # 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))

   Modifié dans la version 3.5: Cette fonction appelle maintenant
   "os.scandir()" au lieu de "os.listdir()", ce qui la rend plus
   rapide en réduisant le nombre d'appels à "os.stat()".

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Se comporte exactement comme "walk()", si ce n'est qu'il fournit un
   quadruplet "(dirpath, dirnames, filenames, dirfd)", et gère
   "dir_fd".

   *dirpath*, *dirnames* et *filenames* sont identiques à la sortie de
   "walk()" et *dirfd* est un descripteur de fichier faisant référence
   au répertoire *dirpath*.

   Cette fonction prend toujours en charge les chemins relatifs à des
   descripteurs de fichiers et le non-suivi des liens symboliques.
   Notez cependant qu'à l'inverse des autres fonctions, la valeur par
   défaut de *follow_symlinks* pour "walk()" est "False".

   Note:

     Puisque "fwalk()" fournit des descripteurs de fichiers, ils ne
     sont valides que jusque la prochaine itération. Donc vous devriez
     les dupliquer (par exemple avec "dup()") si vous désirez les
     garder plus longtemps.

   Cet exemple affiche le nombre de bytes pris par des fichiers non-
   répertoires dans chaque répertoire à partir du répertoire de
   départ, si ce n'est qu'il ne cherche pas après un sous-répertoire
   CSV :

      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

   Dans le prochain exemple, parcourir l'arbre de bas-en-haut est
   essentiel : "rmdir()" ne permet pas de supprimer un répertoire
   avant qu'il ne soit vide :

      # 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)

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

   Modifié dans la version 3.6: Accepte un *path-like object*.

   Modifié dans la version 3.7: Ajout de la gestion des chemins de
   type "bytes".


Attributs étendus pour Linux
----------------------------

Nouveau dans la version 3.3.

Toutes ces fonctions ne sont disponibles que sur Linux.

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

   Renvoie la valeur de l'attribut étendu *attribute* du système de
   fichiers pour le chemin *path*. *attribute* peut être une chaîne de
   caractères ou d'octets (directement ou indirectement à travers une
   interface "PathLike"). Si c'est une chaîne de caractères, elle est
   encodée avec l'encodage du système de fichiers.

   Cette fonction peut supporter la spécification d'un descripteur de
   fichier et le non-suivi des liens symboliques.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *path* et *attribute*.

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

   Renvoie une liste d'attributs du système de fichiers étendu pour
   *path*. Les attributs dans le liste sont représentés par des
   chaînes de caractères et sont décodés avec l'encodage du système de
   fichier. Si *path* vaut "None", "listxattr()" examinera le
   répertoire actuel.

   Cette fonction peut supporter la spécification d'un descripteur de
   fichier et le non-suivi des liens symboliques.

   Modifié dans la version 3.6: Accepte un *path-like object*.

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

   Supprime l'attribut étendu *attribute* du système de fichier pour
   le chemin *path*. *attribute* devrait être une chaîne de caractères
   ou d'octets (directement ou indirectement à travers une interface
   "PathLike"). Si c'est une chaîne de caractères, elle est encodée
   avec l'encodage du système de fichiers.

   Cette fonction peut supporter la spécification d'un descripteur de
   fichier et le non-suivi des liens symboliques.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *path* et *attribute*.

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

   Règle l'attribut étendu *attribute* du système de fichier pour le
   chemin *path* à *value*. *attribute* doit être une chaîne de
   caractères ou d'octets sans caractères nuls (directement ou
   indirectement à travers une interface "PathLike"). Si c'est une
   chaîne de caractères, elle est encodée avec l'encodage du système
   de fichiers.  *flags* peut être "XATTR_REPLACE" ou "XATTR_CREATE".
   Si "XATTR_REPLACE" est donné et que l'attribut n'existe pas,
   "EEXISTS" sera levée. Si "XATTR_CREATE" est donné et que l'attribut
   existe déjà, l'attribut ne sera pas créé et "ENODATA" sera levée.

   Cette fonction peut supporter la spécification d'un descripteur de
   fichier et le non-suivi des liens symboliques.

   Note:

     Un bug des versions inférieures à 2.6.39 du noyau Linux faisait
     que les marqueurs de *flags*  étaient ignorés sur certains
     systèmes.

   Modifié dans la version 3.6: Accepte un *path-like object* pour
   *path* et *attribute*.

os.XATTR_SIZE_MAX

   La taille maximum que peut faire la valeur d'un attribut étendu.
   Actuellement, c'est 64 KiB sur Lniux.

os.XATTR_CREATE

   C'est une valeur possible pour l'argument *flags* de "setxattr()".
   Elle indique que l'opération doit créer un attribut.

os.XATTR_REPLACE

   C'est une valeur possible pour l'argument *flags* de
   "setxattr()".Elle indique que l'opération doit remplacer un
   attribut existant.


Gestion des processus
=====================

Ces fonctions peuvent être utilisées pour créer et gérer des
processus.

Les variantes des fonctions "exec*" prennent une liste d'arguments
pour le nouveau programme chargé dans le processus. Dans tous les cas,
le premier de ces arguments est passé au nouveau programme comme son
propre nom plutôt que comme un argument qu'un utilisateur peut avoir
tapé en ligne de commande. Pour les programmeurs C, c'est l'argument
"argv[0]" qui est passé à la fonction "main()" du programme. Par
exemple, "os.execv('/bin/echo/', ['foo', 'bar'])" affichera uniquement
"bar" sur la sortie standard ; "foo" semblera être ignoré.

os.abort()

   Génère un signal "SIGABRT" au processus actuel. Sur Linux, le
   comportement par défaut est de produire un vidage système (*Core
   Dump*) ; sur Windows, le processus renvoie immédiatement un code
   d'erreur "3". Attention : appeler cette fonction n'appellera pas le
   gestionnaire de signal Python enregistré par "SIGABRT" à l'aide de
   "signal.signal()".

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)

   Ces fonctions exécutent toutes un nouveau programme, remplaçant le
   processus actuel, elles ne renvoient pas. Sur Unix, le nouvel
   exécutable est chargé dans le processus actuel, et aura le même
   identifiant de processus (PID) que l'appelant. Les erreurs seront
   reportées par des exceptions "OSError".

   Le processus actuel est remplacé immédiatement. Les fichiers objets
   et descripteurs de fichiers ne sont pas purgés, donc s'il est
   possible que des données aient été mises en tampon pour ces
   fichiers, vous devriez les purger manuellement en utilisant
   "sys.stdout.flush()" ou "os.fsync()" avant d'appeler une fonction
   "exec*".

   Les variantes "l" et "v" des fonctions "exec*" différent sur la
   manière de passer les arguments de ligne de commande. Les variantes
   "l" sont probablement les plus simples à utiliser si le nombre de
   paramètres est fixé lors de l'écriture du code. Les paramètres
   individuels deviennent alors des paramètres additionnels aux
   fonctions "exec*()". Les variantes "v" sont préférables quand le
   nombre de paramètres est variable et qu'ils sont passés dans une
   liste ou un *tuple* dans le paramètre *args*. Dans tous les cas,
   les arguments aux processus fils devraient commencer avec le nom de
   la commande à lancer, mais ce n'est pas obligatoire.

   Les variantes qui incluent un "p"vers la fin ("execlp()",
   "execlpe()", "execvp()", et "execvpe()") utiliseront la variable
   d'environnement "PATH" pour localiser le programme *file*. Quand
   l'environnement est remplacé (en utilisant une des variantes
   "exec*e", discutées dans le paragraphe suivant), le nouvel
   environnement est utilisé comme source de la variable
   d'environnement "PATH". Les autres variantes "execl()", "execle()",
   "execv()", et "execve()" n'utiliseront pas la variable
   d'environnement "PATH" pour localiser l'exécutable. *path* doit
   contenir un chemin absolue ou relatif approprié.

   Pour les fonctions "execle()", "execlpe()", "execve()", et
   "execvpe()" (notez qu'elle finissent toutes par "e"), le paramètre
   *env* doit être un *mapping* qui est utilisé pour définir les
   variables d'environnement du nouveau processus (celles-ci sont
   utilisées à la place de l'environnement du nouveau processus). Les
   fonctions "execl()", "execlp()", "execv()", et "execvp()" causent
   toutes un héritage de l'environnement du processus actuel par le
   processus fils.

   Pour "execve()", sur certaines plate-formes, *path* peut également
   être spécifié par un descripteur de fichier ouvert. Cette
   fonctionnalité peut ne pas être gérée sur votre plate-forme. Vous
   pouvez vérifier si c'est disponible en utilisant "os._supports_fd".
   Si c'est indisponible, l'utiliser lèvera une "NotImplementedError".

   Disponibilité : Unix, Windows.

   Nouveau dans la version 3.3: Prise en charge de la spécification
   d'un descripteur de fichier ouvert pour *path* pour "execve()".

   Modifié dans la version 3.6: Accepte un *path-like object*.

os._exit(n)

   Quitte le processus avec le statut *n*, sans appeler les
   gestionnaires de nettoyage, sans purger les tampons des fichiers,
   etc.

   Note:

     La méthode standard pour quitter est "sys.exit(n)". "_exit()"
     devrait normalement être utilisé uniquement par le processus fils
     après un "fork()".

Les codes de sortie suivants sont définis et peuvent être utilisés
avec "_exit()", mais ils ne sont pas nécessaires. Ils sont typiquement
utilisés pour les programmes systèmes écrits en Python, comme un
programme de gestion de l'exécution des commandes d'un serveur de
mails.

Note:

  Certaines de ces valeurs peuvent ne pas être disponibles sur toutes
  les plate-formes Unix étant donné qu'il en existe des variations.
  Ces constantes sont définies là où elles sont définies par la plate-
  forme sous-jacente.

os.EX_OK

   Code de sortie signifiant qu'aucune erreur n'est arrivée.

   Disponibilité : Unix.

os.EX_USAGE

   Code de sortie signifiant que les commandes n'ont pas été utilisées
   correctement, comme quand le mauvais nombre d'arguments a été
   donné.

   Disponibilité : Unix.

os.EX_DATAERR

   Code de sortie signifiant que les données en entrées étaient
   incorrectes.

   Disponibilité : Unix.

os.EX_NOINPUT

   Code de sortie signifiant qu'un des fichiers d'entrée n'existe pas
   ou n'est pas lisible.

   Disponibilité : Unix.

os.EX_NOUSER

   Code de sortie signifiant qu'un utilisateur spécifié n'existe pas.

   Disponibilité : Unix.

os.EX_NOHOST

   Code de sortie signifiant qu'un hôte spécifié n'existe pas.

   Disponibilité : Unix.

os.EX_UNAVAILABLE

   Code de sortie signifiant qu'un service requis n'est pas
   disponible.

   Disponibilité : Unix.

os.EX_SOFTWARE

   Code de sortie signifiant qu'une erreur interne d'un programme a
   été détectée.

   Disponibilité : Unix.

os.EX_OSERR

   Code de sortie signifiant qu'une erreur du système d'exploitation a
   été détectée, comme l'incapacité à réaliser un *fork* ou à créer un
   tuyau (*pipe*).

   Disponibilité : Unix.

os.EX_OSFILE

   Code de sortie signifiant qu'un fichier n'existe pas, n'a pas pu
   être ouvert, ou avait une autre erreur.

   Disponibilité : Unix.

os.EX_CANTCREAT

   Code de sortie signifiant qu'un fichier spécifié par l'utilisateur
   n'a pas pu être créé.

   Disponibilité : Unix.

os.EX_IOERR

   Code de sortie signifiant qu'une erreur est apparue pendant une E/S
   sur un fichier.

   Disponibilité : Unix.

os.EX_TEMPFAIL

   Code de sortie signifiant qu'un échec temporaire est apparu. Cela
   indique quelque chose qui pourrait ne pas être une erreur, comme
   une connexion au réseau qui n'a pas pu être établie pendant une
   opération réessayable.

   Disponibilité : Unix.

os.EX_PROTOCOL

   Code de sortie signifiant qu'un protocole d'échange est illégal,
   invalide, ou non-compris.

   Disponibilité : Unix.

os.EX_NOPERM

   Code de sortie signifiant qu'il manque certaines permissions pour
   réaliser une opération (mais n'est pas destiné au problèmes de
   système de fichiers).

   Disponibilité : Unix.

os.EX_CONFIG

   Code de sortie signifiant qu'une erreur de configuration est
   apparue.

   Disponibilité : Unix.

os.EX_NOTFOUND

   Code de sortie signifiant quelque chose comme "une entrée n'a pas
   été trouvée".

   Disponibilité : Unix.

os.fork()

   *Fork* un processus fils. Renvoie "0" dans le processus fils et le
   PID du processus fils dans le processus père. Si une erreur
   apparaît, une "OSError" est levée.

   Notez que certaines plate-formes (dont FreeBSD <= 6.3 et Cygwin)
   ont des problèmes connus lors d'utilisation de *fork()* depuis un
   fil d'exécution.

   Avertissement:

     Voit "ssl" pour les application qui utilisent le module SSL avec
     *fork()*.

   Disponibilité : Unix.

os.forkpty()

   *Fork* un processus fils, en utilisant un nouveau pseudo-terminal
   comme terminal contrôlant le fils. Renvoie une paire "(pid, fd)" où
   *pid* vaut "0" dans le fils et le PID du processus fils dans le
   parent, et *fd* est le descripteur de fichier de la partie maître
   du pseudo-terminal. Pour une approche plus portable, utilisez le
   module "pty". Si une erreur apparaît, une "OSError" est levée.

   Disponibilité : certains dérivés Unix.

os.kill(pid, sig)

   Envoie le signal *sig* au processus *pid*. Les constantes pour les
   signaux spécifiques à la plate-forme hôte sont définies dans le
   module "signal".

   Windows : les signaux "signal.CTRL_C_EVENT" et
   "signal.CTRL_BREAK_EVENT" sont des signaux spéciaux qui ne peuvent
   être envoyés qu'aux processus consoles qui partagent une console
   commune (par exemple, certains sous-processus). Toute autre valeur
   pour *sig* amènera le processus a être tué sans condition par l'API
   TerminateProcess, et le code de retour sera mis à *sig*. La version
   Windows de "kill()" prend en plus les identificateurs de processus
   à tuer.

   Voir également "signal.pthread_kill()".

   Nouveau dans la version 3.2: Prise en charge de Windows.

os.killpg(pgid, sig)

   Envoie le signal *sig* au groupe de processus *pgid*.

   Disponibilité : Unix.

os.nice(increment)

   Ajoute *increment*  à la priorité du processus. Renvoie la nouvelle
   priorité.

   Disponibilité : Unix.

os.plock(op)

   Verrouille les segments du programme en mémoire. La valeur de *op*
   (définie dans "<sys/lock.h>") détermine quels segments sont
   verrouillés.

   Disponibilité : Unix.

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

   Ouvre un tuyau vers ou depuis la commande *cmd*. La valeur de
   retour est un fichier objet ouvert relié au tuyau qui peut être lu
   ou écrit selon la valeur de *mode* qui est "'r'" (par défaut) ou
   "'w'". L'argument *buffering* a le même sens que l'argument
   correspondant de la fonction "open()". L'objet fichier renvoyé
   écrit (ou lit) des chaînes de caractères et non de bytes.

   La méthode "close" renvoie "None" si le sous-processus s'est
   terminé avec succès, ou le code de retour du sous-processus s'il y
   a eu une erreur. Sur les systèmes POSIX, si le code de retour est
   positif, il représente la valeur de retour du processus décalée
   d'un byte sur la gauche. Si le code de retour est négatif, le
   processus le processus s'est terminé avec le signal donné par la
   négation de la valeur de retour. (Par exemple, la valeur de retour
   pourrait être "-signal.SIGKILL" si le sous-processus a été tué).
   Sur les systèmes Windows, la valeur de retour contient le code de
   retour du processus fils dans un entier signé .

   Ceci est implémenté en utilisant "subprocess.Popen". Lisez la
   documentation de cette classe pour des méthodes plus puissantes
   pour gérer et communiquer avec des sous-processus.

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

   Enregistre des appelables (*callables*) à exécuter quand un nouveau
   processus enfant est crée avec "os.fork()" ou des APIs similaires
   de clonage de processus. Les paramètres sont optionnels et par
   mots-clé uniquement. Chacun spécifie un point d'appel différent.

   * *before* est une fonction appelée avant de *forker* un processus
     enfant.

   * *after_in_parent* est une fonction appelée depuis le processus
     parent après avoir *forké* un processus enfant.

   * *after_in_child* est une fonction appelée depuis le processus
     enfant.

   Ces appels ne sont effectués que si le contrôle est censé retourner
   à l'interpréteur Python. Un lancement de "subprocess" typique ne
   les déclenchera pas, car l'enfant ne ré-entre pas dans
   l'interpréteur.

   Les fonctions enregistrées pour l'exécution avant le *fork* sont
   appelées dans l'ordre inverse à leur enregistrement. Les fonctions
   enregistrées pour l'exécution après le *fork* (soit dans le parent
   ou dans l'enfant) sont appelées dans l'ordre de leur
   enregistrement.

   Notez que les appels à "fork()" faits par du code C de modules
   tiers peuvent ne pas appeler ces fonctions, à moins que ce code
   appelle explicitement "PyOS_BeforeFork()",
   "PyOS_AfterFork_Parent()" et "PyOS_AfterFork_Child()".

   Il n'y a aucun moyen d'annuler l'enregistrement d'une fonction.

   Disponibilité : Unix.

   Nouveau dans la version 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)

   Exécute le programme *path* dans un nouveau processus.

   (Notez que le module "subprocess" fournit des outils plus puissants
   pour générer de nouveaux processus et récupérer leur valeur de
   retour. Il est préférable d'utiliser ce module que ces fonctions.
   Voyez surtout la section Remplacer les fonctions plus anciennes par
   le module subprocess.)

   Si *mode* vaut "P_NOWAIT", cette fonction renvoie le PID du nouveau
   processus, et si *mode* vaut "P_WAIT", la fonction renvoie le code
   de sortie du processus s'il se termine normalement, ou "-signal" où
   *signal* est le signal qui a tué le processus. Sur Windows, le PID
   du processus sera en fait l'identificateur du processus (*process
   handle*) et peut donc être utilisé avec la fonction "waitpid()".

   Les variantes "l" et "v" des fonctions "spawn*" diffèrent sur la
   manière de passer les arguments de ligne de commande. Les variantes
   "l" sont probablement les plus simples à utiliser si le nombre de
   paramètres est fixé lors de l'écriture du code. Les paramètres
   individuels deviennent alors des paramètres additionnels aux
   fonctions "spawn*()". Les variantes "v" sont préférables quand le
   nombre de paramètres est variable et qu'ils sont passés dans une
   liste ou un *tuple* dans le paramètre *args*. Dans tous les cas,
   les arguments aux processus fils devraient commencer avec le nom de
   la commande à lancer, mais ce n'est pas obligatoire.

   Les variantes qui incluent un "p"vers la fin ("spawnlp()",
   "spawnlpe()", "spawnvp()", et "spawnvpe()") utiliseront la variable
   d'environnement "PATH" pour localiser le programme *file*. Quand
   l'environnement est remplacé (en utilisant une des variantes
   "spawn*e", discutées dans le paragraphe suivant), le nouvel
   environnement est utilisé comme source de la variable
   d'environnement "PATH". Les autres variantes "spawnl()",
   "spawnle()", "spawnv()", et "spawnve()" n'utiliseront pas la
   variable d'environnement "PATH" pour localiser l'exécutable. *path*
   doit contenir un chemin absolue ou relatif approprié.

   Pour les fonctions "spawnle()", "spawnlpe()", "spawnve()", et
   "spawnvpe()" (notez qu'elles finissent toutes par "e"), le
   paramètre *env* doit être un *mapping* qui est utilisé pour définir
   les variables d'environnement du nouveau processus (celles-ci sont
   utilisées à la place de l'environnement du nouveau processus). Les
   fonctions "spawnl()", "spawnlp()", "spawnv()", et "spawnvp()"
   causent toutes un héritage de l'environnement du processus actuel
   par le processus fils. Notez que les clefs et les valeurs du
   dictionnaire *env* doivent être des chaînes de caractères. Des
   valeurs invalides pour les clefs ou les valeurs met la fonction en
   échec et renvoie "127".

   Par exemple, les appels suivants à "spawnlp()" et "spawnvpe()" sont
   équivalents :

      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)

   Disponibilité : Unix, Windows. "spawnlp()", "spawnlpe()",
   "spawnvp()", et "spawnvpe()" ne sont pas disponibles sur Windows.
   "spawnle()" et "spawnve()" ne sont pas sécurisés pour les appels
   concurrents (*thread-safe*) sur Windows, il est conseillé
   d'utiliser le module "subprocess" à la place.

   Modifié dans la version 3.6: Accepte un *path-like object*.

os.P_NOWAIT
os.P_NOWAITO

   Valeurs possibles pour le paramètre *mode* de la famille de
   fonctions "spawn*". Si l'une de ces valeurs est donnée, les
   fonctions "spawn*()" sortiront dès que le nouveau processus est
   créé, avec le PID du processus comme valeur de retour.

   Disponibilité : Unix, Windows.

os.P_WAIT

   Valeur possible pour le paramètre *mode* de la famille de fonctions
   "spawn*". Si *mode* est défini par cette valeur, les fonctions
   "spawn*" ne se terminent pas tant que le nouveau processus n'a pas
   été complété et renvoient le code de sortie du processus si
   l'exécution est effectuée avec succès, ou "-signal" si un signal
   tue le processus.

   Disponibilité : Unix, Windows.

os.P_DETACH
os.P_OVERLAY

   Valeurs possibles pour le paramètre *mode* de la famille de
   fonctions "spawn*". Ces valeurs sont moins portables que celles
   listées plus haut. "P_DETACH" est similaire à "P_NOWAIT", mais le
   nouveau processus est détaché de la console du processus appelant.
   Si "P_OVERLAY" est utilisé, le processus actuel sera remplacé. La
   fonction "spawn*" ne sort jamais.

   Disponibilité : Windows.

os.startfile(path[, operation])

   Lance un fichier avec son application associée.

   Quand *operation* n'est pas spécifié ou vaut "'open'", l'effet est
   le même qu'un double clic sur le fichier dans Windows Explorer, ou
   que de passer le nom du fichier en argument du programme **start**
   depuis l'invite de commande interactif : le fichier est ouvert avec
   l'application associée à l'extension (s'il y en a une).

   Quand une autre *operation* est donnée, ce doit être une "commande-
   verbe" qui spécifie ce qui devrait être fait avec le fichier. Les
   verbes habituels documentés par Microsoft sont "'print'" et
   "'edit'" (qui doivent être utilisés sur des fichiers) ainsi que
   "'explore'" et "'find'" (qui doivent être utilisés sur des
   répertoires).

   "startfile()" termine dès que l'application associée est lancée.Il
   n'y a aucune option permettant d'attendre que l'application ne se
   ferme et aucun moyen de récupérer le statu de sortie de
   l'application. Le paramètre *path* est relatif au répertoire
   actuel. Si vous voulez utiliser un chemin absolu, assurez-vous que
   le premier caractère ne soit pas un slash ("'/'"). La fonction
   Win32 "ShellExecute()" sous-jacente ne fonctionne pas sinon.
   Utilisez la fonction "os.path.normpath()" pour vous assurer que le
   chemin est encodé correctement pour Win32.

   Pour réduire Pour réduire le temps système de démarrage de
   l'interpréteur, la fonction Win32 "ShellExecute()"  ne se finit pas
   tant que cette fonction na pas été appelée. Si la fonction ne peut
   être interprétée, une "NotImplementedError" est levée.

   Disponibilité : Windows.

os.system(command)

   Exécute la commande (une chaîne de caractères) dans un sous-invite
   de commandes. C'est implémenté en appelant la fonction standard C
   "system()" et a les mêmes limitations. les changements sur
   "sys.stdin", etc. ne sont pas reflétés dans l'environnement de la
   commande exécutée. Si *command* génère une sortie, elle sera
   envoyée à l'interpréteur standard de  flux.

   Sur Unix, la valeur de retour est le statut de sortie du processus
   encodé dans le format spécifié pour "wait()". Notez que POSIX ne
   spécifie pas le sens de la valeur de retour de la fonction C
   "system()", donc la valeur de retour de la fonction Python est
   dépendante du système.

   Sur Windows, la valeur de retour est celle renvoyée par l'invite de
   commande système après avoir lancé *command*. L'invite de commande
   est donné par la variable d'environnement Windows "COMSPEC". Elle
   vaut habituellement **cmd.exe**, qui renvoie l'état de sortie de la
   commande lancée. Sur les systèmes qui utilisent un invite de
   commande non-natif, consultez la documentation propre à l'invite.

   Le module "subprocess" fournit des outils plus puissants pour
   générer de nouveaux processus et pour récupérer leur résultat. Il
   est préférable d'utiliser ce module plutôt que d'utiliser cette
   fonction. Voir la section Remplacer les fonctions plus anciennes
   par le module subprocess de la documentation du module "subprocess"
   pour des informations plus précises et utiles.

   Disponibilité : Unix, Windows.

os.times()

   Renvoie les temps globaux actuels d'exécution du processus. La
   valeur de retour est un objet avec cinq attributs :

   * "user" — le temps utilisateur

   * "system" — le temps système

   * "children_user" — temps utilisateur de tous les processus fils

   * "children_system" — le temps système de tous les processus fils

   * "elapsed" — temps écoulé réel depuis un point fixé dans le passé

   Pour des raisons de rétro-compatibilité, cet objet se comporte
   également comme un *tuple* contenant "user", "system",
   "children_user", "children_system", et "elapsed" dans cet ordre.

   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.

   Disponibilité : Unix, Windows.

   Modifié dans la version 3.3: Type de retour changé d'un *tuple* en
   un objet compatible avec le type *tuple*, avec des attributs
   nommés.

os.wait()

   Attend qu'un processus fils soit complété, et renvoie un *tuple*
   contenant son PID et son état de sortie : un nombre de 16 bits dont
   le *byte* de poids faible est le nombre correspondant au signal qui
   a tué le processus, et dont le *byte* de poids fort est le statut
   de sortie (si la signal vaut "0"). Le bit de poids fort du *byte*
   de poids faible est mis à 1 si un (fichier système) *core file* a
   été produit.

   Disponibilité : Unix.

os.waitid(idtype, id, options)

   Attend qu'un ou plusieurs processus fils soient complétés.
   *idtypes* peut être "P_PID", "P_PGID", ou "P_ALL". *id* spécifie le
   PID à attendre. *options* est construit en combinant (avec le OR
   bit-à-bit) une ou plusieurs des valeurs suivantes : "WEXITED",
   "WSTOPPED", ou "WCONTINUED" et peut additionnellement être combiné
   avec "WNOHANG" ou "WNOWAIT". La valeur de retour est un objet
   représentant les données contenue dans la structure "siginfo_t",
   nommées "si_pid", "si_uid", "si_signo", "si_status", "si_code" ou
   "None" si "WNOHANG" est spécifié et qu'il n'y a pas d'enfant dans
   un état que l'on peut attendre.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.P_PID
os.P_PGID
os.P_ALL

   Les valeurs possibles pour *idtypes* pour la fonction "waitid()".
   Elles affectent l'interprétation de *id*.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.WEXITED
os.WSTOPPED
os.WNOWAIT

   Marqueurs qui peuvent être utilisés pour la fonction "waitid()" qui
   spécifient quel signal attendre du fils.

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.CLD_EXITED
os.CLD_DUMPED
os.CLD_TRAPPED
os.CLD_CONTINUED

   Les valeurs possibles pour "si_code" dans le résultat renvoyé par
   "waitid()".

   Disponibilité : Unix.

   Nouveau dans la version 3.3.

os.waitpid(pid, options)

   Les détails de cette fonction diffèrent sur Unix et Windows.

   Sur Unix : attend qu'un processus fils donné par son id de
   processus *pid* soit terminé, et renvoie un *tuple* contenant son
   PID et son statut de sortie (encodé comme pour "wait()"). La
   sémantique de cet appel est affecté par la valeur de l'argument
   entier *options*, qui devrait valoir "0" pour les opérations
   normales.

   Si *pid* est plus grand que "0", "waitpid()" introduit une requête
   pour des informations sur le statut du processus spécifié. Si *pid*
   vaut "0", la requête est pour le statut de tous les fils dans le
   groupe de processus du processus actuel. Si *pid* vaut "-1", la
   requête concerne tous les processus fils du processus actuel. Si
   *pid* est inférieur à "-1", une requête est faite pour le statut de
   chaque processus du groupe de processus donné par "-pid" (la valeur
   absolue de *pid*).

   Une "OSError" est levée avec la valeur de *errno* quand l'appel
   système renvoie "-1".

   Sur Windows : attend que qu'un processus donné par l'identificateur
   de processus (*process handle*) *pid*  soi complété, et renvoie un
   *tuple* contenant *pid* et son statut de sortir décalé de 8 bits
   bers la gauche (le décalage rend l'utilisation multiplate-forme
   plus facile). Un *pid* inférieur ou égal à "0" n'a aucune
   signification particulière sur Windows, et lève une exception.
   L'argument entier *options* n'a aucun effet. *pid* peut faire
   référence à tout processus dont l'identifiant est connue pas
   nécessairement un processus fils. Les fonctions "spawn*" appelées
   avec "P_NOWAIT" renvoient des identificateurs de processus
   appropriés.

   Modifié dans la version 3.5: Si l'appel système est interrompu et
   que le gestionnaire de signal ne lève aucune exception, la fonction
   réessaye l'appel système au lieu de lever une "InterruptedError"
   (voir la **PEP 475** à propos du raisonnement).

os.wait3(options)

   Similaire à la fonction "waitpid()", si ce n'est que qu'aucun
   argument *id* n'est donné, et qu'un triplet contenant l'identifiant
   du processus fils, son statut de sortie, et une information sur
   l'utilisation des ressources est renvoyé. Référez-vous à
   "resource"."getrusage()" pour des détails sur les informations
   d'utilisation des ressources. L'argument *options* est le même que
   celui fourni à "waitpid()" et "wait4()".

   Disponibilité : Unix.

os.wait4(pid, options)

   Similaire à "waitpid()", si ce n'est qu'un triplet contenant
   l'identifiant du processus fils, son statut de sortie, et des
   informations d'utilisation des ressources est renvoyé. Référez-vous
   à "resource"."getrusage()" pour des détails sur les informations
   d'utilisation des ressources. Les arguments de "wait4()" sont les
   mêmes que ceux fournis à "waitpid()".

   Disponibilité : Unix.

os.WNOHANG

   L'option de "waitpid()" pour terminer immédiatement si aucun statut
   de processus fils n'est disponible dans l'immédiat. La fonction
   renvoie "(0, 0)" dans ce cas.

   Disponibilité : Unix.

os.WCONTINUED

   Cette option cause les processus fils à être reportés s'ils ont été
   continués après un arrêt du *job control* depuis leurs derniers
   reports de statuts.

   Disponibilité : certains systèmes Unix.

os.WUNTRACED

   Cette option cause les processus fils à être reportés s'ils ont été
   stoppés mais que leur état actuel n'a pas été reporté depuis qu'ils
   ont été stoppés.

   Disponibilité : Unix.

Les fonctions suivantes prennent un code de statu tel que renvoyé par
"system()", "wait()", ou "waitpid()" en paramètre. Ils peuvent être
utilisés pour déterminer la disposition d'un processus.

os.WCOREDUMP(status)

   Renvoie "True" si un vidage système (*core dump*) a été généré pour
   le processus, sinon, renvoie "False".

   This function should be employed only if "WIFSIGNALED()" is true.

   Disponibilité : Unix.

os.WIFCONTINUED(status)

   Return "True" if a stopped child has been resumed by delivery of
   "SIGCONT" (if the process has been continued from a job control
   stop), otherwise return "False".

   See "WCONTINUED" option.

   Disponibilité : Unix.

os.WIFSTOPPED(status)

   Return "True" if the process was stopped by delivery of a signal,
   otherwise return "False".

   "WIFSTOPPED()" only returns "True" if the "waitpid()" call was done
   using "WUNTRACED" option or when the process is being traced (see
   *ptrace(2)*).

   Disponibilité : Unix.

os.WIFSIGNALED(status)

   Return "True" if the process was terminated by a signal, otherwise
   return "False".

   Disponibilité : Unix.

os.WIFEXITED(status)

   Return "True" if the process exited terminated normally, that is,
   by calling "exit()" or "_exit()", or by returning from "main()";
   otherwise return "False".

   Disponibilité : Unix.

os.WEXITSTATUS(status)

   Return the process exit status.

   This function should be employed only if "WIFEXITED()" is true.

   Disponibilité : Unix.

os.WSTOPSIG(status)

   Renvoie le signal qui a causé l'arrêt du processus.

   This function should be employed only if "WIFSTOPPED()" is true.

   Disponibilité : Unix.

os.WTERMSIG(status)

   Return the number of the signal that caused the process to
   terminate.

   This function should be employed only if "WIFSIGNALED()" is true.

   Disponibilité : Unix.


Interface pour l'ordonnanceur
=============================

Ces fonctions contrôlent un processus se voit allouer du temps de
processus par le système d'exploitation. Elles ne sont disponibles que
sur certaines plate-formes Unix. Pour des informations plus
détaillées, consultez les pages de manuels Unix.

Nouveau dans la version 3.3.

Les polices d'ordonnancement suivantes sont exposées si elles sont
gérées par le système d'exploitation.

os.SCHED_OTHER

   La police d'ordonnancement par défaut.

os.SCHED_BATCH

   Police d'ordonnancement pour les processus intensifs en utilisation
   du processeur. Cette police essaye de préserver l'interactivité
   pour le reste de l'ordinateur.

os.SCHED_IDLE

   Police d'ordonnancement pour les tâches de fond avec une priorité
   extrêmement faible.

os.SCHED_SPORADIC

   Police d'ordonnancement pour des programmes serveurs sporadiques.

os.SCHED_FIFO

   Une police d'ordonnancement *FIFO* (dernier arrivé, premier servi).

os.SCHED_RR

   Une police d'ordonnancement *round-robin* (tourniquet).

os.SCHED_RESET_ON_FORK

   Cette option peut combiner différentes politiques d'ordonnancement
   avec un OU bit-à-bit. Quand un processus avec cette option se
   dédouble, la politique d'ordonnancement et la priorité du processus
   fils sont remises aux valeurs par défaut.

class os.sched_param(sched_priority)

   Cette classe représente des paramètres d'ordonnancement réglables
   utilisés pour "sched_setparam()", "sched_setscheduler()", et
   "sched_getparam()". Un objet de ce type est immuable.

   Pour le moment, il n'y a qu'un seul paramètre possible :

   sched_priority

      La priorité d'ordonnancement pour une police d'ordonnancement.

os.sched_get_priority_min(policy)

   Récupère la valeur minimum pour une priorité pour la police
   *policy*. *policy* est une des constantes de police définies ci-
   dessus.

os.sched_get_priority_max(policy)

   Récupère la valeur maximum pour une priorité pour la police
   *policy*. *policy* est une des constantes de police définies ci-
   dessus.

os.sched_setscheduler(pid, policy, param)

   Définit la police d'ordonnancement pour le processus de PID *pid*.
   Un *pid* de "0" signifie le processus appelant. *policy* est une
   des constantes de police définies ci-dessus. *param* est une
   instance de la classe "sched_param".

os.sched_getscheduler(pid)

   Renvoie la police d'ordonnancement pour le processus de PID *pid*.
   Un *pid* de 0 signifie le processus appelant. Le résultat est une
   des constantes de police définies ci-dessus.

os.sched_setparam(pid, param)

   Définit un paramètre d'ordonnancement pour le processus de PID
   *pid*. Un *pid* de "0" signifie le processus appelant. *param* est
   une instance de "sched_param".

os.sched_getparam(pid)

   Renvoie les paramètres d'ordonnancement dans une de "sched_param"
   pour le processus de PID *pid*. Un *pid* de "0" signifie le
   processus appelant.

os.sched_rr_get_interval(pid)

   Renvoie le quantum de temps du *round-robin* (en secondes) pour le
   processus de PID *pid*. Un *pid* de "0" signifie le processus
   appelant.

os.sched_yield()

   Abandonne volontairement le processeur.

os.sched_setaffinity(pid, mask)

   Restreint le processus de PID *pid*  (ou le processus actuel si
   *pid* vaut "0") à un ensemble de CPUs. *mask* est un itérable
   d'entiers représentant l'ensemble de CPUs auquel le processus doit
   être restreint.

os.sched_getaffinity(pid)

   Renvoie l'ensemble de CPUs auquel le processus de PID *pid* (ou le
   processus actuel si *pid* vaut "0") est restreint.


Diverses informations sur le système
====================================

os.confstr(name)

   Renvoie les valeurs de configuration en chaînes de caractères.
   *name* spécifie la valeur de configuration à récupérer. Ce peut
   être une chaîne de caractères représentant le nom d'une valeur
   système définie dans un nombre de standards (POSIX, Unix 95, Unix
   98, et d'autres). Certaines plate-formes définissent des noms
   supplémentaires également. Les noms connus par le système
   d'exploitation hôte sont données dans les clefs du dictionnaire
   "confstr_names". Pour les variables de configuration qui ne sont
   pas incluses dans ce *mapping*, passer un entier pour *name* est
   également accepté.

   Si la valeur de configuration spécifiée par *name* n'est pas
   définie, "None" est renvoyé.

   Si *name* est une chaîne de caractères et n'est pas connue, une
   "ValueError" est levée. Si une valeur spécifique pour *name* n'est
   pas gérée par le système hôte, même si elle est incluse dans
   "confstr_names", une "OSError" est levée avec "errno.EINVAL" pour
   numéro d'erreur.

   Disponibilité : Unix.

os.confstr_names

   Dictionnaire liant les noms acceptés par "confstr()" aux valeurs
   entières définies pour ces noms par le système d'exploitation hôte.
   Cela peut être utilisé pour déterminer l'ensemble des noms connus
   du système.

   Disponibilité : Unix.

os.cpu_count()

   Renvoie le nombre de CPUs dans le système. Renvoie "None" si
   indéterminé.

   Ce nombre n'est pas équivalent au nombre de CPUs que le processus
   courant peut utiliser.  Le nombre de CPUs utilisables peut être
   obtenu avec "len(os.sched_getaffinity(0))"

   Nouveau dans la version 3.4.

os.getloadavg()

   Renvoie le nombre de processus dans la file d'exécution du système
   en moyenne dans les dernières 1, 5, et 15 minutes, ou lève une
   "OSError" si la charge moyenne est impossible à récupérer.

   Disponibilité : Unix.

os.sysconf(name)

   Renvoie les valeurs de configuration en nombres entiers. Si la
   valeur de configuration définie par *name* n'est pas spécifiée,
   "-1" est renvoyé. Les commentaires concernant le paramètre *name*
   de "confstr()" s'appliquent également ici, le dictionnaire qui
   fournit les informations sur les noms connus est donné par
   "sysconf_names".

   Disponibilité : Unix.

os.sysconf_names

   Dictionnaire liant les noms acceptés par "sysconf()" aux valeurs
   entières définies pour ces noms par le système d'exploitation hôte.
   Cela peut être utilisé pour déterminer l'ensemble des noms connus
   du système.

   Disponibilité : Unix.

Les valeurs suivantes sont utilisées pour gérer les opérations de
manipulations de chemins. Elles sont définies pour toutes les plate-
formes.

Des opérations de plus haut niveau sur les chemins sont définies dans
le module "os.path".

os.curdir

   La chaîne de caractère constante utilisée par le système
   d'exploitation pour référencer le répertoire actuel. Ça vaut "'.'"
   pour Windows et POSIX. Également disponible par "os.path".

os.pardir

   La chaîne de caractère constante utilisée par le système
   d'exploitation pour référencer le répertoire parent. Ça vaut "'..'"
   pour Windows et POSIX. Également disponible par "os.path".

os.sep

   Le caractère utilisé par le système d'exploitation pour séparer les
   composantes des chemins. C'est "'/'" pour POSIX, et "'\\'" pour
   Windows. Notez que ce n'est pas suffisant pour pouvoir analyser ou
   concaténer correctement des chemins (utilisez alors
   "os.path.split()" et "os.path.join()"), mais ça peut s'avérer utile
   occasionnellement.  Également disponible par "os.path".

os.altsep

   Un caractère alternatif utilisé par le système d'exploitation pour
   séparer les composantes des chemins, ou "None" si un seul
   séparateur existe. Ça vaut "'/'" sur Windows où "sep" est un
   antislash "'\'". Également disponible par "os.path".

os.extsep

   Le caractère qui sépare la base du nom d'un fichier et son
   extension. Par exemple, le "'.'" de "os.py". Également disponible
   par "os.path".

os.pathsep

   Le caractère conventionnellement utilisé par le système
   d'exploitation pour séparer la recherche des composantes de chemin
   (comme dans la variable d'environnement "PATH"). Cela vaut "':'"
   pour POSIX, ou "';'" pour Windows. Également disponible par
   "os.path".

os.defpath

   Le chemin de recherche par défaut utilisé par "exec*" et "spawn*"
   si l'environnement n'a pas une clef "'PATH'". Également disponible
   par "os.path".

os.linesep

   La chaîne de caractères utilisée pour séparer (ou plutôt pour
   terminer) les lignes sur la plate-forme actuelle. Ce peut être un
   caractère unique (comme "'\n'" pour POSIX,) ou plusieurs caractères
   (comme "'\r\n'" pour Windows). N'utilisez pas *os.linesep* comme
   terminateur de ligne quand vous écrivez dans un fichier ouvert en
   mode *texte* (par défaut). Utilisez un unique "'\n'" à la place,
   sur toutes les plate-formes.

os.devnull

   Le chemin de fichier du périphérique *null*. Par exemple :
   "'/dev/null'" pour POSIX, "'nul'" pour Windows. Également
   disponible par "os.path".

os.RTLD_LAZY
os.RTLD_NOW
os.RTLD_GLOBAL
os.RTLD_LOCAL
os.RTLD_NODELETE
os.RTLD_NOLOAD
os.RTLD_DEEPBIND

   Marqueurs à utiliser avec les fonctions "setdlopenflags()" et
   "getdlopenflags()". Voir les pages de manuel Unix *dlopen(3)* pour
   les différences de significations entre les marqueurs.

   Nouveau dans la version 3.3.


Nombres aléatoires
==================

os.getrandom(size, flags=0)

   Obtient *size* octets aléatoires. La fonction renvoie
   éventuellement moins d'octets que demandé.

   Ces octets peuvent être utilisés pour initialiser un générateur de
   nombres aléatoires dans l'espace utilisateur ou pour des raisons
   cryptographiques.

   "getrandom()" se base sur l'entropie rassemblée depuis les pilotes
   des périphériques et autres sources de bruits de l'environnement.
   La lecture de grosses quantités de données aura un impact négatif
   sur les autres utilisateurs des périphériques "/dev/random" et
   "/dev/urandom".

   L'argument *flags* est un champ de bits qui peut contenir zéro ou
   plus des valeurs suivantes combinées avec un OU bit-à-bit :
   "os.GRND_RANDOM" et "GRND_NONBLOCK".

   Voir aussi la page de manuel Linux pour getrandom().

   Disponibilité : Linux 3.17 et ultérieures.

   Nouveau dans la version 3.6.

os.urandom(size)

   Renvoie une chaîne de *size* octets aléatoires utilisable dans un
   cadre cryptographique.

   Cette fonction renvoie des octets aléatoires depuis un source
   spécifique à l'OS.  Les données renvoyées sont censées être
   suffisamment imprévisibles pour les applications cryptographiques,
   bien que la qualité dépende de l'implémentation du système.

   Sous Linux, si l'appel système "getrandom()" est disponible, il est
   utilisé en mode bloquant : il bloque jusqu'à ce que la réserve
   d'entropie d'*urandom* soit initialisée (128 bits d'entropie sont
   collectés par le noyau). Voir la **PEP 524** pour plus
   d'explications. Sous Linux, la fonction "getrandom()" peut être
   utilisée pour obtenir des octets aléatoires en mode non-bloquant
   (avec l'option "GRND_NONBLOCK") ou attendre jusqu'à ce que la
   réserve d'entropie d'*urandom* soit initialisée.

   Sur un système de type UNIX, les octets aléatoires sont lus depuis
   le périphérique "/dev/urandom". Si le périphérique "/dev/urandom"
   n'est pas disponible ou n'est pas lisible, l'exception
   "NotImplementedError" est levée.

   Sous Windows, "CryptGenRandom()" est utilisée.

   Voir aussi:

     Le module "secrets" fournit des fonctions de plus haut niveau.
     Pour une interface facile à utiliser du générateur de nombres
     aléatoires fourni par votre plate-forme, veuillez regarder
     "random.SystemRandom".

   Modifié dans la version 3.6.0: Sous Linux, "getrandom()" est
   maintenant utilisé en mode bloquant pour renforcer la sécurité.

   Modifié dans la version 3.5.2: Sous Linux, si l'appel système
   "getrandom()" bloque (la réserve d'entropie d'*urandom* n'est pas
   encore initialisée), réalise à la place une lecture de
   "/dev/urandom".

   Modifié dans la version 3.5: Sur Linux 3.17 et plus récent, l'appel
   système "getrandom()" est maintenant utilisé quand il est
   disponible. Sur OpenBSD 5.6 et plus récent, la fonction C
   "getentropy()" est utilisée. Ces fonctions évitent l'utilisation
   interne d'un descripteur de fichier.

os.GRND_NONBLOCK

   Par défaut, quand elle lit depuis "/dev/random", "getrandom()"
   bloque si aucun octet aléatoire n'est disponible, et quand elle lit
   depuis "/dev/urandom", elle bloque si la réserve d'entropie n'a pas
   encore été initialisée.

   Si l'option "GRND_NONBLOCK" est activée, "getrandom()" ne bloque
   pas dans ces cas, mais lève immédiatement une "BlockingIOError".

   Nouveau dans la version 3.6.

os.GRND_RANDOM

   Si ce bit est activé, les octets aléatoires sont puisés depuis
   "/dev/random" plutôt que "/dev/urandom".

   Nouveau dans la version 3.6.
