I don't understand Python's main block. What is that thing?

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?

class="post-text" itemprop="text">

class="normal">Answer

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.