{"id":74322,"date":"2019-12-18T15:07:40","date_gmt":"2019-12-18T09:37:40","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=74322"},"modified":"2024-08-22T17:58:41","modified_gmt":"2024-08-22T12:28:41","slug":"python-namespace-and-scope","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/python-namespace-and-scope\/","title":{"rendered":"Python Namespace and scope – Get unique names for each object"},"content":{"rendered":"

In your school, college or office, confusion can arise because of people having the same names. This confusion is usually resolved by providing a unique identity<\/strong> like using first name and last name. The same problem can arise in programming also.<\/p>\n

If you write a few lines of code then it is not a problem to assign unique names to every variable. But when you load external modules<\/strong> and write thousands of lines of code then it is not possible to use unique and meaningful names for every object or variable.<\/p>\n

This is why namespaces are important and this article will be covering everything about Python namespace and scope.<\/p>\n

What is Python Namespace?<\/h3>\n

A namespace is a collection of names<\/strong>. Python implements namespaces as dictionaries<\/strong>. Imagine it as a name-to-object mapping where names are the keys and objects are the values.<\/p>\n

A namespace allows us to have unique<\/strong> names for each object. If you don\u2019t know, this is just a quick reminder to tell you that strings<\/strong>, lists<\/strong>, functions<\/strong>, etc. everything in Python is an object.<\/p>\n

In simple words, we can say that the role of a namespace is like a surname<\/strong>.<\/p>\n

There can be multiple \u201cTom\u201d<\/strong> in the same class but there will be a single \u201cTom Hanks\u201d<\/strong> (let\u2019s just assume this) in the class and with surname, you can identify between multiple \u201cTom\u201d<\/strong>.<\/p>\n

The Python interpreter does the same thing to understand what exact method or variable one is pointing to in the code<\/strong>. The namespace word itself can be broken down as name (which is a unique identifier) + space (which means relating to scope)<\/strong>.<\/p>\n

The name can be anything from method name<\/strong> to variable name<\/strong> and space<\/strong> depends upon the location from where we are trying to access<\/strong> a variable<\/strong> or a method<\/strong>.<\/p>\n

Types of Namespaces in Python\"Python<\/a><\/h3>\n

Namespaces are of basically three types:<\/p>\n

1. Built-in Namespace<\/h4>\n

This namespace includes functions<\/strong> and exception names<\/strong> that are built-in in the Python. Examples include built-in functions like print(), len(), and built-in exceptions like ValueError and TypeError. The built-in namespace is always available and can be accessed from anywhere in the code, providing a foundation of readily available utilities.<\/p>\n

2. Global Namespace<\/h4>\n

This namespace includes names<\/strong> from the modules that are imported<\/strong> in the project. It is created when we include the module<\/strong> and it lasts until the script ends<\/strong>. Variables and functions defined at the top level of a script or module are part of the global namespace. This allows them to be accessed from any part of the code after their declaration, as long as the script or module is still running.<\/p>\n

3. Local Namespace<\/h4>\n

The local names inside a function come under a local namespace. This namespace is created when the function is called and its scope ends when the function returns a value or exits. Variables defined within a function are local to that function and cannot be accessed from outside. This encapsulation helps prevent conflicts between variables in different parts of the program and allows for better modularity and readability.<\/p>\n

Python Scope<\/h3>\n

With namespaces, we can uniquely identify<\/strong> all the names inside a program. However, it doesn\u2019t mean that we can use the variable names anywhere we want. It also has some scope<\/strong> that indicates the part of the program where we can access them.<\/p>\n

We can directly access the variables without any prefix<\/strong> when they are in the namespace. The lifetime of a namespace is dependent on the scope of objects. When the scope of an object comes to end, the lifetime of the namespace also comes to an end<\/strong>.<\/p>\n

So, we cannot access the inner namespace scope\u2019s objects from an outer namespace<\/strong>.<\/p>\n

Python has the following scopes –<\/strong>\"python<\/a><\/p>\n

When a name is referenced<\/strong> in Python, the interpreter searches the name in the namespace<\/strong> starting from the smallest scope<\/strong> in the diagram and gradually moves towards the outermost scope.<\/p>\n