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

  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.

  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.