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 m1.py", the module name is "__main__":

call myfnc()
m1 module name=__main__

So, the 'if' code block will be executed.

Note also that we can run the code directly using "-m" option:

$ python -m m1
call myfnc()
m1 module name=__main__

For modules that can usually be imported just using import modul_name, we can use python -m module_name to run that module directly (we don't need to know the path!).

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 a 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

Run it:

$ 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:

$ 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:

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

1. import: __name__ = module's filename
   if statement == False, and the script in __main__ will not be executed
   
2. 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.

For better understanding, please play with the following two files with Python3.

foo.py:

#!/usr/bin/python3

print("foo.py")

print(f"__name__ = {__name__}")
print("before import")
import math

print("before functionA")
def functionA():
    print("Function A")

print("before functionB")
def functionB():
    print("Function B {}".format(math.sqrt(100)))

print("before functionC")
def functionC(arg):
    print(f"Function C arg = {arg}")

print("before if __name__ == '__main__':")

if __name__ == '__main__':
    functionA()
    functionB()
    print(f" from __main__ before functionC()")
    functionC(999)
print("after if __name__ == '__main__':")    

bar.py:

print("bar.py")
print(f"__name__ = {__name__}")
print(f"importing foo")
import foo
def functionD():
    print("functionD()")
    foo.functionC(10)

if __name__ == '__main__':
    functionD()    

$ python3 foo.py
foo.py
__name__ = __main__
before import
before functionA
before functionB
before functionC
before if __name__ == '__main__':
Function A
Function B 10.0
 from __main__ before functionC()
Function C arg = 999
after if __name__ == '__main__':  

$ python3 bar.py
bar.py
__name__ = __main__
importing foo
foo.py
__name__ = foo
before import
before functionA
before functionB
before functionC
before if __name__ == '__main__':
after if __name__ == '__main__':
functionD()
Function C arg = 10