What Does if __name__ == "__main__" Do?

The guard is a comparison against the literal string __main__, and __name__ is a module attribute whose value depends on how the module was loaded.

When you run a file directly, Python executes it as the main module and sets __name__ to the string __main__. When the same file is imported by another module, __name__ is set to the module's own name — greet, for example — so the comparison is False and the guarded block is skipped.

That difference is the entire purpose of the guard. It lets a file contain both a set of definitions that other modules can import and a set of statements that should only run when the file is executed as a program. Without it, importing the module would run the top-level code too, which is why scripts used to print things or start servers the moment they were imported.

The idiomatic shape puts the executable work in a function called main and calls it from inside the guard, so the module stays importable and side-effect free, and there is one obvious place to look for the entry point.

One trap worth mentioning for interviews. If a module in your project is imported under two different names — for example once as package.module and once as module — it will be executed twice, because sys.modules keys on the name. The main guard does not prevent that, because in both cases the module is being imported rather than run. Keeping consistent import paths is what actually solves it.

You can build a small module on disk and import it to watch the guard do its job.

import importlib.util
import os
import tempfile

path = os.path.join(tempfile.gettempdir(), "tutorsbot_greet.py")
with open(path, "w", encoding="utf-8") as handle:
    handle.write(
        "print('module body ran')\n"
        "\n"
        "if __name__ == '__main__':\n"
        "    print('main block ran')\n"
    )

spec = importlib.util.spec_from_file_location("tutorsbot_greet", path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)

print("import finished")

os.remove(path)

The output is module body ran followed by import finished. The main block never ran, because when the module was loaded its __name__ was tutorsbot_greet rather than __main__.

The module body did run — the top-level print statement executed as the module was executed. That is normal: importing a module always executes its top-level code once. The guard only protects the part you have deliberately marked as entry-point behaviour.

What this buys you is reusability. The module can be imported by a test, by another script or by a package, and none of them will trigger the side effects. Without the guard, importing it would run the entry-point code, which is the bug that the guard exists to prevent.

The value of __name__ is determined by how the module was loaded, and you can check it from inside the module.

print("name:", __name__)
print("package:", __package__)
print("file:", __file__.rsplit("/", 1)[-1])

if __name__ == "__main__":
    print("running as a script")
else:
    print("running as an imported module")

Run directly, the first line shows __main__ and the script branch is taken. Imported as a module named greet, it would show greet and take the other branch. The other two attributes are useful companions: __package__ is the name of the containing package, or an empty string for a top-level module, and __file__ is the path of the source file.

One detail to mention is that __name__ is not special in the way a keyword would be. It is a normal module attribute that the import machinery sets, and you can assign to it, which is occasionally done in scripts that want to fake a different import context. But the conventional use is exactly the guard: compare it against the literal string __main__ and put your entry point inside.

The other convention you will see in the same file is the opposite guard, if __name__ != '__main__':, which runs the import-time code instead. Between them, the two forms let a module distinguish between being run and being imported.