globals() returns a dictionary of present global symbol table in Python

globals() returns a dictionary of symbol table in global name space

globals() is same as using locals() in global name space

print(globals())

This will return a dictionary, some sample elements are shown here.

{'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None ........
.........}

We can print any element by using key

my_var='plus2net'
print(globals()['my_var']) # plus2net

Default global variables

a=globals()
print(a['__name__'])
print(a['_dh'])

Using User defined function

x=5
def my_sum():
   a=8
   x=10 # local variable
print(globals()['x'])   # 5 
# print(globals()['a']) # KeyError

The last line will return KeyError as the variable a is not available in global name space.

In python what is a name space GPT

Understanding Python NameSpace

In Python, a namespace is a fundamental idea to understand how variables and names are managed in the program. It can be defined as a container where names are mapped to objects. These names are unique identifiers in Python to ensure that there's no naming conflict or ambiguity when your program is executed. Essentially, namespaces in Python are used to keep the names separate from each other. This means that the same name can be used for different objects in different namespaces.

Types of Namespaces in Python

There are several types of namespaces in Python, created at different moments and having different lifespans:

Local Namespace: This includes local names inside a function. This namespace is temporarily created for a function call and gets cleared when the function returns.
Global Namespace: This includes names from various imported packages/modules that are being used in the current project. This namespace is created when the module is included in the script and lasts until the script is executed.
Built-in Namespace: This includes Python’s built-in functions and exceptions. It is created when the Python interpreter starts up and is never deleted.

Namespace Lookup Order

When you use a name in Python, the Python interpreter searches for it in a specific order:

Local Namespace: First, the interpreter looks for the name inside the local namespace (e.g., within a function).
Global Namespace: If the name is not found locally, the interpreter searches the global namespace (the scope of the current module or file).
Built-in Namespace: If the interpreter cannot find the name in either the local or global namespace, it finally checks the built-in namespace.

Importance of Namespaces

Namespaces are crucial in Python for several reasons: Avoiding Conflicts: They help in avoiding naming conflicts between identifiers. Scope Management: They facilitate the scoping of identifiers, making it clear which part of the program a variable belongs to. Code Organization: They contribute to better organization and structuring of code, making it more readable and maintainable. In summary, namespaces in Python are like containers for mapping names to objects, crucial for organizing and structuring code effectively, avoiding naming conflicts, and managing variable scopes throughout a Python program.

All Built in Functions in Python locals() dir() ord()

Math Functions math.fabs() Python- Tutorials

Subscribe to our YouTube Channel here