KeyboardInterrupt

Ctrl+C arrives as an exception — deliberately outside Exception, so catch-all error handlers cannot trap the user in a running program.

InheritsBaseException›KeyboardInterrupt
Control-flow exceptionPython 3 (all)Live demo
KeyboardInterrupt(*args)
Raised by
Ctrl+C in a terminal (SIGINT), signal.raise_signal(signal.SIGINT)
Message
empty — the traceback ends in a bare KeyboardInterrupt
Quick fix
except KeyboardInterrupt: at the top level, cleanup in finally
Watch out
a bare except: swallows it and the program will not stop

Demo

Live evaluation
A loop whose inner except Exception skips bad records. Step bad_at raises ValueError; step stop_at simulates Ctrl+C.
Try:
Inputs
bad_atintstep that raises ValueError
stop_atintstep that "presses Ctrl+C"
Code
log = []
try:
    for i in range(5):
        try:
            if i == 1:
                raise ValueError('bad record')
            if i == 3:
                raise KeyboardInterrupt  # stands in for Ctrl+C
            log.append(i)
        except Exception:
            log.append('skipped')
except KeyboardInterrupt:
    log.append('stopped')
log
Result
[0, 'skipped', 2, 'stopped']

The ValueError at bad_at is 'skipped' and the loop carries on — that is what except Exception is for. The KeyboardInterrupt at stop_at goes straight through the same handler and ends the loop, because KeyboardInterrupt is not an Exception. The demo raises it explicitly; in a real program the interpreter raises it at whatever line is running when you press Ctrl+C.

Constructor

NameTypeRequiredDescription
*argsobjectnoNormally none — Python raises it without arguments.

Attributes

AttributeTypeMeaning
argstupleEmpty when raised by Ctrl+C.
__traceback__traceback | NoneShows the line that was executing when the interrupt arrived — useful for finding where a program hangs.

Common patterns

Graceful exit from a CLI
Catch it once at the entry point, print a short message instead of a traceback, and exit with a non-zero status.
import sys

def main():
    ...

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print('\ncancelled', file=sys.stderr)
        sys.exit(130)
Stop a long loop but keep partial results
Save what was done, then re-raise so the program still exits as interrupted.
results = []
try:
    for item in items:
        results.append(process(item))
except KeyboardInterrupt:
    save(results)
    raise
Handle SIGINT without an exception
Install a signal handler that sets a flag; the loop finishes the current step and stops cleanly.
import signal

stop = False
def on_sigint(signum, frame):
    global stop
    stop = True
signal.signal(signal.SIGINT, on_sigint)

while not stop:
    do_one_step()

Examples

1. Not an Exception subclass
issubclass(KeyboardInterrupt, Exception)
Returns
False
2. Simulate Ctrl+C with a real SIGINT
import signal try: signal.raise_signal(signal.SIGINT) except KeyboardInterrupt: r = 'got Ctrl+C' r
Returns
'got Ctrl+C'
3. except Exception lets it through
try: try: raise KeyboardInterrupt except Exception: r = 'caught by except Exception' except KeyboardInterrupt: r = 'reached the outer handler' r
Returns
'reached the outer handler'
4. finally still runs
log = [] try: try: raise KeyboardInterrupt finally: log.append('files closed') except KeyboardInterrupt: log.append('interrupted') log
Returns
['files closed', 'interrupted']
5. A custom SIGINT handler replaces it
import signal seen = [] old = signal.signal(signal.SIGINT, lambda signum, frame: seen.append(signum)) signal.raise_signal(signal.SIGINT) signal.signal(signal.SIGINT, old) seen == [signal.SIGINT]
Returns
True
6. The default handler is what raises it
import signal signal.getsignal(signal.SIGINT) is signal.default_int_handler
Returns
True
7. Uncaught, the last line has no message
raise KeyboardInterrupt
Returns
KeyboardInterrupt

Pitfalls

1. A bare except makes the program unstoppable
A retry loop with except: catches Ctrl+C as if it were a failed attempt and keeps going. except Exception lets the interrupt end the loop.
bare except
log = []
for attempt in range(3):
    try:
        raise KeyboardInterrupt  # user presses Ctrl+C
    except:
        log.append('retrying')
log
['retrying', 'retrying', 'retrying']
except Exception
log = []
try:
    for attempt in range(3):
        try:
            raise KeyboardInterrupt  # user presses Ctrl+C
        except Exception:
            log.append('retrying')
except KeyboardInterrupt:
    log.append('stopped')
log
['stopped']
2. Catching it and carrying on silently
Swallowing the interrupt hides that the work is incomplete. Clean up, then re-raise (or exit with a non-zero status).
swallow
done = []
def run():
    try:
        for i in range(5):
            if i == 2:
                raise KeyboardInterrupt
            done.append(i)
    except KeyboardInterrupt:
        pass
    return 'finished'
run()
'finished'
clean up, re-raise
done = []
def run():
    try:
        for i in range(5):
            if i == 2:
                raise KeyboardInterrupt
            done.append(i)
    except KeyboardInterrupt:
        done.append('partial')
        raise
    return 'finished'
try:
    run()
except KeyboardInterrupt:
    r = done
r
[0, 1, 'partial']

When to use

Use it
  • Top-level except KeyboardInterrupt in a CLI to exit without a traceback
  • Saving partial progress before re-raising
  • Recognising it in logs: the traceback shows where the program was when interrupted
Reach for something else
  • Catch-all error handling → except Exception (it already excludes Ctrl+C)
  • Long-running services → handle SIGINT/SIGTERM with signal handlers
  • Continuing normally after Ctrl+C → the user asked the program to stop

Notes

CPython impl
Modules/signalmodule.c — the default SIGINT handler (signal.default_int_handler) raises KeyboardInterrupt in the main thread
Threads
Only the main thread receives it; worker threads keep running unless they check a flag or are daemon threads
Timing
Signal handlers run between bytecode instructions, so a long call into C code may not be interrupted until it returns
Docs note
Because it can arrive at any line, it may leave state inconsistent — the docs advise ending the program as quickly as possible

FAQ

KeyboardInterrupt inherits directly from BaseException, not Exception — on purpose, so that catch-all error handlers do not prevent the user from stopping the program with Ctrl+C. Catch it explicitly with except KeyboardInterrupt, or use except BaseException if you really mean everything.