The __name__ == '__main__' Idiom Explained Notes in Hindi & English : पायथन इडियम: if __name__ == '__main__' की विस्तृत व्याख्या और 20 महत्वपूर्ण MCQ प्रश्न (Rajasthan IT Exam)

Post a Comment

PGDCA, BCA, B-Tech, MCA, M-Tech, B.Sc computer science राजस्थान सूचना सहायक व कंप्यूटर शिक्षक विशेष नोट्स: इस अध्याय में हम The __name__ == '__main__' Idiom Explained (पायथन इडियम: if __name__ == '__main__' की विस्तृत व्याख्या) की संपूर्ण थ्योरी, मुख्य तकनीकी बिंदु, तुलनात्मक तालिका और विगत परीक्षाओं के पैटर्न पर आधारित 20 अति-महत्वपूर्ण बहुविकल्पीय प्रश्न (MCQs) विस्तृत हिंदी व अंग्रेजी व्याख्या सहित पढ़ेंगे।

Overview: The `if __name__ == '__main__':` idiom lets a single Python file serve safely as both a standalone executable script and an importable library module. At load time, the interpreter sets `__name__` to `'__main__'` for the entry script, whereas imported modules receive their dotted module name.

अध्याय सार: `if __name__ == '__main__':` इडियम एक ही पायथन फाइल को स्वतंत्र स्क्रिप्ट और पुन: उपयोग योग्य मॉड्यूल दोनों रूपों में सुरक्षित रूप से चलाने की सुविधा देता है। इंटरप्रेटर सीधे चलाई गई फाइल के लिए `__name__` का मान `'__main__'` सेट करता है, जबकि इम्पोर्ट किए गए मॉड्यूल को उसका मॉड्यूल नाम मिलता है।

The __name__ == '__main__' Idiom Explained: Detailed Notes & Architecture (पायथन इडियम: if __name__ == '__main__' की विस्तृत व्याख्या)

1. How the Interpreter Assigns the __name__ Dunder Attribute (इंटरप्रेटर द्वारा __name__ एट्रिब्यूट का निर्धारण)

[EN] Before executing any statements in a module, Python automatically binds a string variable called `__name__` in that module's global dictionary. When a file is invoked directly from the command line (`python app.py`), passed to `python -m pkg.app`, or evaluated in the interactive REPL, its `__name__` is set to `'__main__'`. Conversely, when that exact same file is loaded via `import app` or `import pkg.app`, Python sets `__name__` to `'app'` or `'pkg.app'` respectively. Note that `__name__` is simply a regular string attribute (not a reserved keyword) stored on the module object.

[HI] किसी मॉड्यूल का कोड चलाने से पहले पायथन स्वचालित रूप से उसके ग्लोबल नेमस्पेस में `__name__` नामक स्ट्रिंग वेरिएबल सेट करता है। जब फाइल को सीधे `python app.py` या `python -m pkg.app` से चलाया जाता है (या REPL में), तो `__name__` का मान `'__main__'` होता है। इसके विपरीत, जब वही फाइल `import app` या `import pkg.app` द्वारा लोड की जाती है, तो `__name__` का मान `'app'` या `'pkg.app'` होता है। ध्यान दें कि `__name__` कोई रिजर्व्ड कीवर्ड नहीं बल्कि मॉड्यूल का एक विशेष स्ट्रिंग एट्रिब्यूट है।

2. Preventing Unwanted Side Effects During Imports (इम्पोर्ट के समय अनचाहे साइड-इफेक्ट्स को रोकना)

[EN] Unlike C or Java where execution strictly begins at a `main()` function, Python runs every top-level statement in a file as soon as it is executed or imported. Without the `if __name__ == '__main__':` guard, test calls, input prompts, server loops, or print statements placed at top level would automatically run whenever another file imports a helper function from it. Wrapping execution entry points inside `if __name__ == '__main__':` ensures definitions (`def`, `class`, constants) always load cleanly while script-only actions wait for direct invocation. This pattern is standard for writing unit-testable scripts and CLI tools.

