Saya sedang mengerjakan skrip python yang memulai beberapa proses dan koneksi basis data. Sesekali saya ingin membunuh skrip dengan aCtrlC sinyal + , dan saya ingin melakukan pembersihan.

Di Perl saya akan melakukan ini:

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

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

Bagaimana saya melakukan analog ini dengan Python?

Daftarkan pawang Anda dengan signal.signalseperti ini:

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

Kode diadaptasi dari sini .

Dokumentasi lebih lanjut signaldapat ditemukan di sini .  

Anda dapat memperlakukannya seperti pengecualian (KeyboardInterrupt), seperti yang lainnya. Buat file baru dan jalankan dari shell Anda dengan konten berikut untuk melihat apa yang saya maksud:

import time, sys

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

Dan sebagai manajer konteks:

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

Menggunakan:

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

Penangan bersarang:

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

Dari sini: https://gist.github.com/2907502

Anda dapat menangani CTRL+ Cdengan menangkap KeyboardInterruptpengecualian. Anda bisa menerapkan kode pembersihan apa pun di penangan pengecualian.

Dari dokumentasi 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

Cuplikan Lain

Disebut mainsebagai fungsi utama dan exit_gracefullysebagai CTRL+ cpenangan

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

Saya mengadaptasi kode dari @udi untuk mendukung beberapa sinyal (tidak ada yang mewah):

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

Kode ini mendukung panggilan interupsi keyboard ( SIGINT) dan SIGTERM( kill <process>)

Berbeda dengan Matt J jawabannya, saya menggunakan objek sederhana. Ini memberi saya kemungkinan untuk mengurai handler ini ke semua utas yang perlu dihentikan keamanannya.

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)

Di tempat lain

while True:
    # task
    if handler.SIGINT:
        break

Anda dapat menggunakan fungsi-fungsi dalam modul sinyal built-in Python untuk mengatur penangan sinyal dengan python. Secara khusus signal.signal(signalnum, handler)fungsi ini digunakan untuk mendaftarkan handlerfungsi untuk sinyal signalnum.

terima kasih atas jawaban yang ada, tetapi ditambahkan 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

Jika Anda ingin memastikan bahwa proses pembersihan Anda selesai, saya akan menambahkan jawaban Matt J dengan menggunakan SIG_IGN sehingga lebih lanjut SIGINTdiabaikan yang akan mencegah pembersihan Anda terganggu.

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

Secara pribadi, saya tidak bisa menggunakan try / kecuali KeyboardInterrupt karena saya menggunakan mode standard socket (IPC) yang memblokir. Jadi SIGINT dikeluarkan, tetapi datang hanya setelah menerima data pada soket.

Mengatur pengatur sinyal berperilaku sama.

Di sisi lain, ini hanya berfungsi untuk terminal aktual. Lingkungan awal lainnya mungkin tidak menerima Ctrl+C , atau menangani sinyal sebelumnya.

Juga, ada "Pengecualian" dan "BaseExceptions" dalam Python, yang berbeda dalam arti bahwa penerjemah perlu keluar dengan bersih sendiri, sehingga beberapa pengecualian memiliki prioritas yang lebih tinggi daripada yang lain (Pengecualian berasal dari BaseException)