Understanding the main method of python
I am new to Python, but I have experience in other OOPS 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
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()
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:
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
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).
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).