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

Nouveau dans la version 2.0.

**Source code:** Lib/atexit.py

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

The "atexit" module defines a single function to register cleanup
functions.  Functions thus registered are automatically executed upon
normal interpreter termination.  "atexit" runs these functions in the
*reverse* order in which they were registered; if you register "A",
"B", and "C", at interpreter termination time they will be run in the
order "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é.

This is an alternate interface to the functionality provided by the
"sys.exitfunc()" variable.

Note: This module is unlikely to work correctly when used with other
code that sets "sys.exitfunc".  In particular, other core Python
modules are free to use "atexit" without the programmer’s knowledge.
Authors who use "sys.exitfunc" should convert their code to use
"atexit" instead.  The simplest way to convert code that sets
"sys.exitfunc" is to import "atexit" and register the function that
had been bound to "sys.exitfunc".

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.

   At normal program termination (for instance, if "sys.exit()" is
   called or the main module’s execution completes), all functions
   registered are called in last in, first out order.  The assumption
   is that lower level modules will normally be imported before higher
   level modules and thus must be cleaned up later.

   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.

   Modifié dans la version 2.6: This function now returns *func*,
   which makes it possible to use it as a decorator.

Voir aussi:

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


28.9.1. 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:
       _count = int(open("counter").read())
   except IOError:
       _count = 0

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

   def savecounter():
       open("counter", "w").write("%d" % _count)

   import atexit
   atexit.register(savecounter)

Les arguments positionnels et par mot-clé 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.
