Understanding the main method of python

I am new to Python, but I have experience in other OOP languages. My
course does not explain the main method in python.

Please tell me how main method works in python
? I am confused because I am trying to compare it to Java.

def main():
# display
            some lines


if __name__ == "__main__":
            main()

How is main
executed and why do I need this strange if to execute
main. My code is terminated without output when I remove the
if.

The minimal code -

class AnimalActions:

            def quack(self): return self.strings['quack']
 def bark(self): return
            self.strings['bark']


class
            Duck(AnimalActions):
 strings = dict(
 quack =
            "Quaaaaak!",
 bark = "The duck cannot bark.",

            )


class Dog(AnimalActions):
 strings =
            dict(

 quack = "The dog cannot quack.",
 bark =
            "Arf!",
 )

def in_the_doghouse(dog):

            print(dog.bark())

def in_the_forest(duck):

            print(duck.quack())


def main():
 donald =
            Duck()
 fido = Dog()

 print("- In the
            forest:")
 for o in ( donald, fido ):

            in_the_forest(o)

 print("- In the doghouse:")
 for o in (
            donald, fido ):

 in_the_doghouse(o)

if
            __name__ == "__main__": main()

Answer

The Python approach to "main" is almost
unique to the language(*).

The semantics are a
bit subtle. The __name__ identifier is bound to the name of any
module as it's being imported. However, when a file is being executed then
__name__ is set to "__main__" (the
literal string:
__main__).

This is
almost always used to separate the portion of code which should be executed from the
portions of code which define functionality. So Python code often contains a line
like:

#!/usr/bin/env
            python
from __future__ import print_function
import this, that,
            other, stuff
class SomeObject(object):

            pass

def some_function(*args,**kwargs):

            pass


if __name__ == '__main__':
 print("This
            only executes when %s is executed rather than imported" %
            __file__)

Using this
convention one can have a file define classes and functions for use in other programs,
and also include code to evaluate only when the file is called as a standalone
script.

It's important to understand that all of
the code above the if __name__ line is being executed,
evaluated, in both cases. It's evaluated by the interpreter when the file is imported or
when it's executed. If you put a print statement before the
if __name__ line then it will print output every time any other
code attempts to import that as a module. (Of course, this would be
anti-social. Don't do
that).

I, personally, like these semantics. It
encourages programmers to separate functionality (definitions) from function (execution)
and encourages re-use.

Ideally almost
every Python module can do something useful if called from the command line. In many
cases this is used for managing unit tests. If a particular file defines functionality
which is only useful in the context of other components of a system then one can still
use __name__ == "__main__" to isolate a block of code which
calls a suite of unit tests that apply to this
module.

(If you're not going to have any such
functionality nor unit tests than it's best to ensure that the file mode is NOT
executable).

Summary: if __name__ ==
'__main__': has two primary use
cases:

• Allow a module to
  provide functionality for import into other code while also providing useful semantics
  as a standalone script (a command line wrapper around the
  functionality)


• Allow a module to define a suite of unit
  tests which are stored with (in the same file as) the code to be tested and which can be
  executed independently of the rest of the
  codebase.

It's
fairly common to def main(*args) and have if
__name__ == '__main__': simply call
main(*sys.argv[1:]) if you want to define main in a manner
that's similar to some other programming languages. If your .py file is primarily
intended to be used as a module in other code then you might def
test_module() and calling test_module() in your
if __name__ == '__main__:'
suite.

• (Ruby also
  implements a similar feature if __file__ ==
$0).