[HI] C या Java की तरह `main()` फंक्शन अनिवार्य न होने के कारण पायथन फाइल लोड होते ही सारे टॉप-लेवल स्टेटमेंट चला देता है। यदि `if __name__ == '__main__':` गार्ड न लगाया जाए, तो किसी दूसरे प्रोग्राम में फाइल इम्पोर्ट करने पर भी प्रिंट, इनपुट या सर्वर लूप स्वतः चलने लगेंगे। एंट्री कोड को इस ब्लॉक में रखने से फंक्शन व क्लास परिभाषाएं तो लोड हो जाती हैं, पर मुख्य निष्पादन केवल फाइल को सीधे चलाने पर ही होता है। यूनिट-टेस्ट करने योग्य कोड और CLI टूल्स लिखने का यह मानक तरीका है।

3. Packages with __main__.py and the -m Execution Flag (__main__.py और -m फ्लैग द्वारा पैकेज निष्पादन)

[EN] To make an entire package directory runnable via `python -m mypackage`, Python looks for a special file named `__main__.py` inside `mypackage/`. Python executes `__main__.py` with `__name__ == '__main__'` while setting `__package__` to `'mypackage'`, allowing clean relative imports inside the package entry point. Similarly, running `python -m mypackage.tool` runs `tool.py` as `'__main__'` while preserving package context (unlike `python mypackage/tool.py`, where `__package__` is empty and relative imports fail). This mechanism powers built-in commands like `python -m http.server`, `python -m pip`, and `python -m unittest`.

[HI] किसी पूरे पैकेज को `python -m mypackage` के जरिए चलाने के लिए पैकेज फोल्डर के भीतर `__main__.py` फाइल बनाई जाती है। पायथन इसे `__name__ == '__main__'` और `__package__ = 'mypackage'` के साथ चलाता है, जिससे रिलेटिव इम्पोर्ट सुचारू रूप से काम करते हैं। `python mypackage/tool.py` के विपरीत, `python -m mypackage.tool` चलाने पर पैकेज संदर्भ सुरक्षित रहता है। `python -m pip` और `python -m http.server` जैसे प्रसिद्ध कमांड इसी मैकेनिज्म पर आधारित हैं।

4. Multiprocessing Guard and Self-Import Gotcha (मल्टीप्रोसेसिंग सुरक्षा और सेल्फ-इम्पोर्ट सावधानी)

[EN] On Windows and macOS, Python's `multiprocessing` module uses the `spawn` start method, which launches fresh interpreter processes that re-import the main script file. If process creation is not guarded inside `if __name__ == '__main__':`, every spawned child immediately spawns another child, causing an infinite loop or a `RuntimeError`. Another subtle edge case occurs if a running script `foo.py` executes `import foo`: because the initial script was registered in `sys.modules` under `'__main__'` rather than `'foo'`, Python loads a second duplicate module instance named `'foo'`. Checking `if __name__ == '__main__':` also remains optional—scripts without it still run sequentially from line 1.

[HI] Windows और macOS पर `multiprocessing` का `spawn` तरीका नए प्रोसेस बनाते समय मुख्य स्क्रिप्ट फाइल को दोबारा इम्पोर्ट करता है। यदि प्रोसेस बनाने वाला कोड `if __name__ == '__main__':` के अंदर न हो, तो हर नया चाइल्ड प्रोसेस अनंत लूप में नए प्रोसेस बनाता रहेगा और `RuntimeError` आएगा। एक अन्य विशेष स्थिति तब होती है जब चलती हुई फाइल `foo.py` स्वयं `import foo` कर ले: चूंकि पहली बार वह `'__main__'` नाम से लोड हुई थी, इसलिए `'foo'` नाम से उसका दूसरा मॉड्यूल इंस्टेंस बन जाता है। यद्यपि यह इडियम वैकल्पिक है, परंतु सुरक्षित प्रोग्रामिंग के लिए अत्यंत आवश्यक है।

Syntax, Formula & Technical Example (The __name__ == '__main__' Idiom Explained)

def square(n):
    return n * n

print("Module loaded with __name__ =", __name__)

if __name__ == "__main__":
    print("Running directly as main script")
    print("square(7) =", square(7))

The __name__ == '__main__' Idiom Explained Quick Reference & Comparison Table

