if __name__ == '__main__':
We see if __name__ == '__main__': quite often.
It checks if a module is being imported or not.
In other words, the code within the 'if' block will be executed only when the code runs directly. Here 'directly' means 'not imported'.
Let's see what it does using a simple code that prints the name of the modue:
# m1.py def myfnc(): print('m1 module name=%s' %(__name__)) if __name__ == '__main__': print('call myfnc()') myfnc()
If we run the code directly via "python m.py", the module name is "__main__":
call myfnc() m1 module name=__main__
So, the 'if' code block will be executed. However, if we import the module from other code (i.e. m2.py), the name is not '__main__':
# m2.py import m1 print('m1.__name__ = %s' %(m1.__name__))
If we run it, we won't have any output from 'm1.py' because the the code within 'if' block won't be executed. Note that when imported, module name for m1 is not '__main__' anymore:
$ python m2.py m1.__name__ = m1
Because Python can tell if a module is imported or not, we can use this feature to test a code.
The code below will print the width and height when we import the module.
# pt.py class Rectangle(object): def __init__(self, w, h): self.width = w self.height = h def area(self): return self.width * self.height r1 = Rectangle(10,20) print(r1.width, r1.height)
It is good if it stays as a standalone code. But we may not want to print out the test case when we want use it as a imported module. So, we need to block it from printing the output. That's what the module __name__ check is doing in the code below:
# pt2.py class Rectangle(object): def __init__(self, w, h): self.width = w self.height = h def area(self): return self.width * self.height if __name__ == '__main__': r1 = Rectangle(10,20) print(r1.width, r1.height)
Python modules are objects and have several useful attributes. As shown in the above example, we can use this to easily test our modules as we write them, by including a special block of code that executes when we run the Python file on the command line.
Actually, in Python, a function called main doesn't have any special role. However, it is a common practice to organize a program's main functionality in a function called main and call it with code similar to the following:
def main(): try: doMainthing() return 0 except: return 1 if __name__ == "__main__": sys.exit(main())
Note that like C, Python uses == for comparison and = for assignment. Unlike C, however, Python does not support in-line assignment, so there's no chance of accidentally assigning the value you thought you were comparing.
Another example doing binary search:
class MyTest: def __init__(self, array, upper): self.upper = upper; self.array = array def binary(self,n): lower = 0 upper = self.upper while lower <= upper: mid = (lower+upper)/2 if(n < array[mid]): upper = mid-1 elif(n > array[mid]): lower = mid+1 elif(n == array[mid]): return mid return -1 if __name__ == "__main__": array = [0,1,2,3,4,5,6,7,8,9,10] t = MyTest(array, len(array)-1) x = t.binary(10) if x == -1: print "Not found" else: print "Found at", x
$ python t.py Found at 10
So. what makes this if statement special?
Well, modules are objects, and all modules have a built-in attribute __name__. A module's __name__ depends on how we're using the module.
If we import the module, then __name__ is the module's filename, without a directory path or file extension:
C:\TEST> python >>> import pt2 >>> pt2.__name__ 'pt2'
But you can also run the module (pt3.py) not by importing it but running it directly as a standalone program:
# pt3.py class Rectangle(object): def __init__(self, w, h): self.width = w self.height = h def area(self): return self.width * self.height if __name__ == '__main__': r1 = Rectangle(10,20) print(r1.width, r1.height) print "__name__ = ", __name__
in which case __name__ will be a special default value, __main__ as shown below:
C:\TEST> python pt3.py (10, 20) __name__ = __main__
Python evaluated the if statement, found a true expression, and executed the if code block. In this case, it printed two values and the __name__.
The Python program (pt3.py) was executed directly (as opposed to being imported from another program), and we see the special global variable __name__ has the value __main__. This will call the function main() and when main finishes, it will exit giving the system the return code that is the result of main(). In other words, if we execute the Python script directly, __name__ is set to __main__, but if we import it from another script, it is not. In the case when the script is being imported from another module, it doesn't execute the main() function and simply provides the script's functions and classes to the importing script.
Though it may be repeating the above statements, here is one of the answers from stackoverflow to the question:
What does "if __name__ == '__main__':" do?
Ans: When the Python interpreter reads a source file, it executes all of the code found in it. Before executing the code, it will define a few special variables. For example, if the python interpreter is running that module (the source file) as the main program, it sets the special __name__ variable to have a value __main__. If this file is being imported from another module, __name__ will be set to the module's name.
- import: __name__ = module's filename
if statement == False, and the script in __main__ will not be executed
- direct run: __name__ = __main__
if statement == True, and the script in __main__ will be executed
Also, it exits the python interpreter after we run it directly. But if we import it, the exit call never happens because the if statement is false.
Ph.D. / Golden Gate Ave, San Francisco / Seoul National Univ / Carnegie Mellon / UC Berkeley / DevOps / Deep Learning / Visualization