An identifier such as variable name is "in scope" if it is bound to a value.
Identifiers exist in "namespaces". Python namespaces are like dictionaries in that identifiers can be added or removed at execution time. This is called "dynamic scope".
This differs from languages such as C where the scope of an identifier is defined at compile time and is determined by the location of the identifier's declaration in the program. This is called "lexical scope".
In a Python function, we can create a local variable simply by assigning to it. The scope of variables assigned to within a function is limited to that function. Their scope is "local". This allows you to freely re-use names without worrying about conflicts with variables defined in other functions. Variables that are not assigned to in a function refer to variables in an enclosing scope (global scope or an enclosing function's scope).
Variables assigned to outside a function are in the __main__ namespace and are "global". It is possible to refer to a global variable by using the global statement.
In the following example there are two scopes: the global one where x and y are bound to an integer with value 1 and the scope of the function f where a new variable x is created in the functions local namespace because it is assigned to. The global y statement binds y to the value in the enclosing scope. z exists only the function's namespace.
In this example the global variable x is "shadowed" by the local variable x.
x=1
y=1
def f():
global y
x=2
y=2
z=2
print(x,y,z)
f()
print(x,y)
import __main__
'x' in dir(__main__), 'z' in dir(__main__)
Importing a module also creates a namespace. Variables and functions in the file that is imported are placed in a namespace that has the same name as the file. For example, when we import from the file math.py, the function cos and the variable pi are placed in the math namespace:
import math
math.myfunction = 1
print(dir(math),math.myfunction)
from math import *
import __main__
print(dir(__main__))
The global namespace is in a module called __main__. Built-in identifiers exist the __builtin__ namespace in the global namespace:
import __main__
print(dir(__main__))
print(dir(__main__.__builtin__))
Each instance of an object also has its own scope.
class newclass():
pass
c1=newclass()
c2=newclass()
c1.x=1
c2.x=2
x=3
print(c1.x,c2.x,x)
A name can exists in multiple scopes. The priority is:
x=3
class myclass():
x=2
def __init__(self,x):
self.x=x
def f1(self):
x=1
return x
def f2(self):
return self.x
def f3(self):
return x
c=myclass(4)
# scopes: global, function(local) and object
print(c.f1(), c.f2(), c.f3())
# global scope (in main namespace)
print(x)
# module scope
import math
math.x=4
print(math.x)
Dynamic binding allows functions to retain state.
In this example we create a function object that returns the smallest value it has been called with since it was created.
We could accomplish the same thing by defining a new type of object with appropriate methods, but a closure has less overhead.
def newmin():
m=None
def f(x):
# 'nonlocal' binds m to the enclosing scope
# instead of the global scope
nonlocal m
if m == None or x<m:
m=x
return m
return f
min1=newmin()
print(min1(15),min1(10),min1(20))
min2=newmin()
print(min2(10),min2(5),min2(15))
print(min1(100),min2(100))