Execution ContextValue of __name__Key Exam Fact
python script.py (Direct)'__main__'Code inside if __name__ == '__main__': executes
import script (Imported)'script'Definitions load; guarded __main__ block is skipped
import pkg.mod (Submodule)'pkg.mod'Contains full dotted package hierarchy path
python -m pkg (Package)'__main__' (in __main__.py)Sets __package__ = 'pkg' enabling relative imports

The __name__ == '__main__' Idiom Explained Top 20 Bilingual MCQs with Answers

Q1. When a file `calc.py` is run directly via `python calc.py`, what is the value of `__name__` inside `calc.py`?

(`python calc.py` द्वारा सीधे चलाने पर `calc.py` के भीतर `__name__` का मान क्या होता है?)

(A) '__init__'

(B) 'calc.py'

(C) '__main__'

(D) 'calc'

Correct Answer: (C)

[EN] The top-level script executed directly by the Python interpreter always receives `'__main__'` for `__name__`.

[HI] पायथन इंटरप्रेटर द्वारा सीधे चलाई जाने वाली मुख्य स्क्रिप्ट में `__name__` का मान हमेशा `'__main__'` होता है।

Q2. When `main.py` executes `import helper`, what is the value of `__name__` inside `helper.py`?

(जब `main.py` में `import helper` चलता है, तो `helper.py` के भीतर `__name__` का मान क्या होता है?)

(A) 'helper'

(B) '__main__'

(C) 'main'

(D) 'helper.py'

Correct Answer: (A)

[EN] Imported modules receive their module name string rather than `'__main__'`.

[HI] इम्पोर्ट किए गए मॉड्यूल को `'__main__'` के बजाय उसका अपना मॉड्यूल नाम `'helper'` मिलता है।

Q3. When `app.py` executes `import tools.parser`, what is `__name__` inside `tools/parser.py`?

(जब `app.py` में `import tools.parser` चलता है, तो `tools/parser.py` में `__name__` क्या होगा?)

(A) 'tools.parser'

(B) 'parser'

(C) 'tools'

(D) '__main__'

Correct Answer: (A)

[EN] Submodules inside packages receive their full dotted module path as `__name__`.

[HI] पैकेज के भीतर स्थित सबमॉड्यूल का `__name__` पूरा डॉटेड पाथ `'tools.parser'` होता है।

Q4. What is the primary purpose of `if __name__ == '__main__':` in a Python file?

(पायथन फाइल में `if __name__ == '__main__':` लिखने का मुख्य उद्देश्य क्या है?)

(A) To prevent script-only code from running when the file is imported as a module

(B) To satisfy a mandatory Python syntax requirement like C's main()

(C) To declare global variables across multiple modules

(D) To tell Python where to start compiling functions

Correct Answer: (A)

[EN] It guards execution code so definitions can be reused via import without triggering driver or test routines.

[HI] यह इम्पोर्ट करते समय मुख्य निष्पादन कोड को चलने से रोकता है ताकि फाइल लाइब्रेरी और स्क्रिप्ट दोनों बन सके।

Q5. What data type is the built-in `__name__` attribute?

(बिल्ट-इन `__name__` एट्रिब्यूट का डेटा टाइप क्या होता है?)

(A) module

(B) type

(C) str

(D) bool

Correct Answer: (C)

[EN] `__name__` is always a standard Python string (`str`), such as `'__main__'` or `'math'`.

[HI] `__name__` हमेशा एक स्ट्रिंग (`str`) होती है।

Q6. Which special file inside a package folder is executed when running `python -m mypkg`?

(`python -m mypkg` कमांड चलाने पर पैकेज फोल्डर के भीतर कौन-सी विशेष फाइल चलती है?)

(A) __init__.py

(B) main.py

(C) __app__.py

(D) __main__.py

Correct Answer: (D)

[EN] Python looks for `__main__.py` inside a package when the package is invoked as a script with `-m`.

[HI] `python -m` से पैकेज चलाने पर पायथन उसके भीतर `__main__.py` फाइल को चलाता है।

Q7. Why is `if __name__ == '__main__':` mandatory for `multiprocessing.Process` scripts on Windows?

