Je travaille sur un script python qui démarre plusieurs processus et connexions à la base de données. De temps en temps, je veux tuer le script avec un signal Ctrl+ C, et je voudrais faire un peu de nettoyage.

En Perl, je ferais ceci:

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

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

Comment puis-je faire l'analogue de cela en Python?

Enregistrez votre gestionnaire avec signal.signalcomme ceci:

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

Code adapté d' ici .

Vous signaltrouverez plus de documentation sur ici .  

Vous pouvez le traiter comme une exception (KeyboardInterrupt), comme n'importe quelle autre. Créez un nouveau fichier et exécutez-le à partir de votre shell avec le contenu suivant pour voir ce que je veux dire:

import time, sys

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

Et en tant que gestionnaire de contexte:

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

Utiliser:

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

Gestionnaires imbriqués:

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

À partir d'ici: https://gist.github.com/2907502

Vous pouvez gérer CTRL+ Cen interceptant l' KeyboardInterruptexception. Vous pouvez implémenter n'importe quel code de nettoyage dans le gestionnaire d'exceptions.

De la documentation 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

Encore un autre extrait

Référé maincomme fonction principale et exit_gracefullycomme gestionnaire CTRL+c

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

J'ai adapté le code de @udi pour supporter plusieurs signaux (rien d'extraordinaire):

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

Ce code prend en charge l'appel d'interruption clavier ( SIGINT) et SIGTERM( kill <process>)

Contrairement à Matt J, sa réponse, j'utilise un objet simple. Cela me donne la possibilité d'analyser ce gestionnaire pour tous les threads qui doivent être arrêtés en sécurité.

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)

Autre part

while True:
    # task
    if handler.SIGINT:
        break

Vous pouvez utiliser les fonctions du module de signal intégré de Python pour configurer des gestionnaires de signal en python. Plus précisément, la signal.signal(signalnum, handler)fonction est utilisée pour enregistrer la handlerfonction pour le signal signalnum.

merci pour les réponses existantes, mais ajouté 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 vous voulez vous assurer que votre processus de nettoyage se termine, j'ajouterais à la réponse de Matt J en utilisant un SIG_IGN afin que d'autres SIGINTsoient ignorés, ce qui empêchera votre nettoyage d'être interrompu.

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()

Personnellement, je ne pouvais pas utiliser try / except KeyboardInterrupt car j'utilisais le mode socket standard (IPC) qui bloque. Le SIGINT a donc été mis en file d'attente, mais n'est venu qu'après avoir reçu des données sur le socket.

La définition d'un gestionnaire de signaux se comporte de la même manière.

En revanche, cela ne fonctionne que pour un terminal réel. D'autres environnements de démarrage peuvent ne pas accepter Ctrl+ Cou pré-gérer le signal.

De plus, il existe des "Exceptions" et "BaseExceptions" en Python, qui diffèrent dans le sens où l'interpréteur doit se fermer proprement, donc certaines exceptions ont une priorité plus élevée que d'autres (les exceptions sont dérivées de BaseException)