It is a scoping thing, or rather, the lack of a scope. Python does not have block scopes; the only thing that defines a new scope in Python is a function definition. (Comprehensions do, too, but that's because they are implemented using anonymous functions.)

There is no "local" x in either the try block or the except block; both are the same x as defined before the try statement.

One exception: e is kind of local. It's still in the same scope as x, but it is unset by the try statement once it completes to avoid a reference cycle, just as if you had written del e immediately after the statement.

try statements do not create a new scope, but text won't be set if the call to url lib.request.urlopen raises the exception. You probably want the print(text) line in an else clause, so that it is only executed when there is no exception.

try:
    url = "http://www.google.com"
    page = urllib.request.urlopen(url)
    text = page.read().decode('utf8')
except (ValueError, RuntimeError, TypeError, NameError):
    print("Unable to process your request dude!!")
else:
    print(text)

If text needs to be used later, you really need to think about what its value is supposed to be if the assignment to page fails and you can't call page.read(). You can give it an initial value prior to the try statement:

text = 'something'
try:
    url = "http://www.google.com"
    page = urllib.request.urlopen(url)
    text = page.read().decode('utf8')
except (ValueError, RuntimeError, TypeError, NameError):
    print("Unable to process your request dude!!")

print(text)

or in the else clause:

try:
    url = "http://www.google.com"
    page = urllib.request.urlopen(url)
    text = page.read().decode('utf8')
except (ValueError, RuntimeError, TypeError, NameError):
    print("Unable to process your request dude!!")
else:
    text = 'something'

print(text)

If you are trying to change a global variable from an inner scope, then in that inner scope you need to have global company. Sometimes it can't be avoided but doing so is usually a "code smell"

The built-in try function does not create its own scope. Modules, classes, and functions create scope. A complete description of Python scopes and namespaces (https://docs.python.org/3/tutorial/classes.html#python-scopes-and-namespaces) in the docs. Although scopes are determined statically, they are used dynamically. At any time during execution, there are at least three nested scopes whose namespaces are directly accessible: • the innermost scope, which is searched first, contains the local names (The variables a and b) • the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also non-global names (Arguments num1 and num2. If assigned, then they become local) • the next-to-last scope contains the current module’s global names (The add function) • the outermost scope (searched last) is the namespace containing built-in names (try, except, else, float, return, None, and ValueError) Post back if you need more help. Good luck!!!

the one line you call fails, which means that process is never bound (because the code never makes it that far!). so there's no way to do that.

in other words, when you call subprocess.Popen an exception is raised, so there's no result to set process to.

I hadn't tried this before, but what it seems happens is that as creates and removes the variable name for its scope. So you enter the first except block and it adds error to the local namespace. Then you enter the second except block for the IndexError and that adds error to the local scope. Then you leave that except block and it removes error from the local scope. Then you try to use error but the previous step had "cleaned it up" and so it's not in your local namespace any more. Given that, if you want to keep track of the error you'll have to use some variable other than the one you define in as to hold it.

You won't get a SyntaxError from missing data. Do you mean a KeyError? And assuming info is a dictionary, you don't need a try at all. Just use get with a default value: sector = find_sector.info.get('sector', the_default_value_here) If it's only a incomplete Mapping type that doesn't support get, it would be simply: try: sector = find_sector.info['sector'] except KeyError: sector = the_default_value_here

Add the line global foobar to the top of get_foobar()

This tells the bytecode compiler you want to reference the variable in this function using global scope instead of local.

Assignment implicitly changes a variable's scope to local for the whole function scope.

In bytecode:

## code input (local)
def test():
    print foobar
    foobar = 2

## bytecode output
#
# 3           0 LOAD_FAST                0 (foobar)
#             3 PRINT_ITEM 
#             4 PRINT_NEWLINE
# 
# 4           5 LOAD_CONST               1 (2)
#             8 STORE_FAST               0 (foobar)
#            11 LOAD_CONST               0 (None)
#            14 RETURN_VALUE

## code input (global)
def test():
    global foobar
    print foobar
    foobar = 2

## bytecode output
#
# 4           0 LOAD_GLOBAL              0 (foobar)
#             3 PRINT_ITEM 
#             4 PRINT_NEWLINE 
#
# 5           5 LOAD_CONST               1 (2)
#             8 STORE_GLOBAL             0 (foobar)
#            11 LOAD_CONST               0 (None)
#            14 RETURN_VALUE

Notice the usage of LOAD_FAST and STORE_FAST instead of LOAD_GLOBAL and STORE_GLOBAL. The Python dis module documentation has a list of opcodes for reference.

You can use this code to quickly dump the bytecode for a function:

import compiler, dis
code = compiler.compile('''
def test():
    print foobar
    foobar = 2
''', '__main__', 'exec')
dis.dis(code.co_consts[1])

What's wrong with the "else" clause ?

for filename in files:
    try:
        im = Image.open(os.path.join(dirname,filename))
    except IOError, e:
        print "error opening file :: %s : %s" % (os.path.join(dirname,filename), e)
    else:
        print im.size

Now since you're in a loop, you can also use a "continue" statement:

for filename in files:
    try:
        im = Image.open(os.path.join(dirname,filename))
    except IOError, e:
        print "error opening file :: %s : %s" % (os.path.join(dirname,filename), e)
        continue

    print im.size

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 had the same question and I don't quite understand Adam's answer. The idea, as far as I am concerned, was to only declare the variable before the try block: int minutes; Then define it within the try block, so the exception (if any) would still be caught. Also in this case there does not seem to be a need to include the rest of the code in the try block, so only this definition could be included in the try block, and the rest is outside: try { minutes = int.Parse(entry); } catch(FormatException) { // ... } I have tried running this code and it seems to work properly. So what would be the rationale to include everything in the try block instead of only the definition that may trigger the exception? Thanks for your help.

Python does not have block scope. Anything defined inside the try block will be available outside.

That said, you would still have a problem: if it is the getConnection() call that raises the error, cursor will be undefined, so the reference in the finally block will error.