如果__name__ ==“__main__”：做什么？
if __name__ == "__main__":做什么？
# Threading example import time, thread def myfunction(string, sleeptime, lock, *args): while 1: lock.acquire() time.sleep(sleeptime) lock.release() time.sleep(sleeptime) if __name__ == "__main__": lock = thread.allocate_lock() thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock)) thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
当Python解释器读取源文件时，它会执行所有在其中find的代码。
在执行代码之前，它会定义一些特殊的variables。 例如，如果python解释器正在将该模块（源文件）作为主程序运行，则会将特殊的__name__variables设置为"__main__" 。 如果这个文件是从另一个模块导入的， __name__将被设置为模块的名字。
在你的脚本的情况下，让我们假设它正在执行作为主要function，例如你说了类似的东西
python threading_example.py
在命令行上。 设置特殊variables后，将执行import语句并加载这些模块。 然后，它将评估def块，创build一个函数对象并创build一个名为myfunction的variables，指向函数对象。 然后读取if语句，看看__name__是否等于"__main__" ，所以会执行那里显示的块。
这样做的一个原因是，有时你写一个模块（一个.py文件），它可以直接执行。 或者，也可以导入并在其他模块中使用。 通过执行主要的检查，你可以让代码只在你想运行模块作为程序时执行，而当某人只是想导入你的模块并自己调用你的函数时，不要执行它。
看到这个页面的一些额外的细节。
当您的脚本通过将其作为命令传递给Python解释器来运行时，
python myscript.py
所有在缩进级别0的代码都被执行。 被定义的函数和类已经被定义好了，但是他们的代码没有被运行。 与其他语言不同，没有main()函数可以自动运行 – main()函数隐含在顶层的所有代码中。
在这种情况下，顶级代码是一个if块。 __name__是一个内置variables，用于计算当前模块的名称。 但是，如果一个模块正在直接运行（如上面的myscript.py ），则__name__被设置为string"__main__" 。 因此，您可以testing您的脚本是否正在直接运行，或者正在通过testing进行其他操作
if __name__ == "__main__": ...
如果你的脚本被导入到另一个模块中，它的各种函数和类定义将被导入，并且它的顶层代码将被执行，但是if子句的then-body中的代码将不会作为条件运行不符合。 作为一个基本的例子，考虑以下两个脚本：
# file one.py def func(): print("func() in one.py") print("top-level in one.py") if __name__ == "__main__": print("one.py is being run directly") else: print("one.py is being imported into another module")
# file two.py import one print("top-level in two.py") one.func() if __name__ == "__main__": print("two.py is being run directly") else: print("two.py is being imported into another module")
现在，如果你调用解释器
python one.py
输出将是
top-level in one.py one.py is being run directly
如果你运行two.py而不是：
python two.py
你得到
top-level in one.py one.py is being imported into another module top-level in two.py func() in one.py two.py is being run directly
因此，当模块被加载时，它的__name__等于"one"而不是__main__ 。
__name__variables（imho）最简单的解释如下：
创build以下文件。
# a.py import b
和
# b.py print "Hello World from %s!" % __name__ if __name__ == '__main__': print "Hello World again from %s!" % __name__
运行它们会得到这个输出：
$ python a.py Hello World from b!
正如你所看到的，当一个模块被导入时，Python在这个模块globals()['__name__']设置为模块的名字。
$ python b.py Hello World from __main__! Hello World again from __main__!
正如你所看到的，当一个文件被执行时，Python在这个文件globals()['__name__']为"__main__" 。
if __name__ == "__main__":做什么？
作为程序入口点的模块中的全局variables__name__是'__main__' 。
所以， if块中的代码只在该模块是程序的入口点时才会运行。
我们为什么需要这个？
开发和testing你的代码
假设你正在编写一个Python脚本来devise用作模块：
def do_important(): """This function does something very important"""
您可以通过将该函数的这个调用添加到底部来testing该模块：
do_important()
并运行它（在命令提示符），如下所示：
~$ python important.py
问题
但是，如果要将模块导入到另一个脚本中：
import important
在导入时， do_important函数会被调用，所以你可能会在底部注释掉你的函数调用。 然后你必须记住你是否已经把你的testing函数调用注释掉了。 而这额外的复杂性意味着你可能会忘记，使你的开发过程更麻烦。
一个更好的方法
__name__variables指向Python解释器恰好在此刻的名称空间。 在导入的模块中，它是该模块的名称。 但是在主模块（或交互式Python会话，即解释器的Read，Eval，Print Loop或REPL）中，您正在运行"__main__" 。
所以如果你在执行前检查：
if __name__ == "__main__": do_important()
通过上面的代码，只有当你运行它作为主模块时（或者有意从另一个脚本调用它），代码才会被执行。
更好的方式
尽pipe如此，Pythonic还是有改进的地方。
如果我们想从模块外部运行这个业务stream程呢？ 如果我们把这些代码放在我们开发和testing的代码中，然后在下面的代码中立即检查'__main__' ：
def main(): """business logic for when running this module as the primary one!""" setup() foo = do_important() bar = do_even_more_important(foo) for baz in bar: do_super_important(baz) teardown() # Here's our payoff idiom! if __name__ == '__main__': main()
如果我们将模块作为主模块运行，那么我们现在有一个最终的模块结束function。 它将允许将模块及其函数和类导入到其他脚本中，而无需运行main函数，并且还允许在从另一个'__main__'模块运行时调用模块（及其函数和类），即
import important important.main()
这个习惯用法也可以在Python文档中find__main__模块的解释。 该文指出：
该模块代表解释器的主程序执行的（否则是匿名的）作用域 – 从标准input，脚本文件或交互式提示中读取命令。 正是这种惯用的“条件脚本”节导致脚本运行的环境：
if __name__ == '__main__': main()
if __name__ == "__main__"是脚本从命令行（比如说python myscript.py ）运行时运行的部分。
if __name__ == "__main__":做什么？
__name__是一个全局variables（在Python中，全局实际上是指在模块级别上 ），它存在于所有名称空间中。 它通常是模块的名称（作为一个strtypes）。
然而，作为唯一的特殊情况，无论你在哪个Python进程中运行，就像在mycode.py中一样：
python mycode.py
否则匿名的全局命名空间被赋予'__main__'的值给它的__name__ 。
因此，包括最后一行
if __name__ == '__main__': main()
- 在mycode.py脚本的最后，
- 当它是由Python进程运行的主要入口点模块时，
将导致脚本的唯一定义的main函数运行。
使用这个结构的另一个好处是：你也可以将你的代码作为一个模块导入到另一个脚本中，然后在程序决定的时候运行main函数：
import mycode # ... any amount of other code mycode.main()
当我们的模块（ M.py ）中有某些语句的M.py ，我们希望当它作为main（不导入）运行的时候被执行，那么我们可以把这些语句（testing用例，打印语句）放在这个下面如果阻塞。 默认情况下（当模块作为main运行，不导入）， __name__variables被设置为"__main__" ，当它被导入时， __name__variables会得到一个不同的值，最有可能的是模块的名字（ 'M' ）。 这有助于将模块的不同变体运行在一起，并分离出特定的input和输出语句以及任何testing用例。
简而言之 ，使用这个“ if __name__ == "main" ”块来防止（某些）代码在模块导入时运行。
让我们以更抽象的方式来看待答案：
假设我们在x.py中有这个代码：
... <Block A> if __name__ == '__main__': <Block B> ...
当我们运行“x.py”时，块A和B运行。
但是，当我们运行另一个模块“y.py”时，只运行阻塞A（而不是B），其中xy被导入，并从那里运行代码（就像“x.py”中的函数是从y.py调用）。
当你交互地运行Python时，本地的__name__variables被分配了__main__的值。 同样，当你从命令行执行一个Python模块，而不是将其导入到另一个模块中时，它的__name__属性被赋值为__main__ ，而不是模块的实际名称。 通过这种方式，模块可以查看自己的__name__值来自行确定如何使用它们，无论是作为对另一个程序的支持还是作为从命令行执行的主要应用程序。 因此，下面的习惯用法在Python模块中很常见：
if __name__ == '__main__': # Do something appropriate here, like calling a # main() function defined elsewhere in this module. main() else: # Do nothing. This module has been imported by another # module that wants to make use of the functions, # classes and other useful bits it has defined.
这里有很多不同的关于代码机制的问题，“如何”，但是对我来说，直到我理解了“为什么”之前，没有任何意义。 这应该对新程序员特别有用。
以这个例子：
文件“ab.py”：
def a(): print('A function in ab file'); a()
第二个文件“xy.py”：
import ab def main(): print('main function') def x(): print ('s') x() if __name__ == "__main__": main()
这段代码实际在做什么？
当你执行xy.py时，你导入ab 。 import语句在导入时立即运行模块，所以ab的操作在xy的剩余部分之前被执行。 一旦完成了ab，它继续xy。
解释器会跟踪哪些脚本正在运行__name__ 。 当你运行一个脚本 – 不pipe你命名了什么 – 解释器将其称为"__main__" 。 这就是如何跟踪哪个脚本是主文件，在外部调用另一个脚本后返回的脚本。 （可能会说'home'脚本。）从这个'main'脚本调用的任何其他脚本被指定为__name__文件名。 因此， if __name__ == "__main__":是解释器的testing，以确定它是否正在它正在查看（parsing）的脚本上运行，或者它是否暂时偷看到另一个脚本中。 这使程序员可以灵活地使脚本在外部调用时的行为不同。
要了解发生了什么，请首先关注不显示的行和脚本中出现的顺序。 记住函数或者def块在被调用之前不会自己做任何事情。 口译员如果自言自语，可能会怎么想：
- 打开xy.py. 好的，xy.py是'home'文件; 这意味着它在
__name__variables中被称为"__main__"。 - 使用
__name__ab.py导入并打开文件。 - 哦，一个function。 我会记住的。
- 好的，函数a（）; 我刚刚了解到 我想我现在打印。
- 文件结束; 回到
"__main__"！ - 哦，一个function。 我会记住的。
- 另一个。
- 函数x（）; 好吧，打印'。
- 这是什么？ 一个
if语句。 那么，条件已经满足（variables__name__已被设置为"__main__"），所以我将进入main()函数并打印“主函数”。
底部的两行意味着：“如果这是'main'或home脚本，执行名为main()的函数，这就是为什么你会看到一个def main(): block up top，它包含脚本的主要stream程function。
为什么执行这个？
还记得我之前提到的关于import报表吗？ 当你导入一个模块时，它不会“识别”它，并等待进一步的指令 – 它实际上运行脚本中包含的所有可执行操作。 因此，将脚本的内容放入main()函数中会有效隔离它，并将其隔离，以便在被另一个脚本导入时不会立即运行。
再次，会有例外，但通常的做法是main()通常不会被外部调用。 所以你可能还有一个疑问：如果我们不调用main() ，为什么我们调用脚本呢？ 这是因为许多人用自己构build的独立函数来构build脚本。 然后他们在剧本的其他地方被调用。 这使我感到：
但代码工作没有它
恩，那就对了。 这些单独的函数可以通过一个不包含在main()函数中的内联脚本来调用。 如果你习惯于（正如我在编程的早期学习阶段）build立内联脚本来完成你所需要的内容，那么如果你再次需要这个操作的话，你将会尝试去找出它。嗯，你不习惯这种内部结构的代码，因为它更复杂的构build，它不是直观的阅读。 但是，这是一个脚本，可能不能从外部调用它的函数，因为如果这样做，它将开始计算和分配variables。 如果你试图重用一个函数，那么很可能你的新脚本与旧脚本的关系足够紧密，以至于可能存在相互冲突的variables。
我应该在旁边说， 这个线程包含@kindall的答案，最终帮助我理解 – 为什么，而不是如何。 不幸的是，它被标记为这个的重复，我认为这是一个错误。
简单地说， __name__是为每个脚本定义的variables，它定义脚本是作为主模块运行，还是作为导入模块运行。
所以如果我们有两个脚本
#script1.py print "Script 1's name: {}".format(__name__)
和;
#script2.py import script1 print "Script 2's name: {}".format(__name__)
执行script1的输出是;
Script 1's name: __main__
并执行script2的输出是;
Script1's name is script1 Script 2's name: __main__
如你看到的; __name__告诉我们哪个代码是'main'模块。 这很好，因为你可以编写代码而不必担心像C / C ++这样的结构性问题，如果一个文件没有实现一个“main”函数，那么它就不能被编译成可执行文件，如果这样做的话，不能作为图书馆使用。
假设你编写了一个很好的python脚本，并且实现了一堆对其他用途有用的函数，如果我想使用它们，我只需导入你的脚本并在不执行程序的情况下使用它（假设你的代码只执行在if __name__ == "__main__": context）内。 而在C / C ++中，你将不得不把这些部分分成一个单独的模块，然后包含该文件。 想象一下下面的情况。
箭头是导入链接。 对于每个试图包含以前模块代码的三个模块，都有六个文件（九个，计算实现文件）和五个链接，这使得很难将其他代码包含到ac项目中，除非它被专门编译为库。 现在来看看它的python;
你写了一个模块，如果有人想利用你的代码，他们只需要导入它， __name__variables可以帮助分离程序的库部分的可执行部分。
当从命令行调用Python文件时，它是一个特殊的选项。 这通常用于调用“main（）”函数或执行其他适当的启动代码，例如处理命令行参数。
它可以用几种方式写，另一个是：
def main(): dosomething() __name__ == '__main__' and main()
我并不是说你应该在生产代码中使用它，但是它可以说明if __name__ == '__main__'没有什么“神奇的”。 这是一个在Python文件中调用主函数的（很棒的）惯例。
系统（Python解释器）为源文件（模块）提供了许多variables。 你可以随时获得他们的值，所以，让我们把注意力放在__name__variables/属性上：
当Python加载源代码文件时，它会执行所有在其中find的代码。 （请注意，它不调用文件中定义的所有方法和函数，但它确实定义了它们。）
在解释器执行源代码文件之前，它为该文件定义了一些特殊variables; __name__是Python自动为每个源代码文件定义的特殊variables之一。
如果Python正在加载这个源代码文件作为主程序（也就是你运行的文件），那么它会为这个文件设置一个特殊的__name__variables来为其赋值“__main__” 。
如果这是从另一个模块导入的， __name__将被设置为该模块的名称。
所以，在你的例子中，
if __name__ == "__main__": lock = thread.allocate_lock() thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock)) thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
意味着代码块：
lock = thread.allocate_lock() thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock)) thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
只有在直接运行模块时才会执行; 如果另一个模块正在调用/导入它，代码块将不会执行，因为__name__的值在该特定实例中不等于“ main ”。
希望这有助于。
if __name__ == "__main__": main()
检查python脚本的__name__属性是否为“__main__”。 换句话说，如果程序本身被执行，属性将是__main__，所以程序将被执行（在这种情况下是main（）函数）。
但是，如果您的python脚本被模块使用，if语句之外的任何代码都将被执行，所以如果仅仅使用__name__ ==“__main__”来检查程序是否被用作模块，并且因此决定是否运行代码。
如果__name__ ==“__main__”：基本上是顶级脚本环境，则指定解释器（'我具有最高优先级，首先执行'）。
'__main__ '是顶层代码执行的范围的名称。 从标准input，脚本或交互式提示读取时，模块的名称设置为“ main ”。
if __name__ == "__main__": # execute only if run as a script main()
我认为最好是以深入的和简单的语言来打破答案：
__name__ ：Python中的每个模块都有一个名为__name__的特殊属性。 这是一个内置的variables，返回模块的名称。
__main__ ：与其他编程语言一样，Python也有一个执行入口点，即main。 ' main ' 是顶层代码执行的范围的名称。 基本上你有两种使用Python模块的方法：直接作为脚本运行，或者导入它。 当一个模块作为脚本运行时，它的__name__被设置为__main__ 。
因此，当模块作为主程序运行时， __name__属性的值被设置为__main__ 。 否则， __name__的值被设置为包含模块的名称。
print __name__
以上输出为主
if __name == "__main__": print direct method
上面的语句是得到真实和打印直接的方法假设如果他们在其他类中导入这个类它不打印直接的方法。因为当导入它将设置__name__ == "firstmodel name"
您可以使文件可用作脚本以及可导入的模块 。
fibo.py（一个名为fibo的模块）
# Other modules can IMPORT this MODULE to use the function fib def fib(n): # write Fibonacci series up to n a, b = 0, 1 while b < n: print(b, end=' ') a, b = b, a+b print() # This allows the file to be used as a SCRIPT if __name__ == "__main__": import sys fib(int(sys.argv[1]))
参考： https ： //docs.python.org/3.5/tutorial/modules.html
的原因
if __name__ == "__main__": main()
主要是为了避免直接导入代码导致的导入锁问题。
副作用是您自动login支持多个入口点的方法。
