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)

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.

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!!!

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

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

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.

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])

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.

You need something stronger than try to open a new scope, such as def or class. Your code has scoping rules similar to this version:

while True:

    width = int(input("Please enter the width of your floor plan:\n   "))
    height = int(input("Please enter the height of your floor plan:\n   "))
    if width <= 0 or height <= 0:
        print("You have entered and invalid character. Please enter characters only. Press enter to continue\n")
    else:
        print("Success!")
        break

print(width)
print(height)

I assume that you're familiar with this scoping.

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.

Answering a slightly different question: The value total_due is accessible if and only if an error isn't raised during the input or float execution. If no error is raised, then total_due is available immediately. Post back if you have more questions. Good luck!!

Blocks like try and except (but also if, elif, else, with) have no "local scope". However you can't and shouldn't expect that any code in the try block will be executed (because it could fail and go directly in the except or finally block).

But are you sure that "" as "failing" user_id makes sense? Why not something else, for example None?

Also you should avoid catching all exceptions, so I would prefer something like this:

try:
    userid = get_userid()
except Exception:  # or a more specific exception
    userid = None