LEGB

Python has names and references
LEGB
Examples
dir(), vars()
Resources

Python has names and references

An assignment statement creates a symbolic name that you can use to reference an object. The statement x = 'foo' creates a symbolic name x that refers to the string object 'foo'.

Namespace = declarative region that provides a scope to the identifiers. Collection of currently defined symbolic names along with information about the object that each name references.

Local = locals() returns dict(), returns copy of local namespace
Enclosing

nonlocal a

Global = globals() returns dict(), returns reference to object

global a

Built-In namespace = dir(__builtins__)

Examples

def a():
    print(c)
    b = c + 10
    print(c)

c = 20 # You can declare c before the function too
a() # 20 20

========================================================================
def a():
    print(c)
    c = 30
    print(c)

c = 20
a() # UnboundLocalError: local variable 'c' referenced before assignment

# WHY?
# Python decides whether a name is local at compile time,
# by scanning the whole function body 
# — not while running it line by line

# When the compiler builds a function, 
# it looks for any assignment to a name anywhere in the body:
# c = ..., c += ..., for c in ..., with ... as c, import c, def c, class c, except ... as c.
# If it finds one, c is a local for the entire function, including the lines above the assignment.

def fоo():
	return total + 1

total = 0
print(foo()) # 1

dеf f(): 
    s = "I love London!"
    рrint(s) 

s = "I love Paris!" 
f()
рrint(s)

# I love London!
# I love Paris!
========================================================================
def f(): 
   print(s)
   s = "I love London!"
   print(s)
 
s = "I love Paris!"
f()
# UnboundLocalError: local variable 's' referenced before assignment

# Question 1
a = [1, 2, 3]

def add(x):
	# print(a)
	a += [x]

add(4) # Error, a += [X] -> a is not declared, we must use "global a" or a.append(X)
print(a)

# a += [x] desugars roughly to: a = a.__iadd__([x])

========================================================================
# Correct version of previous question 1
a = [1, 2, 3]

def add(x):
	# print(a)
	a.append(x)

add(4)
print(a) # [1, 2, 3, 4]

========================================================================
# Question 3: Pass the list as an argument
a = [1, 2, 3]

def add(a):
	print(id(a))
	a += [4]
	print(id(a))

print(id(a)) # All ID are the same
add(a)
print(a) # [1,2,3,4]

def nwe():
    b = (2, 4)
    print(locals()['b'])
    locals()['b'] += (4,)
    print(locals())
    print(b)

nwe()
# (2, 4)
# {'b': (2, 4)}
# (2, 4)

# WHY? locals() inside a function is a snapshot, not the real thing. 
# if you use += for tuple it will work, but different object will be created

dir(), vars()

Use dir(x) when you want a quick list of everything an object can do (including inherited methods, class attributes, and __slots__).
Use vars(x) when you need a dictionary of key-value pairs for an object's instance state (its actual stored data).
Use inspect module when you need deep metadata (e.g., source code, function signatures, or exact type hints).
Use hasattr() / getattr() when you want to dynamically check or access an attribute using a string variable.
vars()

Python objects usually store their instance variables in a dictionary that belongs to the object (except for slots). vars(x) returns this dictionary (as does x.__dict__)
if vars() is without argument then it returns locals()
vars(obj) simply retrieves obj.__dict__

dir()

dir(obj) implicitly calls obj.__dir__() if defined
dir(__builtins__)
dir returns slots, while vars doesn’t
displays class attributes as well
dir(x), returns a dictionary of x's "attributes, its class's attributes, and recursively the attributes of its class's base classes."

Resources

https://realpython.com/python-namespaces-scope/