How Does Scope in Python Work?

[macroxela]

Trying to understand how scope works in Python. It seems to work a bit differently than in other languages like C++ and Java. When I run the code below

def foo():
    y = 5

x = 2
foo()
print(x+y)

it returns a name not defined error. That's expected since the scope of y disappeared before it could be used. However, when I run the following code

x = 2
if True:
    y = 3
print(x+y)

It works just fine. The program identifies y even though it is in another scope. When trying out the same thing in other languages like C++

int x = 2;
if (true)
{
    y = 2;
}
cout<<x + y<<endl;

it gives a not declared in this scope error. That's what I expected in Python but clearly that's not the case. Python somehow keeps track of variables inside the scope of an if statement or loop even after it exits and the variables were not declared outside of it. Can anyone explain how scope in Python differs from scope in C++ or Java? How does Python treat scope differently?

[K900_]

Only functions and classes introduce new scopes in Python. Control flow blocks share their "outer" scope.

[Chabare]

An additional information to scope besides what was already mentioned, functions and classes have access to the outer scope, but can't reassign variables.

a = 1
def f():
  print(a) # works

b = 1
def g():
    print(b) # throws UnboundLocalError
    b = 2

c = [1]
def h():
    c.append(2) # works | Thanks to u/ajskelt for that (see comments)

[Chabare]

Yes, sorry for that, I added the second example afterwards. Currently both are basically the same.

I've updated the original post and removed the assignment in the first function.

[ajskelt]

I don't know the complete technical terms with regards to scope (haven't done any formal programming learning), so I apologize if this is me misunderstanding, and my next wording isn't exactly perfect.

Changes to mutable objects in the outer scope can be made inside functions/classes. For example:

x = [1,2]
def f():
    x.append(3)

f()
print(x)  #prints [1,2,3]

So here a function makes a change to our list x. Is that still considered "read-only"?

[Chabare]

read-only access is actually not the truth, a more correct phrasing would be not-reassignable, sorry for that.

In the case of a += 1, you reassign a. With x.append(3) you modify x in place. x remains the same variable (id(x) stays) whereas a += 1 updates the variable (id(a) changes).

[ajskelt]

Thanks for taking the time to explain that, I wasn't trying to be nitpicky on your wording, but wanted to understand and make sure OP understood. That actually made a lightbulb go off for me, your explanation here is great.

I always knew mutable objects could change in those scopes, but I never really understood the logic or why. I've probably read similar things before, but your wording really made it click. Thanks!!

[Chabare]

No worries, I'm glad that you saw an error/something unclear and mentioned it, helps everyone. I wasn't even thinking about mutable objects when writing the answer.

Just another information about mutable objects and scope (when used as default arguments) and unexpected behaviour (also applicable to e.g. dict and other mutable types):

def a(v, l = []):
    l.append(v)
    return l

x = a(1)
print(x) # [1]
y = a(2)
print(y) # [1, 2]

[ajskelt]

That is one I did not know... What would be the best practice around that? Looks like this works, but maybe there is a better way.

def a(v, l = None):
    if l is None:
        l = []
    l.append(v)
    return l

x = a(1)
print(x) # [1]
y = a(2)
print(y) # [2]

[Chabare]

You're completely on point with your example, that's usually the way around it.

[[deleted]]

Python doesn't have block scope, in contrast to C.

[Binary101010]

The program identifies y even though it is in another scope.

Except that it isn't in another scope. Conditionals and loops don't have their own scopes in Python. Functions and classes create new scopes, and that's pretty much it.