Stop Right There: Understanding Python's KeyboardInterrupt Exception

The KeyboardInterrupt exception is raised when the user interrupts the execution of a programtypically by pressing a combination of keys like Ctrl+C (Control-C) on a terminal or command prompt.

It is one of Python's Built-in Exceptionsmeaning you don't need to import anything special to use or catch it.

This exception is the standard way to signal a running Python script to stop immediately and is generally considered a graceful way to terminate a programunlikesaykilling the process externally.

While KeyboardInterrupt is straightforwarda few common issues and "traps" pop up

A common mistake is using a bare except or catching KeyboardInterrupt too generally and doing nothingwhich can make it impossible to stop the program.

This code will run forever and pressing Ctrl+C won't stop it because the exception is caught and ignored.

import time

print("Press Ctrl+C to stop (or so you think!)")
try:
    while True:
        # Some critical operation
        print("Working...")
        time.sleep(1)
#  This catches KeyboardInterrupt and prevents the program from stopping.
except Exception:
    pass 
# The program will silently continue forever!

If you need to catch it for cleanup but still want the program to terminateyou should re-raise the exception or explicitly exit.

import time
import sys

print("Press Ctrl+C to stop.")
try:
    while True:
        print("Working...")
        time.sleep(1)
except KeyboardInterrupt:
    print("\n Interruption detected! Performing cleanup...")
    # Clean up resources (close filesdisconnect from networksetc.)
    # ...
    print("Cleanup complete. Exiting gracefully.")
    # Use sys.exit() or just let the block end to terminate
    sys.exit(0) # Explicitly exit the program

Some operations performed by external C/C++ libraries or system calls (like certain I/O operations or tight computations) might be not immediately interruptible.

There isn't a direct Python solution for thisas it's a limitation of the external code. Howeverwhen using librarieslook for timeouts or non-blocking modes as alternatives. For code you controlensure you return to Python frequently.

The best practice is to use KeyboardInterrupt to trigger a graceful shutdown. This means catching the interruptperforming necessary cleanupand then exitingensuring data integrity.

This example shows how to use a try...except block to ensure cleanup code runs before the program terminates.

import time
import os

# Imagine this is a resource we need to closelike a file handle or a database connection
def open_resource():
    print(" Resource acquired (e.g.file opened).")
    return "DB_CONNECTION_OBJECT"

def close_resource(resource):
    print(f" Closing resource: {resource}...")
    # Add actual closing logic here
    print("Resource released.")

# Main program loop
def run_program():
    resource = None
    try:
        resource = open_resource()
        print("Starting main loop. Press Ctrl+C to initiate graceful shutdown.")
        
        # Loop that does the main work
        while True:
            # Simulate work
            print("Working and saving progress...")
            time.sleep(2)
            
    #  This is where we catch the user interrupt!
    except KeyboardInterrupt:
        print("\n\n*** Keyboard Interrupt Detected! ***")
        
    finally:
        #  The 'finally' block ensures cleanup runs whether an exception occurred or not!
        if resource:
            close_resource(resource)
        
        print("Program finished gracefully.")

if __name__ == "__main__":
    run_program()