Understand namespace and scope for classes in Python (2023)

"Namespaces are a great idea - let's do more of them!"
--The Zen of Python

Objects are building blocks of Python and a namespace is a map to access those blocks. Python has several code block types, each with its own scope or namespace. This article describes scopes and namespaces for classes. Key concepts related to object-oriented programming (OOP) and namespaces in Python are introduced first. Then, using these concepts, namespaces and scopes are described in terms of classes and objects in Python.

Python is a high-level programming language that supports multiple programming paradigms, including functional programming and object-oriented programming. Everything in Python is an object of a specific class, which makes it possible to support higher-order functions. The latter gives Python functional programming capabilities, but behind the scenes, even functions are first class objects in Python. For example, Python creates a function object func using the def statement and we can assign attributes to it.

def func():
happen
print(type(function))
func.at = 20
print(func.at)

Exit

<class 'Function'>
20

Objects are instances of classes, for example an Integer object is an instance of the Numbers class. Classes are "blueprints" for creating objects and provide a way to package data and functionality. Creating a new class creates a new object type, which allows new instances of that type to be created. Attributes can be attached to each class instance to maintain its state. Class instances can also have methods (defined by their class) for changing an object's state. The following code defines a class for a family of circles. This class has three attributes, namely r, Perimeter and Area. With the circle class, we can create a circle of radius r and evaluate its perimeter and area. To understand the use of the word self, the local variable r within the Perimeter method, and the Perimeter method within the Area method, we need to understand how the concept of namespace and scope works in Python.

Before defining a namespace, let's first see what a name is in Python. As we've already seen, everything in Python is an object. A name or identifier is simply a name given to the object. Name is a way to access the underlying object. For example, object 10 is referenced with the name "t". Both t and 10 have the same memory address.

t = 10
press
print(id(t))
print (id(10))
t = t+1
print(id(t))
print(id(11))

Exit

10
140707570557616
140707570557616
140707570557648
140707570557648

One important thing to note here is that assignments don't copy the data - they just bind the names to objects. So in the example above, t was first bound to 10 and is now bound to 11 because they both have the same memory address.

Now, a namespace is a mapping of names to objects implemented as Python dictionaries. The three main examples of namespaces are built-in, global, and local namespaces. The global and local names for a module can be accessed through the built-in functions globals() (returns a dictionary) and locals(), respectively.

war = 7
globals()['var']7

When the Python interpreter is started, a built-in namespace for functions like abs(), id(), etc. is created. The global namespace is created when a module containing variables, functions, classes, etc. is run by the interpreter. A local namespace is created for the local names within a function or class. Namespaces are completely independent of each other, two different modules can define the same variable name "var" without confusion. References to names in modules are attribute references. Example: modname.funname — modanme is a module object and funcname is an attribute of it. Consider the case for the func() function below, func is mapped to module __main__ which is the currently used script.

def func():
happen
Funk

Exit

<Function __main__.func()>

Different namespaces have different lifetimes - the built-in namespaces are created when the Python interpreter starts and are never deleted. The global namespaces are created when the interpreter reads module definitions and persist until the interpreter shuts down. As mentioned, the top-level statements in a module have a global namespace (func in the example above) and are considered part of the __main__ module. Likewise, the built-in names live in a built-in module. The local namespaces are created when functions are called and destroyed when the function returns or throws an error.

A scope is the body of a program from which a namespace can be accessed directly without a prefix. The innermost range containing local names is searched first. It then searches for the region of the enclosing function that is closest to the innermost region. This scope contains a non-local namespace, but also a non-global namespace. Next to the last scope, the namespace in the current module (__main__) is searched - this is the scope of the global namespace. Finally, the outermost scope is searched with built-in names. The following example explains various areas in Python.

def python_scope(): #You must have a non-local scope
def local_scope(): #has local scope
var = "local Variable"def nonlocal_scope():
nonlocal var
var = "non-local variable"def global_scope():
there is a global one
var = "global Variable"var = "Testvariable"
local_scope()
print("After local allocation:", var)
nonlocal_scope()
print("After non-local assignment:", var)
global_scope()
print("After global assignment:", var)python_scope()
print("In global scope:", var) #has global scope

Exit

After local assignment: test variable
After non-local assignment: non-local variable
After global assignment: non-local variable
In global scope: global variable

In the example above, when the python_scope function is called, the definitions of the local_scope, nonlocal_scope, and global_scope functions are read. Then var is assigned the value "test variable". Next, running local_scope creates a local namespace for the function. The "local variable" value is only bound to this namespace. Because of this, the value of var remains "test variable" after the local_scope function is executed. If the variable is declared nonlocal inside the nonlocal_scope function, the name "var" is bound to the namespace of the python_scope function, and therefore the value of "var" is "nonlocal variable" after the nonlocal_scope function is executed. Finally, when var is declared global, it is bound to the global (module) namespace, but we're still within the scope of the python_scope function's namespace. Because of this, the value of the variable "var" is still "non-local variable". Once we move the scope of the python_scope function to the global scope, the value of "var" becomes "global variable".

