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

Note: The effect of registering or unregistering functions from within a cleanup function is undefined.

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 au moment de l'arrêt de l'interpréteur. `unregister()` ne fait rien et reste silencieux si func n'a pas été préalablement inscrite. Si func a été inscrite plus d'une fois, toutes les occurrences de cette fonction sont retirées de la pile d'appels de `atexit`. La comparaison d'égalité (`==`) est utilisée dans l'implémentation interne de la désinscription. Les références des fonctions n'ont donc pas besoin d'avoir la même identité.

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.