(Windows पर `multiprocessing.Process` का उपयोग करने वाली स्क्रिप्ट में `if __name__ == '__main__':` क्यों आवश्यक है?)

(A) multiprocessing requires __name__ to be passed as an argument

(B) Windows blocks any Python script lacking a __main__ guard

(C) Windows uses spawn, which re-imports the main script in child processes and would infinitely spawn processes without the guard

(D) Python converts __main__ to C threads on Windows

Correct Answer: (C)

[EN] Child processes created via `spawn` import the entry script; guarding Process creation prevents recursive spawning.

[HI] Windows पर `spawn` मेथड चाइल्ड प्रोसेस में फाइल को दोबारा इम्पोर्ट करता है, इसलिए गार्ड के बिना अनंत प्रोसेस बनने का एरर आता है।

Q8. Suppose `mod.py` contains: print(__name__) if __name__ == '__main__': print('EXEC') If `run.py` runs `import mod`, what is printed?

(मान लें `mod.py` में है: print(__name__) if __name__ == '__main__': print('EXEC') यदि `run.py` में `import mod` चले, तो क्या प्रिंट होगा?)

(A) __main__ followed by EXEC

(B) mod followed by EXEC

(C) Nothing is printed

(D) mod

Correct Answer: (D)

[EN] Top-level `print(__name__)` prints `'mod'`, and the guarded `if` block evaluates to False so `'EXEC'` is skipped.

[HI] टॉप-लेवल का `print(__name__)` `'mod'` प्रिंट करेगा, जबकि `if` कंडीशन False होने से `'EXEC'` प्रिंट नहीं होगा।

Q9. What is the value of `__name__` inside the interactive Python REPL shell?

(इंटरैक्टिव पायथन REPL शेल के भीतर `__name__` का मान क्या होता है?)

(A) None

(B) 'builtins'

(C) 'repl'

(D) '__main__'

Correct Answer: (D)

[EN] Interactive sessions run in the `__main__` module namespace.

[HI] इंटरैक्टिव सेशन भी `__main__` मॉड्यूल नेमस्पेस में ही चलता है।

Q10. When running `python -m pkg.worker`, what are `__name__` and `__package__` inside `worker.py`?

(`python -m pkg.worker` चलाने पर `worker.py` के भीतर `__name__` और `__package__` क्या होते हैं?)

(A) __name__ == 'worker' and __package__ == None

(B) __name__ == 'pkg.worker' and __package__ == 'pkg'

(C) __name__ == '__main__' and __package__ == 'pkg'

(D) __name__ == '__main__' and __package__ == ''

Correct Answer: (C)

[EN] The `-m` switch executes `worker.py` as `'__main__'` while retaining `'pkg'` in `__package__` so relative imports work.

[HI] `-m` के साथ चलने पर `__name__` `'__main__'` रहता है और `__package__` `'pkg'` बना रहता है।

Q11. What happens if a running script `demo.py` executes `import demo` inside itself?

(यदि चलती हुई स्क्रिप्ट `demo.py` अपने अंदर ही `import demo` चला दे तो क्या होगा?)

(A) RecursionError immediately

(B) Python loads a second separate module object named 'demo' in sys.modules alongside '__main__'

(C) Python detects it is already running and skips re-execution

(D) SyntaxError: circular self-import

Correct Answer: (B)

[EN] Because the main script was registered under key `'__main__'`, importing `'demo'` misses that key and loads `'demo'` anew.

[HI] मुख्य स्क्रिप्ट `'__main__'` नाम से लोड होती है, इसलिए `import demo` करने पर `'demo'` नाम से दूसरा अलग मॉड्यूल ऑब्जेक्ट बन जाता है।

Q12. Is `if __name__ == '__main__':` strictly required in every standalone Python script?

(क्या हर स्वतंत्र पायथन स्क्रिप्ट के चलने के लिए `if __name__ == '__main__':` लिखना अनिवार्य है?)

(A) No, Python runs top-level code sequentially even without it

(B) Yes, Python skips files without a __main__ check

(C) Yes, otherwise Python raises SyntaxError

(D) Only in Python 3, not in Python 2

Correct Answer: (A)

