Sto lavorando a uno script Python che avvia diversi processi e connessioni al database. Ogni tanto voglio uccidere lo script con un segnale Ctrl+ Ce mi piacerebbe fare un po 'di pulizia.

In Perl farei questo:

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

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

Come posso fare l'analogo di questo in Python?

Registra il tuo gestore con in signal.signalquesto modo:

#!/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()

Codice adattato da qui .

Più documentazione su signalè disponibile qui .  

Puoi trattarlo come un'eccezione (KeyboardInterrupt), come qualsiasi altro. Crea un nuovo file ed eseguilo dalla shell con i seguenti contenuti per vedere cosa intendo:

import time, sys

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

E come gestore del contesto:

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

Usare:

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

Gestori nidificati:

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

Da qui: https://gist.github.com/2907502

Puoi gestire CTRL+ Ccatturando l' KeyboardInterrupteccezione. È possibile implementare qualsiasi codice di pulizia nel gestore delle eccezioni.

Dalla documentazione di 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

Ancora un altro frammento

Indicato maincome funzione principale e exit_gracefullycome gestore CTRL+c

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

Ho adattato il codice di @udi per supportare più segnali (niente di speciale):

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

Questo codice supporta la chiamata di interruzione della tastiera ( SIGINT) e il SIGTERM( kill <process>)

In contrasto con Matt J la sua risposta, io uso un oggetto semplice. Questo mi dà la possibilità di analizzare questo gestore a tutti i thread che devono essere arrestati in modo sicuro.

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)

Altrove

while True:
    # task
    if handler.SIGINT:
        break

È possibile utilizzare le funzioni nel modulo di segnale integrato di Python per configurare i gestori di segnale in Python. In particolare, la signal.signal(signalnum, handler)funzione viene utilizzata per registrare la handlerfunzione per il segnale signalnum.

grazie per le risposte esistenti, ma aggiunte 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

Se vuoi assicurarti che il tuo processo di pulizia finisca, aggiungerei la risposta di Matt J usando un SIG_IGN in modo da SIGINTignorare ulteriormente ciò che impedirà l'interruzione della tua pulizia.

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, non ho potuto usare try / tranne KeyboardInterrupt perché stavo usando la modalità socket standard (IPC) che sta bloccando. Quindi il SIGINT è stato cueued, ma è arrivato solo dopo aver ricevuto i dati sul socket.

L'impostazione di un gestore di segnali si comporta allo stesso modo.

D'altra parte, questo funziona solo per un terminale reale. Altri ambienti di partenza potrebbero non accettare Ctrl+ Co pre-gestire il segnale.

Inoltre, ci sono "Eccezioni" e "BaseExceptions" in Python, che differiscono nel senso che l'interprete deve uscire in modo pulito, quindi alcune eccezioni hanno una priorità più alta rispetto ad altre (Eccezioni derivate da BaseException)