Estoy trabajando en un script de Python que inicia varios procesos y conexiones de bases de datos. De vez en cuando quiero matar el script con una señal Ctrl+ C, y me gustaría hacer una limpieza.

En Perl haría esto:

$SIG{'INT'} = 'exit_gracefully';

sub exit_gracefully {
    print "Caught ^C \n";
    exit (0);
}

¿Cómo hago el análogo de esto en Python?

Registre su controlador con signal.signaleste:

#!/usr/bin/env python
import signal
import sys

def signal_handler(sig, frame):
    print('You pressed Ctrl+C!')
    sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
print('Press Ctrl+C')
signal.pause()

Código adaptado desde aquí .

signalPuede encontrar más documentación sobre aquí .  

Puede tratarlo como una excepción (KeyboardInterrupt), como cualquier otro. Cree un nuevo archivo y ejecútelo desde su shell con los siguientes contenidos para ver a qué me refiero:

import time, sys

x = 1
while True:
    try:
        print x
        time.sleep(.3)
        x += 1
    except KeyboardInterrupt:
        print "Bye"
        sys.exit()

Y como gestor de contexto:

import signal

class GracefulInterruptHandler(object):

    def __init__(self, sig=signal.SIGINT):
        self.sig = sig

    def __enter__(self):

        self.interrupted = False
        self.released = False

        self.original_handler = signal.getsignal(self.sig)

        def handler(signum, frame):
            self.release()
            self.interrupted = True

        signal.signal(self.sig, handler)

        return self

    def __exit__(self, type, value, tb):
        self.release()

    def release(self):

        if self.released:
            return False

        signal.signal(self.sig, self.original_handler)

        self.released = True

        return True

Usar:

with GracefulInterruptHandler() as h:
    for i in xrange(1000):
        print "..."
        time.sleep(1)
        if h.interrupted:
            print "interrupted!"
            time.sleep(2)
            break

Manejadores anidados:

with GracefulInterruptHandler() as h1:
    while True:
        print "(1)..."
        time.sleep(1)
        with GracefulInterruptHandler() as h2:
            while True:
                print "\t(2)..."
                time.sleep(1)
                if h2.interrupted:
                    print "\t(2) interrupted!"
                    time.sleep(2)
                    break
        if h1.interrupted:
            print "(1) interrupted!"
            time.sleep(2)
            break

Desde aquí: https://gist.github.com/2907502

Puede manejar CTRL+ Ccapturando la KeyboardInterruptexcepción. Puede implementar cualquier código de limpieza en el controlador de excepciones.

De la documentación de Python :

import signal
import time

def handler(signum, frame):
    print 'Here you go'

signal.signal(signal.SIGINT, handler)

time.sleep(10) # Press Ctrl+c here

Otro fragmento

Referido maincomo la función principal y exit_gracefullycomo el manejador CTRL+c

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        pass
    finally:
        exit_gracefully()

Adapte el código de @udi para admitir múltiples señales (nada lujoso):

class GracefulInterruptHandler(object):
    def __init__(self, signals=(signal.SIGINT, signal.SIGTERM)):
        self.signals = signals
        self.original_handlers = {}

    def __enter__(self):
        self.interrupted = False
        self.released = False

        for sig in self.signals:
            self.original_handlers[sig] = signal.getsignal(sig)
            signal.signal(sig, self.handler)

        return self

    def handler(self, signum, frame):
        self.release()
        self.interrupted = True

    def __exit__(self, type, value, tb):
        self.release()

    def release(self):
        if self.released:
            return False

        for sig in self.signals:
            signal.signal(sig, self.original_handlers[sig])

        self.released = True
        return True

Este código admite la llamada de interrupción del teclado ( SIGINT) y el SIGTERM( kill <process>)

En contraste con Matt J su respuesta, yo uso un objeto simple. Esto me da la posibilidad de analizar este controlador en todos los subprocesos que deben detenerse.

class SIGINT_handler():
    def __init__(self):
        self.SIGINT = False

    def signal_handler(self, signal, frame):
        print('You pressed Ctrl+C!')
        self.SIGINT = True


handler = SIGINT_handler()
signal.signal(signal.SIGINT, handler.signal_handler)

En otra parte

while True:
    # task
    if handler.SIGINT:
        break

Puede usar las funciones en el módulo de señal incorporado de Python para configurar manejadores de señal en python. Específicamente, la signal.signal(signalnum, handler)función se utiliza para registrar la handlerfunción para la señal signalnum.

gracias por las respuestas existentes, pero agregó signal.getsignal()

import signal

# store default handler of signal.SIGINT
default_handler = signal.getsignal(signal.SIGINT)
catch_count = 0

def handler(signum, frame):
    global default_handler, catch_count
    catch_count += 1
    print ('wait:', catch_count)
    if catch_count > 3:
        # recover handler for signal.SIGINT
        signal.signal(signal.SIGINT, default_handler)
        print('expecting KeyboardInterrupt')

signal.signal(signal.SIGINT, handler)
print('Press Ctrl+c here')

while True:
    pass

Si desea asegurarse de que finalice su proceso de limpieza, agregaría a la respuesta de Matt J utilizando un SIG_IGN para que SIGINTse ignoren aún más, lo que evitará que se interrumpa su limpieza.

import signal
import sys

def signal_handler(signum, frame):
    signal.signal(signum, signal.SIG_IGN) # ignore additional signals
    cleanup() # give your process a chance to clean up
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler) # register the signal with the signal handler first
do_stuff()

Personalmente, no pude usar try / except KeyboardInterrupt porque estaba usando el modo de socket estándar (IPC) que está bloqueando. Por lo tanto, el SIGINT se activó, pero llegó solo después de recibir datos en el zócalo.

Establecer un controlador de señal se comporta igual.

Por otro lado, esto solo funciona para un terminal real. Otros entornos de inicio podrían no aceptar Ctrl+ Co manejar previamente la señal.

Además, hay "Excepciones" y "BaseExceptions" en Python, que difieren en el sentido de que el intérprete debe salir de forma limpia, por lo que algunas excepciones tienen mayor prioridad que otras (las excepciones se derivan de BaseException)