Understanding the main method of python

Question

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()

you don't need the if, you can write just `main()` and will also work — Ruben Bermudez, Mar 18 '14 at 22:16
@RubenBermudez Bad idea, that defies the whole point. A main function is used so the file can be imported into a REPL without running as a script, this is what the `if` statement does. If you did not use `if` the script would be run at times where you don't want it to such as importing that module. — anon582847382, Mar 18 '14 at 22:20
@AlexThornton Does that mean you shouldn't use ```main()``` as a wrapper function? If so, is there some sort of naming convention for such a wrapper function? — juil, Apr 14 '16 at 03:49
@juil What @AlexThornton meant is that calling `main()` directly without `if` is a bad idea. There's no problem at all in defining the function called `main`. Even if you called it `my_entry_point` that's not a problem, what becomes a problem is if you called `my_entry_point()` unconditionally without `if`. The emphasis is **without if** == bad idea. — Hendy Irawan, Nov 22 '17 at 12:32

score 224 · Accepted Answer · edited Dec 06 '17 at 10:41

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).

It's worth noting that there is nothing special, to Python, in the if __name__ == '__main__': construct. It is just like any other conditional statement ... and you could have multiple if __name__ == '__main__': and they'd function just like any other conditions and suites of statements in any other Python script. — Jim Dennis, Mar 19 '14 at 01:03
Also, statements outside `__name__ == "__main__"` only get run the first time you import a module in a given session and when you explicitly reload it. That is why modifying your source code and trying to import generally doesn't work as expected. — Mad Physicist, Dec 06 '17 at 10:39

score 80 · Answer 2 · edited Nov 02 '17 at 05:40

In Python, execution does NOT have to begin at main. The first line of "executable code" is executed first.

def main():
    print("main code")

def meth1():
    print("meth1")

meth1()
if __name__ == "__main__":main() ## with if

Output -

meth1
main code

More on main() - http://ibiblio.org/g2swap/byteofpython/read/module-name.html

A module's __name__

Every module has a name and statements in a module can find out the name of its module. This is especially handy in one particular situation - As mentioned previously, when a module is imported for the first time, the main block in that module is run. What if we want to run the block only if the program was used by itself and not when it was imported from another module? This can be achieved using the name attribute of the module.

Using a module's __name__

#!/usr/bin/python
# Filename: using_name.py

if __name__ == '__main__':
    print 'This program is being run by itself'
else:
    print 'I am being imported from another module'

Output -

$ python using_name.py
This program is being run by itself
$ python
>>> import using_name
I am being imported from another module
>>>

How It Works -

Every Python module has it's __name__ defined and if this is __main__, it implies that the module is being run standalone by the user and we can do corresponding appropriate actions.

Actually the first line that gets executed is `def main():`. — Mad Physicist, Sep 20 '16 at 18:12
@MadPhysicist just to be clear: it gets executed first because it's the first line, not because it's `def main()`. — Nietvoordekat, Dec 06 '17 at 10:25
@Nietvoordekat. Correct. There is noting special about the name `main`. The entire module is executed line by line, top to bottom. Every `def` and `class` statement gets executed to create function and class objects in the module namespace. Those objects consist of code and metadata that won't be run until explicitly invoked. — Mad Physicist, Dec 06 '17 at 10:32

Code-Apprentice · Answer 3 · 2018-12-02T17:49:24.653

21

Python does not have a defined entry point like Java, C, C++, etc. Rather it simply executes a source file line-by-line. The if statement allows you to create a main function which will be executed if your file is loaded as the "Main" module rather than as a library in another module.

To be clear, this means that the Python interpreter starts at the first line of a file and executes it. Executing lines like class Foobar: and def foobar() creates either a class or a function and stores them in memory for later use.

edited Dec 02 '18 at 17:49

answered Mar 18 '14 at 22:17

Code-Apprentice

81,660
23
145
268

Can you tell me which line is executed first in my code ? – Erran Morad Mar 18 '14 at 22:43
12

The first line is executed first. – kindall Mar 18 '14 at 22:44
4

Usually you'll have class and function definitions before the `if __name__ == "__main__"` line, so those would be executed first. – kindall Mar 18 '14 at 22:54

score 10 · Answer 4 · edited Dec 22 '16 at 03:23

If you import the module (.py) file you are creating now from another python script it will not execute the code within

if __name__ == '__main__':
    ...

If you run the script directly from the console, it will be executed.

Python does not use or require a main() function. Any code that is not protected by that guard will be executed upon execution or importing of the module.

This is expanded upon a little more at python.berkely.edu

Understanding the main method of python

4 Answers4

Linked