# Understanding the __name__ Variable in Python Scripts
URL: https://madhudadi.in/blog/posts/understanding-the-name-variable-in-python-scripts
Published: 2026-05-19
Tags: python, interview
Read time: 30 min
Difficulty: intermediate
> Discover how Python's __name__ variable helps differentiate script execution from imports, enhancing code modularity and reusability.### Understanding the significance of the __name__ variable in Python scripts

**Explanation**

- The `__name__` variable is a built-in variable in Python that indicates the name of the module.  
- When a Python script is run directly, `__name__` is set to `'__main__'`, allowing for specific code execution.  
- This feature is commonly used to differentiate between running a script as the main program versus importing it as a module in another script.  
- It enables the inclusion of test code or script execution logic that should only run when the script is executed directly.  
- This practice promotes modularity and reusability of code by preventing certain code from running during imports.

```python
# 1. What do you mean by __name__ == '__main__'
```

### What is a module?

Any file with an extention of .py is called a module in python.

Whenever we execute a program it's module name is __main__ and this name is stored in __name__ variable

### Understanding the behavior of the __name__ attribute in Python modules

**Explanation**

- The `display` function is defined to print the string 'hello' when called.
- The function `display()` is invoked, resulting in 'hello' being printed to the console.
- The `print(__name__)` statement outputs the name of the current module; if run as the main program, it will display `__main__`.
- The `print(display.__name__)` statement shows the name of the function `display`, which is 'display', regardless of the module context.
- This code snippet illustrates how the `__name__` attribute helps differentiate between the main module and imported modules in Python.

```python
def display():
  print('hello')

display()

print(__name__) # It is basically for the same module
print(display.__name__) # It prints the module name is imported from another module like module.__name__ output is module instead of __main__. __main__ is for the current module which is yours than other modules developed by someone.
```

**Output**

```text
hello
__main__
display
```

### Importing a module

- But what is the need to import a module?
- How to import a module

### This code demonstrates module importation and the use of the special variable __name__ in Python.

**Explanation**

- The code imports a module named `test` and calls the `hello` function from that module, passing the string 'madhu' as an argument.  
- The `print(__name__)` statement outputs the name of the current module, which will be `'__main__'` if the script is run directly.  
- The `print(test.__name__)` statement outputs the name of the imported module, which will be `'test'`.  
- This snippet illustrates how Python distinguishes between the main program and imported modules using the `__name__` variable.

```python
import test
test.hello('madhu')

print(__name__)
print(test.__name__)
```

**Output**

```text
hello madhu
__main__
test
```

### Importing custom and built-in modules to execute functions in Python

**Explanation**

- The code imports the built-in `math` module for mathematical operations and a user-defined module named `test`.
- It calls the `hello` function from the `test` module, passing the string 'madhu' as an argument.
- The `print` function outputs the result of `math.floor(4.3)`, which rounds down the float to the nearest integer, resulting in 4.

```python
# import multiple module -> user defined + builtin
import math
import test

test.hello('madhu')
print(math.floor(4.3))
```

**Output**

```text
hello madhu
4
```

### Variations of import statement

### Importing essential libraries for mathematical operations and random number generation in Python

**Explanation**

- The `math` library provides access to mathematical functions and constants, such as trigonometric functions and logarithms.  
- The `random` library allows for generating random numbers and performing random selections, useful in simulations and games.  
- Both libraries are standard in Python, meaning they come pre-installed and do not require additional installation.  
- Importing these libraries enables the use of their functionalities throughout the script, enhancing its capabilities.

```python
# Normal
import math
import random
```

### Importing multiple modules for mathematical operations, random number generation, and testing functionalities

**Explanation**

- The code imports three different modules: `math`, `random`, and `test`.  
- The `math` module provides access to mathematical functions like trigonometry, logarithms, and constants.  
- The `random` module is used for generating random numbers and performing random selections.  
- The `test` module is likely a custom or third-party module intended for testing purposes, though its specific functionality is not defined in the snippet.  
- This approach of importing multiple modules in a single line can help streamline code but may reduce readability if overused.

```python
# clubbing together
import math, random, test
```

### This code demonstrates the use of specific mathematical functions from a module and a custom import.

**Explanation**

- The `factorial` function from the `math` module calculates the factorial of a given number, in this case, `5`, which results in `120`.  
- The `floor` function from the `math` module rounds down a floating-point number to the nearest integer, here it processes `4.8` but does not print the result.  
- The `hello` function is imported from a custom module named `test`, but it is not used in this snippet.  
- The code showcases selective importing, which can help reduce memory usage and improve performance by only bringing in necessary functions.

```python
# importing specific names from module
from math import factorial, floor
from test import hello

print(factorial(5))
floor(4.8)
```

**Output**

```text
120


4
```

### This code snippet demonstrates how to import and rename Python modules for mathematical operations and data manipulation.

**Explanation**

- The code imports the `math`, `numpy`, `pandas`, and `matplotlib.pyplot` libraries, renaming `math` to `m` for convenience.  
- The `math.factorial(5)` function call computes the factorial of the number 5, which equals 120.  
- Using aliases for modules helps to shorten the code and improve readability, especially when frequently calling functions from these libraries.  
- `numpy` is typically used for numerical operations, `pandas` for data manipulation, and `matplotlib.pyplot` for plotting, making this import setup versatile for data analysis tasks.

```python
# renaming modules
import math as m
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


m.factorial(5)
```

**Output**

```text
120
```

### This code calculates the factorial of the number 5 using a mathematical function.

**Explanation**

- The code imports the `factorial` function from the `math` module and renames it to `f` for convenience.  
- The `f(5)` function call computes the factorial of 5, which is the product of all positive integers up to 5 (i.e., 5 x 4 x 3 x 2 x 1).  
- The result of `f(5)` is 120, as it returns the factorial value.  
- This snippet demonstrates how to use built-in mathematical functions in Python for efficient calculations.

```python
from math import factorial as f

f(5)
```

**Output**

```text
120
```

### Order of execution of a module

### This code snippet retrieves and prints the Python module search paths from the system environment.

**Explanation**

- The `sys` module is imported to access system-specific parameters and functions.  
- The `sys.path` list contains the directories that Python searches for modules when importing.  
- A `for` loop iterates through each path in `sys.path`.  
- The `print(p)` statement outputs each directory path to the console.  
- This can be useful for debugging import issues or understanding the module search order.

```python
import sys
for p in sys.path:
  print(p)
```

**Output**

```text
C:\Program Files\JetBrains\PyCharm 2025.2.2\plugins\python-ce\helpers\jupyter_debug
C:\Program Files\JetBrains\PyCharm 2025.2.2\plugins\python-ce\helpers\pydev
C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.13_3.13.3312.0_x64__qbz5n2kfra8p0\python313.zip
C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.13_3.13.3312.0_x64__qbz5n2kfra8p0\DLLs
C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.13_3.13.3312.0_x64__qbz5n2kfra8p0\Lib
C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.13_3.13.3312.0_x64__qbz5n2kfra8p0

C:\Users\madhu\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages
C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.13_3.13.3312.0_x64__qbz5n2kfra8p0\Lib\site-packages
```

### What are packages in Python

A package in python is a directory containing similar sub packages and modules.

- A particular directory is treated as package if it has `__init__.py` file in it.
- The `__init__.py` file may be empty or contain some initialization code related to the package

### What are 3rd party packages?

- The python community creates packages and make it available for other programmers
- PyPI -> Python Package Index
- You can upload your own package
- You can also install packages from PyPI and install using pip
- pip is a package manager utility
- it is automatically installed with python