It's because of the design of the Python interpreter and interactive session.

Ctrl + C sends a signal, SIGINT, to the Python process, which the Python interpreter handles by raising the KeyboardInterrupt exception in the currently-running scope.

If the interpreter is running in an interactive session (i.e. by running python or python3 at the console), then the exception in the current function is printed and you return to the Python prompt. If the interpreter is running a script (e.g. by python3 my_script.py), then unless the KeyboardInterrupt is handled by the script, the whole program will stop when the exception is raised.

On Windows, in the interactive Python interpreter, the options to exit are:

• quit()

• exit()

• Ctrl + Z then Enter

• Ctrl + Break

When running scripts, Ctrl + C can generally be used to send a KeyboardInterrupt that halts script execution (note that a Traceback will be generated).

The Ctrl + Break option assumes your keyboard has a Break or Pause/Break key.

On Windows, the only sure way is to use Ctrl + Break. It stops every Python script instantly!

(Note that on some keyboards, "Break" is labeled as "Pause".)

CTRL + C sends an SIGINT signal to the active program and the program you are trying to terminate is not the active program at the time.

In such cases I like to save the process id in a file and later kill the process with with that process id.

To do so, I create 2 files, a start.sh and a stop.sh. I start my script using start.sh and stop it using the stop.sh

The start.sh

#!/bin/bash
echo "Starting my script..."
nohup python /link/to/script.py > /link/to/script.process.log 2>&1&
echo $! > /link/to/script.process.pid
echo "My script is now running."

The stop.sh

#!/bin/bash
echo "Stopping my script..."
kill -9 `cat /link/to/script.process.pid`
echo "My script is now stopped."

This works:

import subprocess
import time
import win32api
import win32con

proc = subprocess.Popen("ping -t localhost", stdin=subprocess.PIPE)
time.sleep(3) # just so it runs for a while

print "sending ctrl c"
try:
	win32api.GenerateConsoleCtrlEvent(win32con.CTRL_C_EVENT, 0)
	proc.wait()
except KeyboardInterrupt:
	print "ignoring ctrl c"

print "still running"

It sends ctrl-c to all processes that share the console of the calling process but then ignores it in the python process with an exception handler. You can't target the subprocess directly because that signal cannot be generated for process groups.

ctypes version

import subprocess
import time
import ctypes
proc = subprocess.Popen("ping -t localhost", stdin=subprocess.PIPE)
time.sleep(3) # just so it runs for a while

try:
	ctypes.windll.kernel32.GenerateConsoleCtrlEvent(0, 0)
	proc.wait()
except KeyboardInterrupt:
	print "ignoring ctrlc"
print "still running"

ctrl-break version

This can target the process specifically but with ping ctrl-break doesn't actually cause it to terminate. You may be able to use it with tshark though.

import subprocess
import time
import ctypes
proc = subprocess.Popen("ping -t localhost", stdin=subprocess.PIPE,
	creationflags=512) # CREATE_NEW_PROCESS_GROUP = 512
time.sleep(3) # just so it runs for a while

ctypes.windll.kernel32.GenerateConsoleCtrlEvent(1, proc.pid) # CTRL_BREAK_EVENT = 1
proc.wait()