Namespace and scope difference

[Uchikago]

I have read through a number of article about this but still can't get a sastified answer, can you guys help me!

What is the relationship between "Namespace" and "scope" can we say a scope is a superset of namespaces ? I mean we can access the outer namespace's name from the inner namespace but not vice versa, correct me if i'm wrong!. And the namespace only contain the name in that specific namespace, not the name in the inner?:

>>> a=2
>>> def inner():
...     b=3
...
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'inner']

[ichabod801]

A namespace is a mapping of names to objects. Common namespaces include modules and classes. They're typically implemented as dictionaries. However, note that a dictionary key can be something that is invalid as a Python name.

The scope of a namespace is the part of the program where the namespace can be referred to without qualification (that is, 'foo', as opposed to 'bar.foo'). So scope is not a superset of namespaces, it a relationship between namespaces and programs.

You can typically access outer namespaces from inner namespaces, but there are limits. One function can't access the namespace of the function that called it, as is possible in some other programming languages. However, a function in a module can access the names in the module's namespace. But note that you can have the same name in the function's namespace and the module's namespace. The function won't be able to access the one in the module's namespace (without some tricks), because it find the function's version of the name and stops there.

[perfringo]

Maybe this read will help you: what is relationship between namespace and scope

[Uchikago]

One function can't access the namespace of the function that called it, as is possible in some other programming languages.

I don't understand ! Isn't this a function access outer function's namespace?

>>> def inner():
...     y=1
...     def innermost():
...         print(y)
...     innermost()
...
...
>>> inner()
1

[ichabod801]

Isn't this a function access outer function's namespace?

Yes, but that's not a function calling another function, it's a function defined within another function.

def foo(x):
   z = x + 2
   return bar(x)

def bar(y):
   return y * z

foo()

The above will fail because bar does not have access to z.

[perfringo]

In order to fully understand namespace and scope you should familiarise yourself with closure as well. Python supports closures: functions that refer to variables from the scope in which they were defined.

ichabod801 used terms 'typically' and 'without some tricks' for a reason. There is much subtlety and in order to understand you must look at the whole picture.

There are behaviours which seem illogical at first but actually make sense if you think about it. Just to illustrate:

>>> def inner():
...     y = 1
...     def innermost():
...         y = 2
...     innermost()
...     print(y)
... 
>>> inner()
1
>>> def inner():
...     y = [1]
...     def innermost():
...         y[0] = 2
...     innermost()
...     print(y)
... 
>>> inner()
[2]

EDIT:

You should also understand difference between reference and assignment:

When you reference a variable in an expression, the Python interpreter will traverse the scope to resolve the reference in following order:

- current function’s scope
- any enclosing scopes (like containing functions)
- scope of the module that contains the code (global scope)
- built-in scope (that contains functions like int and abs)

If Python doesn't find defined variable with the referenced name, then a NameError exception is raised.

Assigning a value to a variable works differently. If the variable is already defined in the current scope, then it will just take on the new value. If the variable doesn’t exist in the current scope, then Python treats the assignment as a variable definition. The scope of the newly defined variable is the function that contains the assignment.

[ichabod801]

To add to what perfringo said, note that Python looks ahead for assignments:

>>> def foo():
...    print(x)
...    x = 3
...    return x + 5
...
>>> x = 5
>>> foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'x' referenced before assignment

Python saw that you were going to assign to x in the function, so it decided was in local scope. Then it processed the print call, and couldn't find x in the local scope, and didn't bother to check the further scopes as it otherwise would. If you didn't have the assignment, it would work just like prefringo says.

It is indeed a subtle and twisty topic.

[Uchikago]

I came accross this:

In Python, these non-local variables are read only by default and we must declare them explicitly as non-local (using nonlocal keyword) in order to modify them.

This isn't quite true right? i mean we can mutate mutable object just like what perfringo did with his example

>>> def inner():
...     y = [1]
...     def innermost():
...         y[0] = 2
...     innermost()
...     print(y)
...
>>> inner()
[2]

[ichabod801]

When you are mutating that list, you are no changing y's reference. y still points to the same place, just what is in that place has changed. If you tried to change how y is aimed, by saying y = [2], that would not change the outer y. If you declared y as nonlocal, y = [2] would change the outer y. However nonlocal (and it's cousin global) are generally frowned upon. They manipulate the scope of namespaces, and make your code hard to follow for people expecting namespaces to work in a certain way. Namespaces and scope are tricky enough without changing them around.

[Uchikago]

x=50
def func(x):
    print(f'X is {x}')
    x=200
    print(x)
func(x)

What about this, it worked because we have a parameter which create a local variable, so when we say

print(f'X is {x}')

X is the local variable not the global variable, they just shared the same object, correct me if i'm wrong please!