I always use

if "__main__" == main:
    __main__()

…and earlier in the code:

def __main__():
    while True:
        pass
main = "__main__"

This helps to prevent people from arbitrarily running my code as a library or executable when I don’t went them to.

I’m at peace with balanced underscores (like “dunder name equals dunder main”) and the internal ones for snake case, but in the unbalanced ones (prefixing unders and dunders for pseudo-private) still bug me. But at least, conventionally, it’s visually the same idea as Hungarian notation.

Interesting observation. Can you give an example where this is relevant?

Tbh reserving “main” is just a hacky if not more so than checking __name__ if you actually understand language design.

Is it? I really don’t think so. What can you propose that’s better? I think if __name__ == __main__ works perfectly fine and can’t really think of anything that would be better.

And you don’t have to use it either if you don’t want to anyway, so no, I don’t think it’s that much of a hack. Especially when the comic compares C as an example, which makes no sense to me whatsoever.

aren’t most of not all conventions hacky anyways?

Python has a bunch of magic variables, like __name__. This one contains the name of the module you’re currently in (usually based on the file name), so if your file is called foo.py, it will have the value foo.

But that’s only if your module is being imported by another module. If it’s executed directly (e.g. python foo.py), it will instead have a __name__ of __main__. This is often used to add a standalone CLI section to modules - e.g. the module usually only defines functions that can be imported, but when executed it runs an example of those functions.

Basically, when you compile a program written in Rust or C/C++ (the first and second panels respectively), the compiler needs to know what’s supposed to be executed first when the program is run directly (i.e. when you click on the executable), which in these languages, is denoted by a special function called main(). Executable files can also contain functions and data structures that can be called by other programs, and when they are, you wouldn’t want to run an entire complex and resource intensive program if another program only needs to call a single function from it. In that case, the other program will call the function it wants but not main, so only that function executes and not the entire program.

However, Python is a scripting language that’s interpreted. So every Python source file is executable provided you have the Python runtime. Python also doesn’t have native support for main functions in the same way Rust and C/C++ does, and it will execute every line of code as it reads the source file. This is why a single line Python file that just calls print is valid, it doesn’t need to be wrapped in a main function to execute. However, what if your Python file is both meant to be executed directly and provides functions that other Python files can call? If you just put the main routine in the root of the file, it would be executed every time another program tries to import the file in order to call functions from it, since the import causes the file to be interpreted and executed in its entirety. You can still just have a main function in your file, but since Python doesn’t natively support it, your main function won’t do anything if you run the file directly because as far as Python is concerned, there is no executable code at the root of the file and you haven’t called any functions.

The workaround is to have a single if statement at the root of the file that looks like this:

if __name__ == '__main__':
    main()

It checks a special variable called __name__. If the Python file is directly executed, __name__ will have the value of the string '__main__', which satisfies the if statement so main() is called. If another Python file imports it, the value of __name__ will be the name of that file, so main() isn’t called. It’s clunky and not that efficient, but, 1, it works, and 2, if you cared about efficiency, you wouldn’t be writing it in Python.

All code needs to have an entry point.

For Python and some other languages, this is the start of the file.

For other languages, this is a special function name reserved for this purpose - generally, “main”.

In the first kind of language, the thought process is basically: I have the flow of execution, starting at the top of the file. If I want to make a library, I should build the things I want to build, then get out of the way.

In the other kind of language, the thought process is basically: I am building a library. If I want to make an executable, I should create an entry point they the execution starts at.

The debate is honestly pretty dumb.

I’m a little new to Python standards. Is this better or worse than putting the def main(): outside the if statement (but calling main() inside it)

Diabolical

What’s the difference between a “scripting” language and a “real” one?

Excel recently added the ability to run python code lol

compared with other languages at the time, the ease of access and readability makes it worth it. plus, the heavy duty stuff is usually handled by more optimised code line numpy or sklearn…

The point of the name==main logic is that it checks if that is the file that was invoked (like running python filename.py). If you just put a main() in the global scope it will be called either when the file is invoked or loaded (which can cause unintended consequences).

Just cross your fingers nobody attempts to import it…

All of mine are called do_thing() because after a few days of working on it, the scope creep always means the original name was wrong anyway.