Question

So I start up pyscripter and I get a file with this in it:

def main():
    pass

if __name__ == '__main__':
    main()

What is that? Why does my program work without it as well? Whats the purpose for this anyway?
Where would my code go? Lets say a a function that prints hello world. Where would that go? where would I call it?

Answer 1

The purpose is basically that you can define a central entrypoint, if, and only if, the script is directly run on its own. Because __name__ will only ever be equal to '__main__', if it is run on its own. Putting your script’s actual content into a separate function allows other scripts to import said function and run it whenever they want it, so it won’t run immediately when the script is imported.

This is also often used in libary modules to have some default behaviour when you just need something quickly. For example the http.server module offers a wide functionality to create your own HTTP server with whatever features you can think of. If you just want to quickly have a simple server listen and pass files statically, you can just use the module’s default behaviour when run from the command line.

Running python3 -m http.server on the command line will exactly do that; run the http.server module, which itself will start a simple HTTP server in its __name__ == '__main__ block.

In response to your comment:

For normal modules, that act as libraries, contain types or functions, your application needs, you don’t need a main function or main block. For scripts that are called directly, for example your starting script that actually launches your application you will have some kind of code that is not encapsulated in functions or classes but that runs directly. That would be something, you could put in a main function which you then call separately. This gives you a bit more freedom to where you put that code. For example you can have the main function directly at the beginning of the file, while additional functions that are called within it are defined further into the file. And the very last part of the script is then the main(). You don’t necessarily need to put that into a if __main__ == '__main__': condition, you could just call it directly. So for example your script could look like this:

def main ():
    # doing something
    utilityFunction(...)
    otherUtilityFunction(...)

def utilityFunction (...):
    ...
def otherUtilityFunction (...):
    ...

main()

If you don’t put the code into a separate function, you’d have to do all the processing at the bottom (after your function definitions) and that might be counter-productive if you just want to quickly see what you do when the script is directly called.

Now, as I said, you don’t need to put that into main-condition block; you can just call it directly. However, if for whatever reason you ever need to include that file, for example because you want to encapsulate it into some other thing, or if you want to call it repeatedly from an interactive shell (IDLE or something), you probably don’t want to run main() whenever you just import the module but only when you want to actually execute its functionality. That’s where you should put the main() into the condition; that way it won’t get executed unless you are directly executing the module.

In general, it’s not a bad idea to always put the main() call into such a condition, as it will never hurt but often turn useful at some later point.