\input{libatexit}

\section{\module{atexit} ---

exit handlers}

\declaremodule{standard}{atexit}

\moduleauthor{Skip Montanaro}{[email protected]}

\sectionauthor{Skip Montanaro}{[email protected]}

\modulesynopsis{Register and execute cleanup functions.}

The \module{atexit} module defines a single function to register

cleanup functions. Functions thus registered are automatically

executed upon normal interpreter termination.

Note: the functions registered via this module are not called when the program is killed by a

signal, when a Python fatal internal error is detected, or when

\code{os._exit()} is called.

This is an alternate interface to the functionality provided by the

\code{sys.exitfunc} variable.

\withsubitem{(in sys)}{\ttindex{exitfunc}}

\begin{funcdesc}{register}{func\optional{, *args\optional{, **kargs}}}

Register \var{func} as a function to be executed at termination. Any

optional arguments that are to be passed to \var{func} must be passed

as arguments to \function{register()}.

At normal program termination (for instance, if

\function{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.

\end{funcdesc}

\subsection{\module{atexit} Example \label{atexit-example}}

The following simple example demonstrates how a module can initialize

a counter from a file when it is imported and save the counter's

updated value automatically when the program terminates without

relying on the application making an explicit call into this module at

termination.

\begin{verbatim}

\end{verbatim}

will be called when the interpreter exits. Only one function may be

installed in this way; to allow multiple functions which will be called

at termination, use the \refmodule{atexit} module. Note: the exit function

_exithandlers = []

def _run_exitfuncs():

"""run any registered exit functions

while _exithandlers:

func, targs, kargs = _exithandlers[-1]

apply(func, targs, kargs)

_exithandlers.remove(_exithandlers[-1])

def register(func, *targs, **kargs):

"""register a function to be executed upon normal program termination

_exithandlers.append((func, targs, kargs))

import sys

try:

x = sys.exitfunc

except AttributeError:

sys.exitfunc = _run_exitfuncs

else:

# if x isn't our own exit func executive, assume it's another

# registered exit function - append it to our list...

if x != _run_exitfuncs:

register(x)

del sys

if __name__ == "__main__":

def x1():

print "running x1"

def x2(n):

print "running x2(%s)" % `n`

def x3(n, kwd=None):

print "running x3(%s, kwd=%s)" % (`n`, `kwd`)

register(x1)

register(x2, 12)

register(x3, 5, "bar")

register(x3, "no kwd args")

test_atexit

handler2 (7,) {'kw': 'abc'}

handler2 () {}

handler1

from test_support import verbose

import atexit

def handler1():

print "handler1"

def handler2(*args, **kargs):

print "handler2", args, kargs

_exithandlers = atexit._exithandlers

atexit._exithandlers = []

atexit.register(handler1)

atexit.register(handler2)

atexit.register(handler2, 7, kw="abc")

atexit._run_exitfuncs()

atexit._exithandlers = _exithandlers