What does if __name__ == "__main__": do?

Question

What does this do, and why should one include the if statement?

if __name__ == "__main__":
    print("Hello, World!")

---

_{If you are trying to close a question where someone should be using this idiom and isn't, consider closing as a duplicate of Why is Python running my module when I import it, and how do I stop it? instead. For questions where someone simply hasn't called any functions, or incorrectly expects a function named main to be used as an entry point automatically, use Why doesn't the main() function run when I start a Python script? Where does the script start running?.}

Answer 1

If you are a beginner, probably the only answer you need right now is that this code is unnecessary for a simple script. It is only useful if you want to be able to import your script (or unpickle etc; see the other answers here for some other non-beginner scenarios).

In slightly different words, the if __name__ guard is a mechanism for hiding code from other code. If you don't have a specific reason to hide something, don't: If you don't need to hide some code from import, don't put it behind this guard, and if you do, hide as little as possible.

In somewhat more detail, let's say you have a simple script fib.py (adapted from this answer):

# XXX FIXME: useless (see below)
if __name__ == "__main__":
    n = int(input('Write a number: '))
    a, b = 0, 1
    while b < n:
        a, b = b, a+b
    print('Fibonacci number %i: %i' % (n, b))

Now, if you simply run python fib.py it works fine. But __name__ will always be "__main__" in this scenario, so the condition is actually unnecessary. The script could be simplified to just

n = int(input('Write a number: '))
a, b = 0, 1
while b < n:
    a, b = b, a+b
print('Fibonacci number %i: %i' % (n, b))

Now, you still can't import fib with the new version, but if you didn't plan to do that in the first place, this version is actually better, because it's simpler and clearer.

If you do want to be able to import fib, the first version was useless, too, because the useful code was in a section which will not run when you import that file (in which case __name__ will not be "__main__"). The proper design in that case would be to refactor the code so that the useful parts are in a function you can run when you want to after you have imported it.

def main():
    n = int(input('Write a number: '))
    a, b = 0, 1
    while b < n:
        a, b = b, a+b
    print('Fibonacci number %i: %i' % (n, b))

if __name__ == "__main__":
    main()

Now, if you import fib, the call to main() will not be executed; but when you run python fib.py, it will.

Actually, a better design still would be to isolate the reusable part (the actual calculation) from the user-visible input/output:

def fibn(n: int) -> int:
    a, b = 0, 1
    while b < n:
        a, b = b, a+b
    return b

def main() -> None:
    n = int(input('Write a number: '))
    print('Fibonacci number %i: %i' % (n, fibn(n)))

if __name__ == "__main__":
    main()

Now, you can from fib import fibn and call the fibn() function from the code which performs this import.

(I called the function fibn() just to make it clearer what is what in this example. In real life, you might call it fib() and do from fib import fib.)

Notice the more modular and reusable design; the fibn function contains the actual calculation, but no user interface parts; and the pesky interactive I/O is separated out into the main function so that you can bypass it (or call it if you want to, of course).

Unlike in languages like C, the name main has no specific meaning to Python; but it's a common convention to use it as the name of the thing which will be run. You still have to actually explicitly call it, like main(), unlike in C.

---

(The code in the question was subsequently reduced to just print("Hello, World!") but I'm leaving this here as potentially instructive for a more real-world scenario.)

Returning to the code in the question, I would similarly move the code from the if into a function as well, so that callers can invoke that function if they want to.

def main():
    lock = thread.allocate_lock()
    thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
    thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

if __name__ == "__main__":
    main()

This changes the scope of the lock variable; if the surrounding code needs access to it, you will need to make it global (or, perhaps, better, refactor main to return lock, and have the caller capture the value in a local variable of its own).

Answer 2

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

# test.py
def test():
   print('test module name=%s' %(__name__))

if __name__ == '__main__':
   print('call test()')
   test()

If we run the code directly via python test.py, the module name is __main__:

call test()
test module name=__main__

Answer 3

if __name__ == "__main__": prevents to run unwanted code when imported its file.

For example, this is test1.py without if __name__ == "__main__"::

# "test1.py"

def hello()
    print("Hello")

hello()

And test2.py just imports test1.py:

# "test2.py"

import test1 # Here

Then, when running test2.py, one Hello is printed because the unwanted code hello() in test1.py is also run:

python test2.py
Hello

Of course, you can call test1.hello() in test2.py:

# "test2.py"

import test1

test1.hello() # Here

Then, when running test2, two Hello is printed:

python test2.py
Hello
Hello

Now, add if __name__ == "__main__": to test1.py and put hello() under it:

# "test1.py"

def hello()
    print("Hello")

if __name__ == "__main__":
    hello()

And, this is test2.py:

# "test2.py"

import test1

test1.hello()

Then, when running test2.py, only one Hello is printed because if __name__ == "__main__": prevents to run the unwanted code hello() when test2.py imports test1.py:

python test2.py
Hello

In addition, whether test1.py has if __name__ == "__main__": or not:

# "test1.py"

def hello()
    print("Hello")

if __name__ == "__main__":
    hello()

# "test1.py"

def hello()
    print("Hello")

hello()

One Hello is printed properly when running test1.py:

python test1.py
Hello

Answer 4

Short Answer

It's boilerplate code that protects users from accidentally invoking the script when they didn't intend to. Here are some common problems when the guard is omitted from a script:

• If you import the guardless script in another script (e.g. import my_script_without_a_name_eq_main_guard), then the latter script will trigger the former to run at import time and using the second script's command line arguments. This is almost always a mistake.

• If you have a custom class in the guardless script and save it to a pickle file, then unpickling it in another script will trigger an import of the guardless script, with the same problems outlined in the previous bullet.

Long Answer

To better understand why and how this matters, we need to take a step back to understand how Python initializes scripts and how this interacts with its module import mechanism.

Whenever the Python interpreter reads a source file, it does two things:

• it sets a few special variables like __name__, and then

• it executes all of the code found in the file.

Let's see how this works and how it relates to your question about the __name__ checks we always see in Python scripts.

Code Sample

Let's use a slightly different code sample to explore how imports and scripts work. Suppose the following is in a file called foo.py.

# Suppose this is foo.py.

print("before import")
import math

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

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

print("before __name__ guard")
if __name__ == '__main__':
    function_a()
    function_b()
print("after __name__ guard")

Special Variables

When the Python interpreter reads a source file, it first defines a few special variables. In this case, we care about the __name__ variable.

When Your Module Is the Main Program

If you are running your module (the source file) as the main program, e.g.

python foo.py

the interpreter will assign the hard-coded string "__main__" to the __name__ variable, i.e.

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__" 

When Your Module Is Imported By Another

On the other hand, suppose some other module is the main program and it imports your module. This means there's a statement like this in the main program, or in some other module the main program imports:

# Suppose this is in some other main program.
import foo

The interpreter will search for your foo.py file (along with searching for a few other variants), and prior to executing that module, it will assign the name "foo" from the import statement to the __name__ variable, i.e.

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"

Executing the Module's Code

After the special variables are set up, the interpreter executes all the code in the module, one statement at a time. You may want to open another window on the side with the code sample so you can follow along with this explanation.

Always

1. It prints the string "before import" (without quotes).

2. It loads the math module and assigns it to a variable called math. This is equivalent to replacing import math with the following (note that __import__ is a low-level function in Python that takes a string and triggers the actual import):

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

3. It prints the string "before function_a".

4. It executes the def block, creating a function object, then assigning that function object to a variable called function_a.

5. It prints the string "before function_b".

6. It executes the second def block, creating another function object, then assigning it to a variable called function_b.

7. It prints the string "before __name__ guard".

Only When Your Module Is the Main Program

8. If your module is the main program, then it will see that __name__ was indeed set to "__main__" and it calls the two functions, printing the strings "Function A" and "Function B 10.0".

Only When Your Module Is Imported by Another

8. (instead) If your module is not the main program but was imported by another one, then __name__ will be "foo", not "__main__", and it'll skip the body of the if statement.

Always

9. It will print the string "after __name__ guard" in both situations.

Summary

In summary, here's what'd be printed in the two cases:

# What gets printed if foo is the main program
before import
before function_a
before function_b
before __name__ guard
Function A
Function B 10.0
after __name__ guard

# What gets printed if foo is imported as a regular module
before import
before function_a
before function_b
before __name__ guard
after __name__ guard

Why Does It Work This Way?

You might naturally wonder why anybody would want this. Well, sometimes you want to write a .py file that can be both used by other programs and/or modules as a module, and can also be run as the main program itself. Examples:

• Your module is a library, but you want to have a script mode where it runs some unit tests or a demo.

• Your module is only used as a main program, but it has some unit tests, and the testing framework works by importing .py files like your script and running special test functions. You don't want it to try running the script just because it's importing the module.

• Your module is mostly used as a main program, but it also provides a programmer-friendly API for advanced users.

Beyond those examples, it's elegant that running a script in Python is just setting up a few magic variables and importing the script. "Running" the script is a side effect of importing the script's module.

Food for Thought

• Question: Can I have multiple __name__ checking blocks? Answer: it's strange to do so, but the language won't stop you.

• Suppose the following is in foo2.py. What happens if you say python foo2.py on the command-line? Why?

# Suppose this is foo2.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    function_a()
    print("m2")
print("t2")
      

• Now, figure out what will happen in foo3.py (having removed the __name__ check):

# Suppose this is foo3.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo3 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
print("m1")
function_a()
print("m2")
print("t2")

• What will this do when used as a script? When imported as a module?

# Suppose this is in foo4.py
__name__ = "__main__"

def bar():
    print("bar")
    
print("before __name__ guard")
if __name__ == "__main__":
    bar()
print("after __name__ guard")

Answer 5

Do the following in your project.

Make a python file and simply print the __name__. Run this python file

Now, import this python file in another python file. Do not, touch the __name__ print statement.

After importing, the print(__name__) will still execute.

First, the output will be __main__. But in the second scenario, the output will be different (according to the name of the python file).

Therefore, if you add an if check if __name__ == "__main__" it will return True if the python file is being run without importing as a standalone script. But if it is being imported, this will evaluate to False. Why would you need all this?

Maybe your python file is class based or function based. You might want to reuse these classes or functions in a different python file. But, you might not want to execute the python script which is to be executed when that python script is executed as a standalone script.

Therefore, make sure to add this in almost every python file.

Answer 6

In addition to the information already provided, the if __name__ == "__main__": technique is also a great way to make sure your pytest and unittest scripts still run if you accidentally call them with python instead of pytest (or python -m unittest). Here's an example of that:

def test_assert():
    assert 1 + 2 == 3

if __name__ == "__main__":
    import pytest
    pytest.main([__file__])

Now your test will run regardless of calling it with pytest or python. Here's the unittest version:

import unittest

class Tests(unittest.TestCase):
    def test_assert(self):
        self.assertTrue(1 + 2 == 3)

if __name__ == "__main__":
    unittest.main()

Then your script runs the same with a python call as it would with a python -m unittest call.

Now, what if you also want to make sure that all your args gets passed to pytest if called with python? Or, what if you also want to include additional args? Here's an example of how to do that:

def test_assert():
    assert 1 + 2 == 3

if __name__ == "__main__":
    from pytest import main
    from sys import argv
    main([*argv, "-s"])

Now, your python -v --html=report.html will have the same effect as pytest -v --html=report.html, etc. It's a great way to make sure that scripts still run as intended, even if not run with the expected pytest or python -m unittest calls.

Answer 7

The code under if __name__ == '__main__': will only be executed if the module is invoked as a script.

As an example, consider the following module my_test_module.py:

# my_test_module.py

print('This is going to be printed out, no matter what')

if __name__ == '__main__':
    print('This is going to be printed out, only if user invokes the module as a script')

---

First possibility: Import my_test_module.py in another module

# main.py

import my_test_module

if __name__ == '__main__':
    print('Hello from main.py')

Now if you invoke main.py:

python main.py

>> 'This is going to be printed out, no matter what'
>> 'Hello from main.py'

Note that only the top-level print() statement in my_test_module is executed.

---

Second possibility: Invoke my_test_module.py as a script

Now if you run my_test_module.py as a Python script, both print() statements will be executed:

python my_test_module.py

>>> 'This is going to be printed out, no matter what'
>>> 'This is going to be printed out, only if user invokes the module as a script'

---

For a more comprehensive explanation, you can read What does if __name__ == '__main__' do in Python.

Answer 8

All the answers have pretty much explained the functionality. But I will provide one example of its usage which might help clearing out the concept further.

Assume that you have two Python files, a.py and b.py. Now, a.py imports b.py. We run the a.py file, where the import b.py code is executed first. Before the rest of the a.py code runs, the code in the file b.py must run completely.

In the b.py code, there is some code that is exclusive to that file b.py and we don't want any other file (other than the b.py file), that has imported the b.py file, to run it.

So that is what this line of code checks. If it is the main file (i.e., b.py) running the code, which in this case it is not (a.py is the main file running), then only the code gets executed.

Answer 9

If the Python interpreter is running a particular module then the __name__ global variable will have the value "__main__":

def a():
    print("a")

def b():
    print("b")

if __name__ == "__main__":

        print ("you can see me")
        a()
else:

        print ("You can't see me")
        b()

When you run this script, it prints:

you can see me
a

If you import this file, say A to file B, and execute the file B then if __name__ == "__main__" in file A becomes False, so it prints:

You can't see me
b

Answer 10

In simple words:

The code you see under if __name__ == "__main__": will only get called upon when your Python file is executed as python example1.py

However, if you wish to import your Python file example1.py as a module to work with another Python file, say example2.py, the code under if __name__ == "__main__": will not run or take any effect.

Answer 11

What does if __name__ == "__main__": do?

__name__ is a global variable (in Python, global actually means on the module level) that exists in all namespaces. It is typically the module's name (as a str type).

As the only special case, however, in whatever Python process you run, as in mycode.py:

python mycode.py

the otherwise anonymous global namespace is assigned the value of '__main__' to its __name__.

Thus, including the final lines

if __name__ == '__main__':
    main()

• at the end of your mycode.py script,
• when it is the primary, entry-point module that is run by a Python process,

will cause your script's uniquely defined main function to run.

Another benefit of using this construct: you can also import your code as a module in another script and then run the main function if and when your program decides:

import mycode
# ... any amount of other code
mycode.main()

Answer 12

Create the following two files:

# a.py

import b

# b.py

print("__name__ equals " + __name__)

if __name__ == '__main__':
    print("if-statement was executed")

Now run each file individually.

---

Running python a.py:

$ python a.py
__name__ equals b

When a.py is executed, it imports the module b. This causes all the code inside b to run. Python sets globals()['__name__'] in the b module to the module's name, b.

Running python b.py:

$ python b.py
__name__ equals __main__
if-statement was executed

When only the file b.py is executed, Python sets globals()['__name__'] in this file to "__main__". Therefore, the if statement evaluates to True this time.

Answer 13

Only facts you need to know

The other answers to this question are way too long. The actual mechanics are quite simple and there are only two essential facts:

1. Pure Python modules are always created with the variable __name__ set to the string "__main__".

2. Importing a module has the side-effect of changing the __name__ variable to the base filename without the .py extension.

How this information is used

People write __name__ == '__main__' to test whether a module has been imported.

It is common to have some code that shouldn't run when an import occurs: Test code, one-time use code, a command-line front-end, or a web server front-end.

The idea is that person running a module directly wants these actions to happen, but a person importing the module just wants direct access to the functions, classes, and variables.

As you can see from the other answers, people seem to be able to talk endlessly about this topic, but it really is a simple thing and is easily mastered. The Python tutorial covers this in about two minutes worth of reading. Don't let the other answers drown you with overexplaining :-)

Answer 14

Consider:

if __name__ == "__main__":
    main()

It checks if the __name__ attribute of the Python script is "__main__". In other words, if the program itself is executed, the attribute will be __main__, so the program will be executed (in this case the main() function).

However, if your Python script is used by a module, any code outside of the if statement will be executed, so if __name__ == "__main__" is used just to check if the program is used as a module or not, and therefore decides whether to run the code.

Answer 15

If this .py file are imported by other .py files, the code under the if statement will not be executed.

If this .py are run by python this_py.py under shell, or double clicked in Windows. the code under the if statement will be executed.

It is usually written for testing.

Answer 16

The Python main function is the starting point of any program. When the program is run, the Python interpreter runs the code sequentially. The main function is executed only when it is run as a Python program...

def main():
    print("I am in the function")

print("I am out of the function")

when you run the script shows:

I am out of the function

And not the code "I am in the function".

It is because we did not declare the call function "if__name__== "main".

If you use from it:

def main():
    print("I am in the function")

if __name__ == "__main__":
    main()

print("I am out of the function")

The output is equal to

I am in the function
I am out of the function

In Python, if__name__== "__main__" allows you to run the Python files either as reusable modules or stand-alone programs.

When Python interpreter reads a source file, it will execute all the code found in it. When Python runs the "source file" as the main program, it sets the special variable __name__ to have a value "__main__".

When you execute the main function, it will then read the if statement which checks whether __name__ is equal to __main__.

Answer 17

Before explaining anything about if __name__ == '__main__' it is important to understand what __name__ is and what it does.

What is __name__?

__name__ is a DunderAlias - can be thought of as a global variable (accessible from modules) and works in a similar way to global.

It is a string (global as mentioned above) as indicated by type(__name__) (yielding <class 'str'>), and is an inbuilt standard for both Python 3 and Python 2 versions.

Where

It can not only be used in scripts but can also be found in both the interpreter and modules/packages.

Interpreter:

>>> print(__name__)
__main__
>>>

Script:

test_file.py:

print(__name__)

Resulting in __main__

Module or package:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

Resulting in somefile

Notice that when used in a package or module, __name__ takes the name of the file. The path of the actual module or package path is not given, but has its own DunderAlias __file__, that allows for this.

You should see that, where __name__, where it is the main file (or program) will always return __main__, and if it is a module/package, or anything that is running off some other Python script, will return the name of the file where it has originated from.

Practice

Being a variable means that it's value can be overwritten ("can" does not mean "should"), overwriting the value of __name__ will result in a lack of readability. So do not do it, for any reason. If you need a variable define a new variable.

It is always assumed that the value of __name__ to be __main__ or the name of the file. Once again changing this default value will cause more confusion that it will do good, causing problems further down the line.

Example:

>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>

It is considered good practice in general to include the if __name__ == '__main__' in scripts.

Now to answer if __name__ == '__main__':

Now we know the behaviour of __name__ things become clearer:

An if is a flow control statement that contains the block of code will execute if the value given is true. We have seen that __name__ can take either __main__ or the file name it has been imported from.

This means that if __name__ is equal to __main__ then the file must be the main file and must actually be running (or it is the interpreter), not a module or package imported into the script.

If indeed __name__ does take the value of __main__ then whatever is in that block of code will execute.

This tells us that if the file running is the main file (or you are running from the interpreter directly) then that condition must execute. If it is a package then it should not, and the value will not be __main__.

Modules

__name__ can also be used in modules to define the name of a module

Variants

It is also possible to do other, less common but useful things with __name__, some I will show here:

Executing only if the file is a module or package

if __name__ != '__main__':
    # Do some useful things 

Running one condition if the file is the main one and another if it is not

if __name__ == '__main__':
    # Execute something
else:
    # Do some useful things

You can also use it to provide runnable help functions/utilities on packages and modules without the elaborate use of libraries.

It also allows modules to be run from the command line as main scripts, which can be also very useful.

Answer 18

Suppose I wrote functions and classes for web scraping on Wikipedia. Of course, this may not be a good example.

I want to use those functions in another program without rewriting it.

Well, I import them, but at the end of that file I put __name__ == '__main__'

When we import a module, all the code inside it is executed from start to end. But when it reaches the condition, it does not run func, func2, etc., which is the Wikipedia __scrape__.

Well, in the global scope a Python __name__ is defined to '__main__' for the current program.

When we import a module, it is defined as a variable in the name space of our current program and current program __name__ is '__main__':

File test.py

def func():
    # Do something
    pass

def func2():
    # Do something
    pass

print('The program name is set to ', globals()['__name__'])

if __name__=='__main__':
    # In the current program, __name__ is equal to '__main__'
    func('https://www.wikipedia.org')
    func2('https://www.wikipedia.org')
    # Or do more jobs

import test1
print('inside of current program')
print('name is current program', __name__)
print(globals()['test1'])
test1.func('another site')
test1.func2('another site')

Output

inside of test 1
name of program is set to test1
end of module
inside of current
__main__
<module 'test1' from 'C:\\users\\ir\\appdata\\local\\programs\\python\\python38\\lib\\test1.py'>

Answer 19

Every module in Python has a special attribute called __name__. The value of the __name__ attribute is set to '__main__' when the module is executed as the main program (e.g., running python foo.py).

Otherwise, the value of __name__ is set to the name of the module that it was called from.

Answer 20

When a Python file is executed it creates many special variables such as __name__. The variable __name__ holds the name of the file. And the answer to your question is that

if __name__ == "__main__":
       # Do something

This means that if the name of the file being executed is running as the source file and not a module then it will run the code inside it. This can be proved with a simple example. Create two Python files, foo.py and second.py. Then in the foo.py, type this:

if __name__ == "__main__":
       print("file is not imported")
else:
       print("file is imported")

And in the second.py, type this:

import foo

if foo.__name__ == "__main__":
       print("file is not imported")
else:
       print("file is imported")

In addition to this, if you will do this print(__name__) then it will print __main__. Why?

Because the file is running as the main source and if you'll do print(foo.__name__) it will print foo because the default value of the __name__ variable is the name of the file and by default I mean you can change it too. To do this, just go to the foo.py file and do this: __name__ = "name". Then when you'll run the file, for example,

__name__ = "Hello, World!"
print(__name__)

then the output will be:

Hello, World!

Answer 21

You can check up on the special variable __name__ with this simple example:

Create file1.py

if __name__ == "__main__":
    print("file1 is being run directly")
else:
    print("file1 is being imported")

Create *file2.py

import file1 as f1

print("__name__ from file1: {}".format(f1.__name__))
print("__name__ from file2: {}".format(__name__))

if __name__ == "__main__":
    print("file2 is being run directly")
else:
    print("file2 is being imported")

Execute file2.py

Output:

file1 is being imported
__name__ from file1: file1
__name__ from file2: __main__
file2 is being run directly

Answer 22

Every module in Python has an attribute called __name__. The value of __name__ attribute is __main__ when the module is run directly, like python my_module.py. Otherwise (like when you say import my_module) the value of __name__ is the name of the module.

Small example to explain in short.

Script test.py

apple = 42

def hello_world():
    print("I am inside hello_world")

if __name__ == "__main__":
    print("Value of __name__ is: ", __name__)
    print("Going to call hello_world")
    hello_world()

We can execute this directly as

python test.py

Output

Value of __name__ is: __main__
Going to call hello_world
I am inside hello_world

Now suppose we call the above script from another script:

Script external_calling.py

import test

print(test.apple)
test.hello_world()

print(test.__name__)

When you execute this,

python external_calling.py

Output

42
I am inside hello_world
test

So, the above is self-explanatory that when you call test from another script, if loop __name__ in test.py will not execute.

Answer 23

To be short, you need to know several points:

1. import a action actually runs all that can be run in a.py, meaning each line in a.py

2. Because of point 1, you may not want everything to be run in a.py when importing it

3. To solve the problem in point 2, Python allows you to use a condition check

4. __name__ is an implicit variable in all .py modules:

• when a.py is imported, the value of __name__ of a.py module is set to its file name "a"
• when a.py is run directly using "python a.py", the value of __name__ is set to a string __main__

5. Based on the mechanism how Python sets the variable __name__ for each module, do you know how to achieve point 3? The answer is fairly easy, right? Use an if condition: if __name__ == "__main__": // do A

• then python a.py will run the part // do A
• and import a will skip the part // do A

6. You can even put if __name__ == "a" depending on your functional need, but rarely do

The important thing that Python is special at is point 4! The rest is just basic logic.

_{I've been reading so much throughout the answers on this page. I would say, if you know the thing, for sure you will understand those answers, otherwise, you are still confused.}

Answer 24

It is a special for when a Python file is called from the command line. This is typically used to call a "main()" function or execute other appropriate startup code, like commandline arguments handling for instance.

It could be written in several ways. Another is:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

I am not saying you should use this in production code, but it serves to illustrate that there is nothing "magical" about if __name__ == '__main__'.

It just a convention for invoking a main function in Python files.

Answer 25

Let's look at the answer in a more abstract way:

Suppose we have this code in x.py:

...
<Block A>
if __name__ == '__main__':
    <Block B>
...

Blocks A and B are run when we are running x.py.

But just block A (and not B) is run when we are running another module, y.py for example, in which x.py is imported and the code is run from there (like when a function in x.py is called from y.py).

Answer 26

Consider:

print __name__

The output for the above is __main__.

if __name__ == "__main__":
  print "direct method"

The above statement is true and prints "direct method". Suppose if they imported this class in another class it doesn't print "direct method" because, while importing, it will set __name__ equal to "first model name".

Answer 27

This answer is for Java programmers learning Python. Every Java file typically contains one public class. You can use that class in two ways:

1. Call the class from other files. You just have to import it in the calling program.

2. Run the class stand alone, for testing purposes.

For the latter case, the class should contain a public static void main() method. In Python this purpose is served by the globally defined label '__main__'.

Answer 28

Create a file, a.py:

print(__name__) # It will print out __main__

__name__ is always equal to __main__ whenever that file is run directly showing that this is the main file.

Create another file, b.py, in the same directory:

import a  # Prints a

Run it. It will print a, i.e., the name of the file which is imported.

So, to show two different behavior of the same file, this is a commonly used trick:

# Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly

Answer 29

I think it's best to break the answer in depth and in simple words:

__name__: Every module in Python has a special attribute called __name__. It is a built-in variable that returns the name of the module.

__main__: Like other programming languages, Python too has an execution entry point, i.e., main. '__main__' is the name of the scope in which top-level code executes. Basically you have two ways of using a Python module: Run it directly as a script, or import it. When a module is run as a script, its __name__ is set to __main__.

Thus, the value of the __name__ attribute is set to __main__ when the module is run as the main program. Otherwise the value of __name__ is set to contain the name of the module.

Answer 30

There are lots of different takes here on the mechanics of the code in question, the "How", but for me none of it made sense until I understood the "Why". This should be especially helpful for new programmers.

Take file "ab.py":

def a():
    print('A function in ab file');
a()

And a second file "xy.py":

import ab
def main():
    print('main function: this is where the action is')
def x():
    print ('peripheral task: might be useful in other projects')
x()
if __name__ == "__main__":
    main()

What is this code actually doing?

When you execute xy.py, you import ab. The import statement runs the module immediately on import, so ab's operations get executed before the remainder of xy's. Once finished with ab, it continues with xy.

The interpreter keeps track of which scripts are running with __name__. When you run a script - no matter what you've named it - the interpreter calls it "__main__", making it the master or 'home' script that gets returned to after running an external script.

Any other script that's called from this "__main__" script is assigned its filename as its __name__ (e.g., __name__ == "ab.py"). Hence, the line if __name__ == "__main__": is the interpreter's test to determine if it's interpreting/parsing the 'home' script that was initially executed, or if it's temporarily peeking into another (external) script. This gives the programmer flexibility to have the script behave differently if it's executed directly vs. called externally.

Let's step through the above code to understand what's happening, focusing first on the unindented lines and the order they appear in the scripts. Remember that function - or def - blocks don't do anything by themselves until they're called. What the interpreter might say if mumbled to itself:

• Open xy.py as the 'home' file; call it "__main__" in the __name__ variable.
• Import and open file with the __name__ == "ab.py".
• Oh, a function. I'll remember that.
• Ok, function a(); I just learned that. Printing 'A function in ab file'.
• End of file; back to "__main__"!
• Oh, a function. I'll remember that.
• Another one.
• Function x(); ok, printing 'peripheral task: might be useful in other projects'.
• What's this? An if statement. Well, the condition has been met (the variable __name__ has been set to "__main__"), so I'll enter the main() function and print 'main function: this is where the action is'.

The bottom two lines mean: "If this is the "__main__" or 'home' script, execute the function called main()". That's why you'll see a def main(): block up top, which contains the main flow of the script's functionality.

Why implement this?

Remember what I said earlier about import statements? When you import a module it doesn't just 'recognize' it and wait for further instructions - it actually runs all the executable operations contained within the script. So, putting the meat of your script into the main() function effectively quarantines it, putting it in isolation so that it won't immediately run when imported by another script.

Again, there will be exceptions, but common practice is that main() doesn't usually get called externally. So you may be wondering one more thing: if we're not calling main(), why are we calling the script at all? It's because many people structure their scripts with standalone functions that are built to be run independent of the rest of the code in the file. They're then later called somewhere else in the body of the script. Which brings me to this:

But the code works without it

Yes, that's right. These separate functions can be called from an in-line script that's not contained inside a main() function. If you're accustomed (as I am, in my early learning stages of programming) to building in-line scripts that do exactly what you need, and you'll try to figure it out again if you ever need that operation again ... well, you're not used to this kind of internal structure to your code, because it's more complicated to build and it's not as intuitive to read.

But that's a script that probably can't have its functions called externally, because if it did it would immediately start calculating and assigning variables. And chances are if you're trying to re-use a function, your new script is related closely enough to the old one that there will be conflicting variables.

In splitting out independent functions, you gain the ability to re-use your previous work by calling them into another script. For example, "example.py" might import "xy.py" and call x(), making use of the 'x' function from "xy.py". (Maybe it's capitalizing the third word of a given text string; creating a NumPy array from a list of numbers and squaring them; or detrending a 3D surface. The possibilities are limitless.)

(As an aside, this question contains an answer by @kindall that finally helped me to understand - the why, not the how. Unfortunately it's been marked as a duplicate of this one, which I think is a mistake.)