[EN] Unlike Java/C, Python does not require a main function or guard; it is purely a clean convention and safety idiom.

[HI] C/Java के विपरीत पायथन में यह अनिवार्य नहीं है, यह केवल कोड को सुरक्षित और व्यवस्थित रखने की एक प्रचलित प्रथा है।

Q13. What is `math.__name__` after running `import math as m`?

(`import math as m` चलाने के बाद `m.__name__` का मान क्या होगा?)

(A) 'm'

(B) '__main__'

(C) 'math'

(D) 'builtins'

Correct Answer: (C)

[EN] An import alias (`as m`) only renames the local variable; the module object's internal `__name__` remains `'math'`.

[HI] `as m` केवल लोकल रेफरेंस का नाम बदलता है; मॉड्यूल ऑब्जेक्ट के भीतर `__name__` का मान `'math'` ही रहता है।

Q14. Is `__main__` a reserved keyword in Python's `keyword.kwlist`?

(क्या `__main__` पायथन की `keyword.kwlist` में शामिल एक रिजर्व्ड कीवर्ड है?)

(A) Only inside package directories

(B) Yes, along with __init__

(C) No, it is just a string value assigned to __name__

(D) Yes, introduced in Python 3.0

Correct Answer: (C)

[EN] `'__main__'` is an ordinary string literal and `__name__` is a module attribute; neither is a Python keyword.

[HI] `'__main__'` एक साधारण स्ट्रिंग मान है और `__name__` एक वेरिएबल; इनमें से कोई भी रिजर्व्ड कीवर्ड नहीं है।

Q15. In a project with `app.py` importing `db.py`, which module has `__name__ == '__main__'` when `python app.py` is run?

(यदि `app.py` फाइल `db.py` को इम्पोर्ट करे और `python app.py` चलाया जाए, तो किसका `__name__` `'__main__'` होगा?)

(A) Both app.py and db.py

(B) Only app.py

(C) Neither app.py nor db.py

(D) Only db.py

Correct Answer: (B)

[EN] Only the entry-point script passed to the interpreter receives `'__main__'`; imported dependencies receive their module names.

[HI] केवल सीधे चलाई जाने वाली मुख्य फाइल `app.py` को `'__main__'` मिलता है, इम्पोर्ट की गई `db.py` को `'db'` मिलता है।

Q16. Which statement is NOT true about `__name__ == '__main__'`?

(`__name__ == '__main__'` के बारे में निम्न में से कौन-सा कथन सत्य नहीं है?)

(A) `__name__` is automatically populated by the Python interpreter

(B) Unit tests can be placed inside the `__main__` block of a utility module

(C) Imported modules get their dotted module name in `__name__`

(D) The function called inside `if __name__ == '__main__':` must always be named `main()`

Correct Answer: (D)

[EN] You can execute any statements or call any function name inside `if __name__ == '__main__':`; naming a function `main()` is optional.

[HI] `if __name__ == '__main__':` के भीतर किसी भी नाम का फंक्शन या सीधे स्टेटमेंट चलाया जा सकता है, `main()` नाम रखना जरूरी नहीं है।

Q17. Within The __name__ == '__main__' Idiom Explained, which execution context directly maps to: "'__main__'"?

(The __name__ == '__main__' Idiom Explained में कौन सा Execution Context सीधे "'__main__'" से संबंधित है?)

(A) python -m pkg (Package)

(B) import pkg.mod (Submodule)

(C) python script.py (Direct)

(D) import script (Imported)

Correct Answer: (C)

[EN] In The __name__ == '__main__' Idiom Explained, 'python script.py (Direct)' handles ''__main__'' (Code inside if __name__ == '__main__': executes).

[HI] The __name__ == '__main__' Idiom Explained में 'python script.py (Direct)' का कार्य/विवरण ''__main__'' (Code inside if __name__ == '__main__': executes) है।

Q18. Which option accurately describes 'import script (Imported)' in The __name__ == '__main__' Idiom Explained?

(The __name__ == '__main__' Idiom Explained के संदर्भ में 'import script (Imported)' की सही विशेषता कौन सी है?)

(A) '__main__' (in __main__.py)

(B) 'pkg.mod'

(C) '__main__'

(D) 'script'

