How to capture Ctrl+C termination signal in Python3

Technical Background

Long-running Python programs, such as server backends or scientific computing programs, require special attention. When performing certain operations, such as using Ctrl C to end a running program, we may need to terminate it early. Usually, there are two possibilities for this situation: one is that the program has an error and the program needs to be stopped for adjustment. The other is that the program itself is correct, but the program runs too slowly, or it may want to end early. In this scenario, we often hope to retain its corresponding calculation results. However, if we use some third-party data storage format to store data, it may not support continuous storage. It is very common to save the results after the program execution is completed. If the program is terminated midway, special means are needed to save its results.

Basic Case

Let’s first look at a relatively simple case: an ordinary program that prints numbers. It prints a number every 1 second. We can use python’s signal. signal to capture this termination signal.

# signal_exit.py
import signal
import sys
 
def signal_handler(signal, frame):
    print ('\nSignal Catched! You have just type Ctrl+C!')
    sys.exit(0)
 
if __name__ == '__main__':
    import time
 
    signal.signal(signal.SIGINT, signal_handler)
    for x in range(100):
        time.sleep(1)
        print (x)

When we run this program halfway and press Ctrl C at the same time, we will get the following results:

$ python3 signal_exit.py
0
1
2
^C
Signal Catched! You have just type Ctrl C!

This result shows that we captured the external operation of Ctrl C during the running of the program , and only after the operation is processed accordingly, the program is terminated. It should be noted that if the termination operation of sys.exit(0) is not added at this time, the program will not be stopped and will continue to run, which is equivalent to catching the abnormal termination signal but not doing any processing.

Pass external parameters to the termination signal

In the above case, we only captured the external signal of "termination of operation", but if we go further, we want to capture it to the end What is the output number, and how to operate it at this time? The signal.signal function itself does not support the passing of many parameters. At this time, it is recommended to create a class by yourself and encapsulate the signal_handler function as a member function of the class, so that we can obtain the corresponding internal parameters, such as the following case As shown:

# signal_exit.py
import signal
import sys
import time
 
class Printer:
    def __init__(self):
        self.x = 0
        signal.signal(signal.SIGINT, self.signal_handler)
 
    def signal_handler(self, signal, frame):
        print ('\nSignal Catched! You have just type Ctrl+C! The last number is: {}'.format(self.x))
        sys.exit(0)
 
    def run(self, counter=10):
        while self.x < counter:
            print (self.x)
            time.sleep(1)
            self.x += 1
 
if __name__ == &#39;__main__&#39;:
    printer = Printer()
    printer.run(counter=100)

At this time, if you press Ctrl C at the same time while the program is running, the result will be as follows:

$ python3 signal_exit.py
0
1
2
3
^C
Signal Catched! You have just type Ctrl C! The last number is: 3

As you can see, we succeeded The last output parameter is captured.

The above is the detailed content of How to capture Ctrl+C termination signal in Python3. For more information, please follow other related articles on the PHP Chinese website!