We can't write logical Python code until we know what namespaces in python are and what a variable's scope is. This topic is important because it sets the stage for changeable behaviour, which could cause problems if not understood.
Before we get into namespaces in python, here's a quick review of Python variables.
When working with statically typed languages like C, C++, and Java, the datatype of a variable must be given. It's like making a box that can only hold a certain set of numbers.

But Python is a language that types things on the fly. This way of giving a variable a name is similar to how an interpreter gives a variable a name. There are no limits on the types of data that can be used with this label.
In Python, we need special words like "global" and "nonlocal" to tell the difference between local and nonlocal variables. In languages with static typing, this is not necessary.

What a Namespace is and how it works in Python is defined.

Explain what a Namespace is and what it does in Python.

From the definition of names to the idea of namespaces in python, we have come a long way.
A namespace is, at its most basic level, just a list of names.
In Python, a namespace is like a dictionary where each name is connected to an object.
namespaces in python can live in the same place at the same time without getting in each other's way. When we start the Python interpreter, a namespace is created that has all the built-in names and lasts as long as the interpreter does.
This is why we can access the program's core features and built-in functions like id(), print(), etc. from anywhere in the programme. When a module is loaded, it will set up its own global namespace.

There are separate areas for each namespace. This keeps modules with the same name from fighting with each other.
Modules give functions and types a lot of freedom. When a function is called, a new local namespace is made with all the names for that function. The same is true for social status. The diagram below can help explain this idea.

The Range of a Variable in Python

There's a chance that not all parts of the programme will be able to use the different namespaces in python that have been set up. Here comes the idea of scope into play.
1.The scope of a namespace is the part of the code where it can be used by itself.

2.At any given time, there are at least three levels of nesting going on.

In the current function, which makes use of local names,

3.Module's remit, which has terms that cover everything,

4.The farthest reaches, whose names were already set,

When a reference is made within a function, the local namespace, the global namespace, and the built-in namespace are all checked before the built-in namespace is checked.
Whenever a function is inside another function, the local scope gets a child scope.

All that matters are the Python scopes.

The object's usefulness determines how long it will last. In Python, the range of variables ends when the lifetime of the object ends. In Python, a scope is simply the part of the code where a namespace can be directly referred to.

First, we'll talk about a variable's scope, which is how long it is used in a programme. If a variable is "out of its scope," it can't be interpreted the way we want.
After we've looked at the scope of variables, we'll divide the three main namespaces in python into Global, Local, and Built-in.
Then, to wrap up, we'll talk about the "global" and "nonlocal" keywords, as well as a few related ideas, like using global variables in user-defined modules and using built-ins as variables.

How namespaces in python Are Used 

The word "namespace" refers to a set of information that includes both the current list of declared symbolic names and information about the objects to which those names refer. namespaces in python can be thought of as dictionaries, with the names of objects as the "keys" and the actual objects as the "values." In a key-value pair, the names of objects are linked to those objects.

namespaces in python can be broken down into three main groups:
Tim Peters says that there are some bad things about namespaces in python. They're great, and Python relies on them a lot. There are four different kinds of namespaces in python in Python:

Built-in global enclosure built-in local
How long these last varies. Python creates and gets rid of namespaces in python as needed while a programme is running. Most of the time, a large number of namespaces in python are in use.

First, the framework comes with a set of rules for naming things.
This is the namespace where all of Python's built-in functions and exceptions can be found.

Naming in Context: Worldwide 2
This namespace holds the names of any modules that were used to build the project. It is made when the module is loaded, and it stays there until the script ends.

Third, there is the Local Namespace.
The names used inside the scope of a function have their own namespace. When the function is called, a new namespace is created, and when the function returns a value, the namespace's scope ends.