__name__ ವೇರಿಯೇಬಲ್
ಪೈಥಾನ್ನಲ್ಲಿ, __name__ (ಎರಡು ಅಂಡರ್ಸ್ಕೋರ್ಗಳೊಂದಿಗೆ) ಒಂದು ವಿಶೇಷ, ಅಂತರ್ನಿರ್ಮಿತ ವೇರಿಯೇಬಲ್ ಆಗಿದೆ. ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಒಂದು .py ಫೈಲ್ ಅನ್ನು ಚಲಾಯಿಸುವಾಗ, ಅದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಈ ವೇರಿಯೇಬಲ್ಗೆ ಒಂದು ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ.
__name__ ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು ಫೈಲ್ ಅನ್ನು ಹೇಗೆ ಚಲಾಯಿಸಲಾಗುತ್ತಿದೆ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ:
-
ನೇರವಾಗಿ ಚಲಾಯಿಸಿದಾಗ (Run Directly): ನೀವು ಒಂದು ಪೈಥಾನ್ ಫೈಲ್ ಅನ್ನು ನೇರವಾಗಿ
python my_script.pyಎಂದು ಕಮಾಂಡ್ ಲೈನ್ನಿಂದ ಚಲಾಯಿಸಿದರೆ, ಆ ಫೈಲ್ನೊಳಗೆ__name__ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು__main__ಆಗಿರುತ್ತದೆ. -
ಮೊಡ್ಯೂಲ್ ಆಗಿ ಇಂಪೋರ್ಟ್ ಮಾಡಿದಾಗ (Imported as a Module): ನೀವು ಒಂದು ಫೈಲ್ ಅನ್ನು ಮತ್ತೊಂದು ಫೈಲ್ನಲ್ಲಿ
import my_scriptಎಂದು ಇಂಪೋರ್ಟ್ ಮಾಡಿದರೆ,my_script.pyಫೈಲ್ನೊಳಗೆ__name__ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು ಆ ಮೊಡ್ಯೂಲ್ನ ಹೆಸರಾಗಿರುತ್ತದೆ (ಅಂದರೆ,'my_script').
if __name__ == "__main__": ಬ್ಲಾಕ್
ಈ if ಸ್ಟೇಟ್ಮೆಂಟ್, "ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು, ಈ ಫೈಲ್ ಅನ್ನು ನೇರವಾಗಿ ಚಲಾಯಿಸಿದಾಗ ಮಾತ್ರ ರನ್ ಮಾಡು, ಬೇರೆ ಕಡೆ ಇಂಪೋರ್ಟ್ ಮಾಡಿದಾಗ ರನ್ ಮಾಡಬೇಡ" ಎಂದು ಪೈಥಾನ್ಗೆ ಹೇಳುತ್ತದೆ.
ಇದು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಒಂದು ಫೈಲ್ ಅನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ಬಳಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ: - ಮೊಡ್ಯೂಲ್ ಆಗಿ: ಇತರ ಫೈಲ್ಗಳು ಇದರಲ್ಲಿರುವ ಫಂಕ್ಷನ್ಗಳು ಮತ್ತು ಕ್ಲಾಸ್ಗಳನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿಕೊಳ್ಳಬಹುದು. - ಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿ: ಇದನ್ನೇ ನೇರವಾಗಿ ಚಲಾಯಿಸಿ, ಪರೀಕ್ಷಾ ಕೋಡ್ (test code) ಅಥವಾ ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸಬಹುದು.
ಉದಾಹರಣೆ
ನಾವು calculator.py ಎಂಬ ಮೊಡ್ಯೂಲ್ ಅನ್ನು ರಚಿಸೋಣ.
ಫೈಲ್: calculator.py
def add(a, b):
"""ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಕೂಡಿಸುತ್ತದೆ."""
return a + b
def subtract(a, b):
"""ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಕಳೆಯುತ್ತದೆ."""
return a - b
# ಈ ಫೈಲ್ ಅನ್ನು ನೇರವಾಗಿ ಚಲಾಯಿಸಿದಾಗ ಮಾತ್ರ ಈ ಬ್ಲಾಕ್ ರನ್ ಆಗುತ್ತದೆ.
if __name__ == "__main__":
print("ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಮೊಡ್ಯೂಲ್ ಅನ್ನು ನೇರವಾಗಿ ಚಲಾಯಿಸಲಾಗುತ್ತಿದೆ.")
# ಕೆಲವು ಪರೀಕ್ಷೆಗಳನ್ನು ಮಾಡೋಣ
result1 = add(10, 5)
print(f"10 + 5 = {result1}")
result2 = subtract(10, 5)
print(f"10 - 5 = {result2}")
print(f"`calculator.py` ಯಲ್ಲಿ __name__ ಮೌಲ್ಯ: {__name__}")
ಈಗ, calculator.py ಅನ್ನು ನೇರವಾಗಿ ಚಲಾಯಿಸಿದಾಗ:
ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಮೊಡ್ಯೂಲ್ ಅನ್ನು ನೇರವಾಗಿ ಚಲಾಯಿಸಲಾಗುತ್ತಿದೆ.
10 + 5 = 15
10 - 5 = 5
`calculator.py` ಯಲ್ಲಿ __name__ ಮೌಲ್ಯ: __main__
ಈಗ, ಮತ್ತೊಂದು ಫೈಲ್ main.py ನಿಂದ calculator ಮೊಡ್ಯೂಲ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡೋಣ.
ಫೈಲ್: main.py
import calculator
print("`main.py` ನಿಂದ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಮೊಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತಿದೆ.")
total = calculator.add(100, 200)
print(f"100 + 200 = {total}")
print(f"`main.py` ಯಲ್ಲಿ __name__ ಮೌಲ್ಯ: {__name__}")
main.py ಅನ್ನು ಚಲಾಯಿಸಿದಾಗ:
`main.py` ನಿಂದ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಮೊಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತಿದೆ.
100 + 200 = 300
`main.py` ಯಲ್ಲಿ __name__ ಮೌಲ್ಯ: __main__
calculator.py ನಲ್ಲಿರುವ if __name__ == "__main__": ಬ್ಲಾಕ್ನೊಳಗಿನ ಕೋಡ್ ಇಲ್ಲಿ ಚಲಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ, ಏಕೆಂದರೆ ಅದನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಲಾಗಿದೆ, ನೇರವಾಗಿ ಚಲಾಯಿಸಿಲ್ಲ.
ಈ ವೈಶಿಷ್ಟ್ಯವು ನಿಮ್ಮ ಮೊಡ್ಯೂಲ್ಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಲ್ಲ ಮತ್ತು ಸ್ವತಂತ್ರವಾಗಿ ಪರೀಕ್ಷಿಸಬಲ್ಲಂತೆ ಮಾಡಲು ಅತ್ಯಗತ್ಯ.