"atexit" — Gestionnaire de fin de programme
*******************************************

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

Le module "atexit" définit des fonctions pour inscrire et désinscrire
des fonctions de nettoyage. Les fonctions ainsi inscrites sont
automatiquement exécutées au moment de l'arrêt normal de
l'interpréteur. "atexit" exécute ces fonctions dans l'ordre inverse
dans lequel elles ont été inscrites ; si vous inscrivez "A", "B", et
"C", au moment de l'arrêt de l'interpréteur elles seront exécutées
dans l'ordre "C", "B", "A".

**Note:** Les fonctions inscrites via ce module ne sont pas appelées
quand le programme est tué par un signal non géré par Python, quand
une erreur fatale interne de Python est détectée, ou quand
"os._exit()" est appelé.

Modifié dans la version 3.7: Quand elles sont utilisées avec des sous-
interpréteurs de l'API C, les fonctions inscrites sont locales à
l'interpréteur dans lequel elles ont été inscrites.

atexit.register(func, *args, **kwargs)

   Inscrit *func* comme une fonction à exécuter au moment de l'arrêt
   de l'interpréteur. Tout argument optionnel qui doit être passé à
   *func* doit être passé comme argument à "register()". Il est
   possible d'inscrire les mêmes fonctions et arguments plus d'une
   fois.

   Lors d'un arrêt normal du programme (par exemple, si "sys.exit()"
   est appelée ou l’exécution du module principal se termine), toutes
   les fonctions inscrites sont appelées, dans l'ordre de la dernière
   arrivée, première servie. La supposition est que les modules les
   plus bas niveau vont normalement être importés avant les modules
   haut niveau et ainsi être nettoyés en dernier.

   Si une exception est levée durant l'exécution du gestionnaire de
   fin de programme, une trace d'appels est affichée (à moins que
   "SystemExit" ait été levée) et les informations de l'exception sont
   sauvegardées. Une fois que tous les gestionnaires de fin de
   programme ont eu une chance de s'exécuter, la dernière exception à
   avoir été levée l'est de nouveau.

   Cette fonction renvoie *func*, ce qui rend possible de l'utiliser
   en tant que décorateur.

atexit.unregister(func)

   Retire *func* de la liste des fonctions à exécuter à l'arrêt de
   l’interpréteur. Après avoir appelé "unregister()", *func* est
   garantie de ne pas être appelée à l'arrêt de l’interpréteur, même
   si elle a été inscrite plus d'une fois. "unregister()" ne fait rien
   et reste muette dans le cas où *func* n'a pas été inscrite
   précédemment.

Voir aussi:

  Module "readline"
     Un exemple utile de l'usage de "atexit" pour lire et écrire des
     fichiers d'historique "readline".


Exemple avec "atexit"
=====================

Le simple exemple suivant démontre comment un module peut initialiser
un compteur depuis un fichier quand il est importé, et sauver le
valeur mise à jour du compteur automatiquement quand le programme se
termine, sans avoir besoin que l'application fasse un appel explicite
dans ce module au moment de l'arrêt de l'interpréteur.

   try:
       with open("counterfile") as infile:
           _count = int(infile.read())
   except FileNotFoundError:
       _count = 0

   def incrcounter(n):
       global _count
       _count = _count + n

   def savecounter():
       with open("counterfile", "w") as outfile:
           outfile.write("%d" % _count)

   import atexit
   atexit.register(savecounter)

Les arguments positionnels et nommés peuvent aussi être passés à
"register()" afin d'être repassés à la fonction inscrite lors de son
appel :

   def goodbye(name, adjective):
       print('Goodbye, %s, it was %s to meet you.' % (name, adjective))

   import atexit
   atexit.register(goodbye, 'Donny', 'nice')

   # or:
   atexit.register(goodbye, adjective='nice', name='Donny')

Utilisation en tant que *décorateur* :

   import atexit

   @atexit.register
   def goodbye():
       print("You are now leaving the Python sector.")

Ceci fonctionne uniquement avec des fonctions qui peuvent être
appelées sans argument.
