Python’s `__name__` attribute is a special built-in variable that plays a significant role in determining how a Python script behaves when it’s run. It is particularly useful for creating reusable modules and ensuring that certain code only runs when a script is executed as the main program, not when it’s imported as a module into another script. In this article, we’ll explore the `__name__` attribute in depth, with practical examples to illustrate its usage.
1. What is the `__name__` Attribute?
The `__name__` attribute is a special variable that is automatically set by Python when a script is executed. It indicates whether the script is being run as the main program or if it is being imported as a module into another script. This attribute allows you to conditionally execute specific code based on how the script is being used.
When a Python script is executed, the interpreter sets a special built-in variable __name__ for the script being run. If the script is the main program being executed, Python sets __name__ to “__main__“. However, if the script is being imported as a module, __name__ is set to the name of the module.
2. Usage Scenarios.
2.1 Running Code Conditionally.
A common use case for the `__name__` attribute is to conditionally execute code only when the script is the main program. This is achieved by checking if `__name__` is equal to `“__main__”`.
python_attribute_name.py. In this example, `some_function()` will only be called if `python_attribute_name.py` is executed directly as the main program.
# python_attribute_name.py
print("__name__ : ", __name__)
def some_function():
# Your function logic here
print("some_function() is invoked.")
if __name__ == "__main__":
# Code to execute when this script is run directly
some_function()
2.2 Creating Reusable Modules.
You can define reusable functions and classes in a Python script and then import them into other scripts as modules. When doing so, it’s important not to execute any code at the top level of the script. This can be achieved by using the `__name__` attribute.
reusable-modules.py.
# reusable-modules.py
print("__name__ : ", __name__)
def helper_function():
# Your helper function logic here
print('helper_function() is invoked.')
if __name__ == "__main__":
# Code to execute when this script is run directly
print("This script is being run as the main program.")
else:
print("This script is being imported as a module.")
When you run the above python file with the command python ./reusable-modules.py, it will show the below output.
__name__ : __main__ This script is being run as the main program.
Create another python file reusable-modules-main.py.
import importlib.util
test_spec = importlib.util.spec_from_file_location('python-reusable-module', 'D:\Work\python-courses\python-special-attributes-methods\\reusable-modules.py')
test_module = importlib.util.module_from_spec(test_spec)
test_spec.loader.exec_module(test_module)
test_module.helper_function()
When you run the above python file with the command python reusable-modules-main.py, you can get the below output.
__name__ : python_reusable_module This script is being imported as a module. helper_function() is invoked.
By using this structure, you can safely import `reusable-modules` into other scripts without triggering the code in the `if __name__ == “__main__”` block.
2.3 Testability.
When writing unit tests for your Python code, you may want to exclude certain parts of your script when running tests. The `__name__` attribute can help you achieve this by allowing you to conditionally run test-specific code.
my_module.py.
# my_module.py
def some_function():
# Your function logic here
print('some_function() is invoked.')
def say_hello(user_name):
print('Hello', user_name)
if __name__ == "__main__":
# Code to execute when this script is run directly
some_function()
say_hello('Tom')
When you run the above source code, you will get the below output.
some_function() is invoked. Hello Tom
If you just want to test the function say_hello(user_name), you can create another python file my_module_main.py with the below source code.
my_module_main.py
# my_module_main.py
import importlib.util
def test_say_hello():
# Your test logic here
test_spec = importlib.util.spec_from_file_location('my_module', 'D:\Work\python-courses\python-special-attributes-methods\my_module.py')
test_module = importlib.util.module_from_spec(test_spec)
test_spec.loader.exec_module(test_module)
test_module.say_hello('Jerry')
if __name__ == "__main__":
test_say_hello()
In your test script, you can import `my_module` and test its functions without executing the main program logic.
3. Practical Examples.
Let’s explore a few practical examples to see the `__name__` attribute in action.
3.1 Example 1: A Simple Calculator Module.
Suppose you want to create a simple calculator module with addition and subtraction functions.
my_calculator.py.
# my_calculator.py
def add(x, y):
return x + y
def subtract(x, y):
return x - y
if __name__ == "__main__":
# Code to execute when this script is run directly
print("This is a calculator module.")
You can import and use this module in another script: my_calculator_main.py.
# my_calculator_main.py
import importlib.util
calculator_spec = importlib.util.spec_from_file_location('my_calculator', 'D:\Work\python-courses\python-special-attributes-methods\my_calculator.py')
calculator_module = importlib.util.module_from_spec(calculator_spec)
calculator_spec.loader.exec_module(calculator_module)
result = calculator_module.add(5, 5)
print(f"Addition result: {result}")
result = calculator_module.subtract(10, 2)
print(f"Subtraction result: {result}")
When you run `my_calculator_main.py`, the code in `my_calculator.py`’s `if __name__ == “__main__”` block won’t execute.
3.2 Example 2: A Custom Logging Module.
Let’s create a simple logging module that logs messages to a file when used as the main program but can also be imported for custom logging.
my_logger.py.
# my_logger.py
import datetime
def log_message(message):
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
log_entry = f"{timestamp}: {message}"
with open("log.txt", "a") as log_file:
log_file.write(log_entry + "\n")
if __name__ == "__main__":
# Code to execute when this script is run directly
message = input("Enter a message to log: ")
log_message(message)
You can import and use this logging module in other scripts (my_logger_main.py) to log custom messages without running the input code when imported.
my_logger_main.py
# my_logger_main.py
import importlib.util
logger_spec = importlib.util.spec_from_file_location('my_logger',
'D:\Work\python-courses\python-special-attributes-methods\my_logger.py')
logger_module = importlib.util.module_from_spec(logger_spec)
logger_spec.loader.exec_module(logger_module)
logger_module.log_message("This is a custom log entry.")
When you run the above example code, it will log the custom log text in the log.txt file.
4. Conclusion.
The `__name__` attribute in Python is a powerful tool for controlling the behavior of your scripts when they are run as standalone programs or imported as modules into other scripts.
By utilizing this attribute, you can create reusable modules, conditionally execute code, and improve the testability of your Python code. Understanding and using `__name__` effectively can make your Python scripts more flexible and maintainable.