Correct Answer: (D)

[EN] 'import script (Imported)' provides ''script'' — key point: Definitions load; guarded __main__ block is skipped.

[HI] 'import script (Imported)' का मुख्य विवरण ''script'' है (Definitions load; guarded __main__ block is skipped)।

Q19. In The __name__ == '__main__' Idiom Explained, identify the correct parameter for the specification: "'pkg.mod'".

(The __name__ == '__main__' Idiom Explained में "'pkg.mod'" विवरण किस विकल्प के लिए सही है?)

(A) import script (Imported)

(B) import pkg.mod (Submodule)

(C) python -m pkg (Package)

(D) python script.py (Direct)

Correct Answer: (B)

[EN] 'import pkg.mod (Submodule)' corresponds to ''pkg.mod'' (Contains full dotted package hierarchy path).

[HI] 'import pkg.mod (Submodule)' का संबंध ''pkg.mod'' (Contains full dotted package hierarchy path) से है।

Q20. Considering The __name__ == '__main__' Idiom Explained, what key behavior defines 'python -m pkg (Package)'?

(The __name__ == '__main__' Idiom Explained में 'python -m pkg (Package)' की मुख्य भूमिका या मान क्या है?)

(A) 'script'

(B) 'pkg.mod'

(C) '__main__'

(D) '__main__' (in __main__.py)

Correct Answer: (D)

[EN] 'python -m pkg (Package)' represents ''__main__' (in __main__.py)' (Sets __package__ = 'pkg' enabling relative imports).

[HI] 'python -m pkg (Package)' का अर्थ/मान ''__main__' (in __main__.py)' है (Sets __package__ = 'pkg' enabling relative imports)।

The __name__ == '__main__' Idiom Explained — Exam FAQs

Q1: Does Python require a function actually named `main()` when using `if __name__ == '__main__':`?

क्या `if __name__ == '__main__':` का उपयोग करते समय अंदर `main()` नाम का फंक्शन बनाना जरूरी होता है?

[EN] No. Calling `main()` is purely a style convention to encapsulate script logic cleanly. You can place any valid Python code or call any function inside the `if __name__ == '__main__':` block.

[HI] नहीं, `main()` नाम केवल कोड को साफ रखने की एक परंपरा है। आप `if __name__ == '__main__':` के अंदर कोई भी कोड या किसी भी नाम का फंक्शन कॉल कर सकते हैं।

Q2: Why do relative imports fail when running `python pkg/sub.py` directly, whereas `python -m pkg.sub` succeeds?

`python pkg/sub.py` चलाने पर रिलेटिव इम्पोर्ट क्यों फेल हो जाते हैं जबकि `python -m pkg.sub` में वे काम करते हैं?

[EN] Running `python pkg/sub.py` sets `__name__` to `'__main__'` and `__package__` to `None`, so Python has no parent package metadata to resolve dots like `from . import helper`. Using `-m pkg.sub` keeps `__package__ == 'pkg'` while still setting `__name__ == '__main__'`.

[HI] `python pkg/sub.py` से चलाने पर `__package__` का मान `None` रहता है जिससे डॉट (`.`) वाले रिलेटिव इम्पोर्ट पैरेंट पैकेज नहीं ढूंढ पाते। `-m pkg.sub` में `__package__` `'pkg'` बना रहता है।

Q3: What happens if two imported modules both contain `if __name__ == '__main__':` blocks?

यदि दो इम्पोर्ट किए गए मॉड्यूल्स दोनों में `if __name__ == '__main__':` ब्लॉक हो, तो क्या होगा?

[EN] Neither block runs during import because each imported module's `__name__` equals its own module name rather than `'__main__'`. Only the top-level script being executed directly has `__name__ == '__main__'`.

[HI] इम्पोर्ट के समय उनमें से किसी का भी `__main__` ब्लॉक नहीं चलेगा, क्योंकि दोनों के `__name__` में उनके मॉड्यूल का नाम होगा। केवल सीधे चलाई गई मुख्य फाइल का ही ब्लॉक चलता है।

Related Posts

  • Loading related posts...

Post a Comment

Search Topic Notes & 20 MCQs (Hindi / English)