Simple: while does not create a scope in Python. Python has only the following scopes:

• function scope (may include closure variables)
• class scope (only while the class is being defined)
• global (module) scope
• comprehension/generator expression scope

So when you leave the while loop, e, being a local variable (if the loop is in a function) or a global variable (if not), is still available.

tl;dr: Python is not C.

I later found an answer as PEP 3110 explains that in Python 3 the caught name is removed at the end of the except suite to enable more efficient garbage collection. There is also recommended syntax if you wish to avoid this occurring:

Situations where it is necessary to keep an exception instance around past the end of the except suite can be easily translated like so

try:
    ...
except E as N:
    ...
...

becomes

try:
    ...
except E as N:
    n = N
    ...
…

This way, when N is deleted at the end of the block, n will persist and can be used as normal.

Does python have an elegant way to handle this?

To avoid exceptions from printing unbound names, the most elegant way is not to print them; the second most elegant is to ensure the names do get bound, e.g. by binding them at the start of the function (the placeholder None is popular for this purpose).

If not, what about an inelegant way?

try: print 'b is', b
except NameError: print 'b is not bound'

In a complicated function I'd prefer to avoid testing the existence of every local variable before I, for example, printed debug information about them

Keeping your functions simple (i.e., not complicated) is highly recommended, too. As Hoare wrote 30 years ago (in his Turing acceptance lecture "The Emperor's old clothes", reprinted e.g. in this PDF):

There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.

Achieving and maintaining simplicity is indeed difficult: given that you have to implement a certain total functionality X, it's the most natural temptation in the world to do so via complicated accretion into a few complicated classes and functions of sundry bits and pieces, "clever" hacks, copy-and-paste-and-edit-a-bit episodes of "drive-by coding", etc, etc.

However, it's a worthwhile effort to strive instead to keep your functions "so simple that there are obviously no deficiencies". If a function's hard to completely unit-test, it's too complicated: break it up (i.e., refactor it) into its natural components, even though it will take work to unearth them. (That's actually one of the way in which a strong focus on unit testing helps code quality: by spurring you relentlessly to keep all the code perfectly testable, it's at the same time spurring you to make it simple in its structure).

Try/except blocks do not create a new scope in Python, which is why you can still use e after the block. (This answer has more information about scopes in Python.)

However, if an exception is not raised, e will never be created, so you can't later do if e without an UnboundLocalError occurring.

The return None is junk. Python will never get there.

You could simplify the code and run a little experiment to see if the value FOO is ever returned:

def foo():
    if True:
        raise ValueError('Bad value')
        return 'FOO'
    return 'BAR'

try:
    print(foo())
except ValueError as err:
    print(err)
    # Bad value

If FOO were returned, you might see it in print(foo()), but indeed that line prints nothing. Instead you see Bad value.

This is documented under, The try statement

When an exception has been assigned using as target, it is cleared at the end of the except clause. This is as if

except E as N:
    foo

was translated to

except E as N:
    try:
        foo
    finally:
        del N

This means the exception must be assigned to a different name to be able to refer to it after the except clause

Just rethrow the exception when you get it:

try:
  #do stuff
except KeyboardInterrupt:
  raise
except:
  #do other stuff

You specify that you get an exception that you know that you want to handle differently than default case, but you don't know how to handle it - so you just pass it, by throwing it again.

Some working example:

#!/usr/bin/python2

if __name__ == "__main__":
    try:
        while True:
            try:
                print(1)
            except KeyboardInterrupt:
                raise
            except:
                print(2)
    except KeyboardInterrupt:
        print('end')

Please note that you shouldn't use except:, as this is a bad practice. except: used in this example is used in sole purpose to make things as simple as possible.