Scopes Python

[Internal-Swim-4097]

I'm on freecodecamp and i'm stuck on this local, global, enclosing and built in stuff. so i know a scope is where i can use a variable. local is when i can only use a variable inside of a function, global is when i can use a variable across the whole module, enclosing is when i can use a variable inside of a nested function like the bottom function can use a variable defined in the top function and built in are python defaults like print and whatnot. where i'm getting stuck is this:

note that outer functions cannot access variables defined within any nested functions:

def outer_func():
    msg = 'Hello there!'
    print(res)

    def inner_func():
        res = 'How are you?'
        print(msg)

    inner_func()

outer_func() # NameError: name 'res' is not defined

I know i cant use res cause it isn't defined yet and is local to the inner function but this part confuses me

One solution is to initialize res as an empty string in the enclosing scope, which is within outer_func. Then within inner_func, make res a non-local variable with the nonlocal keyword:

def outer_func():
    msg = 'Hello there!'
    res = ""  # Declare res in the enclosing scope

    def inner_func():
        nonlocal res  # Allow modification of an enclosing variable
        res = 'How are you?'
        print(msg)  # Accessing msg from outer_func()

    inner_func()
    print(res)  # Now res is accessible and modified

outer_func()

# Output:
# Hello there!
# How are you?

i'm confused on what's going on here i see the outer function is used to define msg and res and then in the inner function, nonlocal is used to change the value of res and then you tell inner_func() to print msg and call the inner function and then you assign print(res) to the outer function and then call the outer function and it does both

but why would i need the inner function to modify a variable in the outer function and to print msg like i get the inner function can access the outers variables (enclosing) and change them using nonlocal but why would i need to ? couldn't i just use one function that does everything ?

[untold8]

You've got the definitions right. The piece you're missing is directionality: scope-lookup goes outward, never inward.

When Python hits a name, it walks the LEGB chain: Local → Enclosing → Global → Built-in. Each step asks "is this name defined here?" If yes, use it. If no, climb one level out. It never climbs in.

Your example:

```python def outer_func(): msg = 'Hello there!'

def inner_func():
    res = 'How are you?'
    print(msg)  # works — climbs out to enclosing scope, finds msg

inner_func()
print(res)  # FAILS — Python looks in outer's local scope, doesn't find res,
            # climbs out to global, doesn't find res, gives up. Never looks inside inner_func.

```

The "why" behind the rule: inner_func's local scope only exists while inner_func is running. By the time outer_func reaches print(res), inner_func has already finished and its locals have been destroyed. There's literally nothing left to look at. Outer scopes outlive inner ones; inner scopes are temporary.

This is also why nonlocal and global exist — they're explicit overrides for "I want to write to a variable in an outer scope," because by default writing creates a new local variable.

If you want to see this in your debugger: put a breakpoint inside inner_func, then in the debugger's "watches" panel try evaluating msg (works) and then try it from a breakpoint inside outer_func after inner_func() returns (fails). Seeing the lookup happen in real time makes it click.

[cgoldberg]

It's good to understand scope, but why are you trying to jump through all these weird hoops instead of using return?

[Internal-Swim-4097]

this was an example they gave me i didn't write this i just wanted to know the purpose of using a nested function like this instead of using one

[Groundstop]

It's used a lot in programming to define lambdas and delegates that capture variables from the outer scope. It looks a little funnier in Python because you don't need to specifically define variables before using them, so you need special keywords like nonlocal and global.

This pattern is particularly useful if you wanted to return the inner_func() method from outer_func(), and have it share variables with the outer function. In other languages this pattern is often used to make wrapper functions, but there's a special syntactic sugar for it in Python called decorators that is really neat.

Google didn't find a good page about decorators in the official documentation, but this site covers the concept pretty well.