how to close python script without just activating "except" in try/except statement

Question

I have a python script running over some 50,000 items in a database, it takes about 10 seconds per item and I want to stop it.

But, if i just press ctrl + C while the code is in the try except part, then my program enter the expect statement and delete that item then continue. The only way to close the program is to repeatedly delete items this way until I, just be sheer luck, catch it not in the try statement.

How do I exit the script without just killing a try statement?

EDIT 1

I have a statement that looks something like this:

for item in items:
   try:
      if is_item_gone(content) == 1:
         data = (item['id'])
         db.update('UPDATE items SET empty = 0 WHERE id = (%s);', data)
      else:
          do alot of stuff
   except:
      data = (item['id'])
      db.delete('...')

EDIT 2

The top of my connect to db code looks like:

#!/usr/bin/python
import MySQLdb
import sys

class Database:
....

Answer 1

The issue is because you are using a blanket except which is always a bad idea, if you catch specific exceptions then when you KeyboardInterrupt your script will stop:

for item in items:
   try:
      if is_item_gone(content) == 1:
         data = (item['id'])
         db.update('UPDATE items SET empty = 0 WHERE id = (%s);', data)
      else:
          do alot of stuff
   except MySQLdb.Error  as e:
      print(e)
      data = (item['id'])
      db.delete('...')

If you have other exceptions to catch you can use multiple in the except:

 except (KeyError, MySQLdb.Error) as e

At the very least you could catch Exception as e and print the error.

for item in items:
   try:
      if is_item_gone(content) == 1:
         data = (item['id'])
         db.update('UPDATE items SET empty = 0 WHERE id = (%s);', data)
      else:
          do alot of stuff
   except Exception as e:  
      print(e)
      data = (item['id'])
      db.delete('...')

The moral of the story is don't use a blanket except, catch what you expect and logging the errors might also be a good idea. The exception-hierarchy is also worth reading to see exactly what you are catching.

Answer 2

I would rewrite it like this:

try:
    # ...
except KeyboardInterrupt:
    sys.exit(1)
except Exception:  # I would use a more specific exception here if you can.
    data = (item['id'])
    db.delete('...')

Or just

try:
    # ...
except Exception:  # I would use an even more specific exception here if you can.
    data = (item['id'])
    db.delete('...')

Python 2's exception hiearchy can be found here: https://docs.python.org/2/library/exceptions.html#exception-hierarchy

Also, many scripts are written with something like this boiler plate at the bottom:

def _main(args):
   ...

if __name__ == '__main__':
    try:
        sys.exit(_main(sys.argv[1:]))
    except KeyboardInterrupt:
        print >> sys.stderr, '%s: interrupted' % _SCRIPT_NAME
        sys.exit(1)

When you use except: instead of except Exception: in your main body, you are not allowing this top level exception block to catch the KeyboardInterrupt. (You don't have to actually catch it for Ctrl-C to work -- this just makes it prettier when KeyboardInterrupt is raised.)

Answer 3

import signal
import MySQLdb
import sys

## Handle process signals:
def sig_handler(signal, frame):
    global connection
    global cursor

    cursor.close()
    connection.close()

    exit(0)

## Register a signal to the handler:
signal.signal(signal.SIGINT, sig_handler)

class Database:
    # Your class stuf here.
    # Note that in sig_handler() i close the cursor and connection,
    # perhaps your class has a .close call? If so use that.

for item in items:
   try:
      if is_item_gone(content) == 1:
         data = (item['id'])
         db.update('UPDATE items SET empty = 0 WHERE id = (%s);', data)
      else:
          do alot of stuff
   except MySQLdb.Error  as e:
      data = (item['id'])
      db.delete('...')

This would register and catch for instance Ctrl+c at any given time. The handler would terminate a socket accordingly, then exit with exit code 0 which is a good exit code.

This is a more "global" approach to catching keyboard interrupts.