In summary, when a name is declared global, all references and assignments to it go into the scope containing the names of the __main__ module. When a name is declared nonlocal, all references and assignments to it go into the namespace immediately outside the namespace in which a variable is declared. When no global or non-local statement is in effect, all references and assignments to a name go to the innermost scope.

When a class is defined, a local namespace is created, similar to when a function is defined. As already mentioned, a function (called a method) can be defined inside the class. The function has its own namespace within the class. The instance objects of the class have their own namespace, independent of the class's namespace. A class can inherit parent classes and its namespace is associated with parent classes. Let's understand the namespace for classes using the example class for a family of circles.

In the example below, if we use the dir() function to check the names in the scope (__main__) of the module, we can see that the name Circle is bound in that scope. We can verify this by printing Circle(), which returns the Circle object as an attribute of the __main__ module and a location.

class group:
rad = "A circle of radius r"
print(dir())
print(circle())

Exit

['Kreis', 'In', 'Out', '_', '_2', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', ' __Paket__', '__spec__', '_dh', '_i', '_i1', '_i2', '_i3', '_i4', '_i5', '_i6', '_i7', '_i8', '_i9' , '_ih', '_ii', '_iii', '_oh', 'exit', 'get_ipython', 'quit']
<__main__.circle object at 0x000001FFD57EE548>

Let's check the names in the scope of the Circle class using the __dict__ function.

print(circle.__dict__)
print(circle.rad){'__module__': '__main__', 'rad': 'A circle of radius r', '__dict__': <attribute '__dict__' of 'Circle' objects>, '__weakref__': <attribute '__weakref__' of 'Circle 'objects>, '__doc__':none}
A circle of radius r

We can see here that the variable "rad" is in scope of the Circle class and is bound to the Circle object. Also, each instance of the class has different namespaces. The following code creates two instances of the Circle class, C1 and C2, and assigns them to an attribute section. When the dictionary is printed containing names in the range of C1 and C2, we can see that both have different ranges.

C1 = circle()
C2 = circle()
C1.scope = 'this is in the scope of C1'
C2.scope = 'this is in the scope of C2'
print(C1.__dict__)
print(C2.__dict__)

Exit

{'Scope': 'this is within the scope of C1'}
{'Scope': 'this is within the scope of C2'}

Finally, let's understand the scope and namespace for methods within the class. Each method within the class has its own namespace. In the code below, Perimeter() is a function within the class. When executed, this function throws a naming error. This is because Perimeter() is assigned to Circle's scope while we are trying to access it in global scope (of the module).

class group:
rad = "A circle of radius r"
def scope(s):
print(f'value of perimeter is {2*3.14*r}')Scope(5)

Exit

naming error: Name 'Perimeter' is not defined

When we associate class_func with Circle class namespace, there is no error as shown below.

Circle.Perimeter(1)Value of the circumference is 6.28

Okay, but the purpose of a function within a class is to update or return the properties of class objects. Let's call this function on an object (instance) of the Circle class.

Circle().Perimeter(1)TypeError: Perimeter() takes 1 positional argument, but 2 were specified

The above code throws a type error because when we assign a function to an object, the object is automatically passed as a parameter to the function. Therefore, in the definition of the function, we need to pass an object (instance) of the class. That's whereselfis used. "Self" is just a name given to an object of the class, and that name is tied to the object's namespace.

class group:
rad = "A circle of radius r"
def perimeter(self, r):
print(f'value of perimeter is {2*3.14*r}')Circle().Perimeter(1)

Exit

Value of the circumference is 6.28

Generally, when we create objects using classes, they are created with some initial states. Here the built-in method __init__ can be used to define an initial state. For example, we can define a circle with a given radius "r". Also, you don't have to explicitly call the __init__ method. It is called automatically when an instance of the class is created. See the example below.

class group:
"""A class for the family of circles"""
def __init__(self, radius):
self.r = Radius
Kreis(1)

Exit

<__main__.Circle at 0x1ffd5899488>

Also note that self.r is used here to concatenate the name "r" to the object's namespace. So that it can be accessed in the scope of the object's namespace with (Circle().r). And using the same terminology, a method in a class can access another method in the class, as shown in the example below.

class group:
"""A class for the family of circles"""
def __init__(self, radius):
self.r = Radius
def scope (self):
return 2*self.r*3.14
def area (self):
return self.Perimeter()*self.r/2C = circle(1)
print(C.Perimeter())
print(C.Area())

Exit

6.28
3.14

In the example above, the Perimeter() method is used in the Area() method. Again, "self" is used with the Perimeter() method to associate it with the namespace of the "self" object.

In summary, the following figure illustrates the concept of namespace and scope for the Circle class. First, definitions of the Circle class that are in the global namespace are read and a namespace for the Circle class is created. Namespaces for the object (C) and methods (Perimeter, Area) are also created. When we execute the Area method using C.Area(), we first look for the names in the area of ​​the method (Area), then in the area of ​​the C object, and finally in the area of ​​the Circle class. For example, the word perimeter is searched first in the scope of the area method, then in the scope of the object (C/self). The name Perimeter is tied into the object's namespace with self.Perimeter and can therefore be used within the Area method. If we use "Perimeter" without the word "self", it is not scoped to the object and is not accessible to the Area method.