if __name__ == "__main__":什么作用？

# Threading example
import time, threaddef myfunction(string, sleeptime, lock, *args):while True: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))

#1楼

这是从命令行调用Python文件时的特殊功能。通常用于调用“ main（）”函数或执行其他适当的启动代码，例如命令行参数处理。

它可以用几种方式编写。另一个是：

def some_function_for_instance_main():dosomething()__name__ == '__main__' and some_function_for_instance_main()

我并不是说您应该在生产代码中使用它，但这只是为了说明if __name__ == '__main__'并没有什么“魔术”。在Python文件中调用主函数是一个很好的约定。

#2楼

当我们的模块（ M.py ）中有某些语句要在作为主模块运行（不导入）时执行时，可以将这些语句（测试用例，打印语句）放在if块下面。

默认情况下（当模块作为主模块运行而不是导入时）， __name__变量设置为"__main__" ，并且在导入时， __name__变量将获得不同的值，很可能是模块的名称（ 'M' ）。这有助于一起运行模块的不同变体，分离其特定的输入和输出语句，以及是否存在测试用例。

简而言之 ，使用此' if __name__ == "main" '块可防止在导入模块时运行（某些）代码。

#3楼

if __name__ == "__main__":什么作用？

概述基础知识：

作为程序入口点的模块中的全局变量__name__是'__main__' 。否则，这就是您导入模块的名称。
因此，仅当模块是程序的入口点时， if块下的代码才会运行。
它允许模块中的代码可由其他模块导入，而无需在导入时执行下面的代码块。

我们为什么需要这个？

开发和测试您的代码

假设您正在编写旨在用作模块的Python脚本：

def do_important():"""This function does something very important"""

您可以通过在底部添加此函数调用来测试模块：

do_important()

并使用以下命令运行它（在命令提示符下）：

~$ python important.py

问题

但是，如果要将模块导入到另一个脚本：

import important

导入时，将调用do_important函数，因此您可能会在底部注释掉函数调用do_important() 。

# do_important() # I must remember to uncomment to execute this!

然后，您必须记住是否已注释掉测试函数调用。这种额外的复杂性将意味着您可能会忘记，从而使您的开发过程更加麻烦。

更好的方法

__name__变量指向当前Python解释器所在的名称空间。

在导入的模块中，它是该模块的名称。

但是在主模块（或交互式Python会话，即解释器的Read，Eval，Print Loop或REPL）内部，您正在运行其"__main__" 。

因此，如果您在执行之前进行检查：

if __name__ == "__main__":do_important()

有了以上内容，您的代码将仅在以主模块运行（或从另一个脚本有意调用）时执行。

更好的方法

不过，有一种Python方式可以对此进行改进。

如果我们想从模块外部运行此业务流程怎么办？

如果将代码放在我们想要在开发和测试这样的函数时使用的代码，然后在执行以下操作后立即检查'__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()

现在，我们在模块末尾具有最终功能，如果我们将模块作为主要模块运行，则该功能将运行。

它将允许在不运行main函数的情况下将模块及其功能和类导入其他脚本，并且还允许在从其他'__main__'模块运行时调用模块（及其功能和类），即

import important
important.main()

这个惯用法也可以在Python文档中的__main__模块的说明中找到。该文本指出：

此模块表示解释程序的主程序在其中执行的（否则为匿名）范围-从标准输入，脚本文件或交互式提示中读取的命令。在这种环境中，惯用的“条件脚本”节使脚本运行：
 if __name__ == '__main__': main() 

#4楼

交互式运行Python时，将为本地__name__变量分配__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.

#5楼

if __name__ == "__main__":怎么办？

__name__是一个存在于所有命名空间中的全局变量（在Python中，global实际上是在模块级别上表示）。它通常是模块的名称（作为str类型）。

但是，作为唯一的特殊情况，无论您运行什么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()

#6楼

让我们以更抽象的方式看一下答案：

假设我们在x.py中有以下代码：

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

当我们运行“ x.py”时，将运行块A和B。

但是，当我们运行另一个模块（例如“ y.py”）时，仅运行块A（而不运行B），其中导入了xy并从那里运行代码（例如，当“ x.py”中的函数由y.py调用）。

#7楼

系统（Python解释器）为源文件（模块）提供了许多变量。您可以随时获取它们的值，因此，让我们关注__name__变量/属性：

当Python加载源代码文件时，它将执行在其中找到的所有代码。（请注意，它不会调用文件中定义的所有方法和函数，但会定义它们。）

但是，在解释器执行源代码文件之前，它会为该文件定义一些特殊的变量。 __name__是Python为每个源代码文件自动定义的那些特殊变量之一。

如果Python将此源代码文件作为主程序（即您运行的文件）加载，则它将为此文件设置特殊的__name__变量，使其具有值“ __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 ”。

希望这会有所帮助。

#8楼

if __name__ == "__main__":基本上是顶级脚本环境，并且它指定解释器（“我具有首先执行的最高优先级”）。

'__main__'是顶级代码在其中执行的作用域的名称。从标准输入，脚本或交互式提示中读取时，模块的__name__设置等于'__main__' 。

if __name__ == "__main__":# Execute only if run as a scriptmain()

#9楼

考虑：

print __name__

上面的输出是__main__ 。

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

上面的陈述是正确的，并显示“ direct method” 。假设他们在另一个类中导入了该类，则不会打印“直接方法”，因为在导入时，它将设置__name__ equal to "first model name" 。

#10楼

在这里，有关代码的“如何”的机制有很多不同的看法，但是对我来说，直到我理解了“为什么”之后，才有意义。这对新程序员特别有用。

取得文件“ ab.py”：

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

还有第二个文件“ 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()

这段代码实际上在做什么？

执行xy.py ， import ab 。 import语句在导入时立即运行模块，因此ab的操作要在xy的其余部分之前执行。用ab完成后，以xy继续。

解释器使用__name__跟踪正在运行的脚本。当您运行脚本时（无论您使用什么名称），解释器都将其称为"__main__" ，从而使其成为运行外部脚本后返回的主脚本或“主”脚本。

从此"__main__"脚本调用的任何其他脚本都将其文件名分配为其__name__ （例如__name__ == "ab.py" ）。因此， if __name__ == "__main__":是解释程序的测试，以确定它是否正在解释/解析最初执行的“ home”脚本，或者它是否正在临时窥视另一个（外部）脚本。这使程序员可以灵活地让脚本在直接执行与在外部执行之间有所不同。

让我们逐步看一下上面的代码，以了解发生了什么，首先关注未缩进的行及其在脚本中出现的顺序。请记住，函数或def块在被调用之前不会自行执行任何操作。如果自言自语，口译员可能会说：

打开xy.py作为“主”文件；在__name__变量中将其称为"__main__" 。
导入并使用__name__ == "ab.py"打开文件。
哦，有功能。我会记住的。
好的，函数a() ; 我才知道打印' ab文件中的函数 '。
文件结尾；回到"__main__" ！
哦，有功能。我会记住的。
另一个。
函数x() ; 好，打印“ 外围任务：可能在其他项目中有用 ”。
这是什么？一个if语句。好了，条件已经得到满足（变量__name__已设置为"__main__" ），所以我将输入main()函数并输出' main函数：这是操作所在 。

最后两行表示：“如果这是"__main__"或'home'脚本，则执行名为main()的函数。这就是为什么您会看到def main():顶部阻塞的原因，其中包含脚本功能的主要流程。

为什么要实施呢？

还记得我之前说的有关导入语句的内容吗？导入模块时，它不仅会“识别”它并等待进一步的指令-实际上会运行脚本中包含的所有可执行操作。因此，将脚本的内容放入main()函数中可以有效地隔离它，将其隔离，以便在被另一个脚本导入时不会立即运行。

同样，会有例外，但是通常的做法是main()通常不从外部调用。因此，您可能想知道又一件事：如果我们不调用main() ，为什么还要调用脚本呢？这是因为许多人使用独立的函数来构造脚本，这些独立的函数旨在独立于文件中的其余代码运行。然后在脚本正文中的其他位置调用它们。这使我想到了这一点：

但是代码没有它就可以工作

是的，这是正确的。这些单独的函数可以从main()函数中未包含的嵌入式脚本中调用。如果您习惯了（就像我在编程的早期学习阶段一样）构建可以完全满足您需要的内联脚本，并且如果您再次需要该操作，那么您将尝试再次找出它。嗯，您不习惯这种代码的内部结构，因为它的构建更加复杂并且阅读起来也不那么直观。

但这是一个脚本，可能无法从外部调用其功能，因为如果执行该脚本，它将立即开始计算和分配变量。而且，如果您想重用某个功能，则新脚本与旧脚本的关联性可能会很高，以至于变量会冲突。

在拆分独立功能时，您可以通过将其调用到另一个脚本中来重用以前的工作。例如，“ example.py”可能会导入“ xy.py”并调用x() ，从而利用“ xy.py”中的“ x”功能。（也许是将给定文本字符串的第三个单词大写；从数字列表中创建一个NumPy数组并对其进行平方；或者对3D表面进行趋势处理。这种可能性是无限的。）

（顺便说一句，这个问题包含@kindall的答案，它最终帮助我理解了-原因，而不是方法。不幸的是，它被标记为与此副本的副本，我认为这是错误的。）

#11楼

简而言之， __name__是为每个脚本定义的变量，用于定义脚本是作为主模块运行还是作为导入模块运行。

因此，如果我们有两个脚本；

#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__告诉我们哪个代码是“主”模块。这很棒，因为您只需编写代码，而不必担心C / C ++中的结构性问题，在这种情况下，如果文件未实现“ main”功能，则无法将其编译为可执行文件，如果可以，然后它不能用作库。

假设您编写的Python脚本功能出色，并实现了许多对其他用途有用的功能。如果我要使用它们，我可以导入您的脚本并使用它们而不执行程序（假设您的代码仅在if __name__ == "__main__":上下文中执行）。而在C / C ++中，您将必须将这些部分分成一个单独的模块，然后再包含文件。如下图所示；

箭头是导入链接。对于三个试图包含先前模块代码的模块，有六个文件（九个，计算实现文件）和五个链接。除非将其专门编译为库，否则很难将其他代码包含到C项目中。现在将其描述为适用于Python：

您编写了一个模块，如果有人想使用您的代码，他们只需导入它， __name__变量可以帮助将程序的可执行部分与库部分分开。

#12楼

我认为最好是深入浅出的答案：

__name__ ：Python中的每个模块都有一个名为__name__的特殊属性。它是一个内置变量，返回模块的名称。

__main__ ：和其他编程语言一样，Python也有一个执行入口点，即main。 '__main__' 是执行顶级代码的作用域的名称 。基本上，您有两种使用Python模块的方式：直接将其作为脚本运行，或将其导入。当模块作为脚本运行时，其__name__设置为__main__ 。

因此，当模块作为主程序运行时， __name__属性的值设置为__main__ 。否则， __name__的值将设置为包含模块的名称。

#13楼

if __name__ == "__main__"是使用（例如） python myscript.py类的命令从命令行运行脚本时运行的部分。

#14楼

每当Python解释器读取源文件时，它都会做两件事：

它设置了一些特殊变量，例如__name__ ，然后
它执行文件中找到的所有代码。

让我们看看它是如何工作的，以及它与您在Python脚本中经常看到的有关__name__检查的问题之间的__name__ 。

代码样例

让我们使用稍微不同的代码示例来探索导入和脚本的工作方式。假设以下内容位于名为foo.py的文件中。

# Suppose this is foo.py.print("before import")
import mathprint("before functionA")
def functionA():print("Function A")print("before functionB")
def functionB():print("Function B {}".format(math.sqrt(100)))print("before __name__ guard")
if __name__ == '__main__':functionA()functionB()
print("after __name__ guard")

特殊变量

当Python交互程序读取源文件时，它首先定义一些特殊变量。在这种情况下，我们关心的是__name__变量。

当您的模块是主程序时

如果您将模块（源文件）作为主程序运行，例如

python foo.py

解释器将硬编码字符串"__main__"分配给__name__变量，即

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

当您的模块由另一个导入时

另一方面，假设其他模块是主程序，并且它将导入您的模块。这意味着在主程序中或主程序导入的某些其他模块中有这样的语句：

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

在这种情况下，解释器将查看模块的文件名foo.py ，剥离.py ，然后将该字符串分配给模块的__name__变量，即

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

执行模块的代码

设置特殊变量后，解释器一次执行一个语句，执行模块中的所有代码。您可能想要在代码示例侧面打开另一个窗口，以便您可以按照以下说明进行操作。

总是

它输出字符串"before import" （不带引号）。
它加载math模块并将其分配给名为math的变量。这等效于将import math替换为以下内容（请注意， __import__是Python中的低级函数，它接受字符串并触发实际的导入）：

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

它打印字符串"before functionA" 。
它执行def块，创建一个功能对象，然后将该功能对象分配给一个名为functionA的变量。
它输出字符串"before functionB" 。
它执行第二个def块，创建另一个功能对象，然后将其分配给名为functionB的变量。
它输出字符串"before __name__ guard" 。

仅当您的模块是主程序时

如果您的模块是主程序，那么它将看到__name__确实设置为"__main__"并且它将调用两个函数，分别打印字符串"Function A"和"Function B 10.0" 。

仅当您的模块由另一个导入时

（相反）如果您的模块不是主程序而是由另一个程序导入的，则__name__将为"foo" ，而不是"__main__" ，它将跳过if语句的主体。

总是

在两种情况下，它将在"after __name__ guard"打印字符串。

摘要

总而言之，这是两种情况下的打印内容：

# What gets printed if foo is the main program
before import
before functionA
before functionB
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 functionA
before functionB
before __name__ guard
after __name__ guard

为什么这样工作？

您自然会想知道为什么有人会想要这个。好吧，有时候您想编写一个.py文件，该文件既可以供其他程序和/或模块用作模块，又可以作为主程序本身运行。例子：

您的模块是一个库，但是您希望有一个脚本模式，在其中运行一些单元测试或演示。
您的模块仅用作主程序，但具有一些单元测试，并且测试框架通过导入.py文件（如脚本）并运行特殊的测试功能来工作。您不希望它只是因为正在导入模块而尝试运行脚本。
您的模块主要用作主程序，但它也为高级用户提供了程序员友好的API。

除了这些示例之外，可以优雅地用Python运行脚本只是设置一些魔术变量并导入脚本。 “运行”脚本是导入脚本模块的副作用。

思想的食物

问题：我可以有多个__name__检查块吗？答：这样做很奇怪，但是这种语言不会阻止您。
假设以下内容在foo2.py 。如果在命令行上说python foo2.py会发生什么？为什么？

# Suppose this is foo2.py.def functionA():print("a1")from foo2 import functionBprint("a2")functionB()print("a3")def functionB():print("b")print("t1")
if __name__ == "__main__":print("m1")functionA()print("m2")
print("t2")

现在，如果你删除弄明白会发生什么__name__在检查foo3.py ：

# Suppose this is foo3.py.def functionA():print("a1")from foo3 import functionBprint("a2")functionB()print("a3")def functionB():print("b")print("t1")
print("m1")
functionA()
print("m2")
print("t2")

当用作脚本时，它将做什么？当作为模块导入时？

# Suppose this is in foo4.py
__name__ = "__main__"def bar():print("bar")print("before __name__ guard")
if __name__ == "__main__":bar()
print("after __name__ guard")

#15楼

通过将脚本作为命令传递给Python解释器来运行脚本时，

python myscript.py

缩进级别为0的所有代码都将执行。可以很好地定义已定义的函数和类，但是不会运行任何代码。与其他语言不同，没有main()函数会自动运行-main main()函数隐式是顶层的所有代码。

在这种情况下，顶级代码是if块。 __name__是一个内置变量，其结果为当前模块的名称。但是，如果直接运行模块（如上面的myscript.py所述），则将__name__设置为字符串"__main__" 。因此，您可以通过测试来测试您的脚本是直接运行还是通过其他方式导入

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 oneprint("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

因此，当模块one被加载时，它的__name__等于"one" ，而不是"__main__" 。

#16楼

__name__变量（imho）的最简单解释如下：

创建以下文件。

# 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__']设置为模块名称。同样，在导入时，模块中的所有代码都在运行。由于if语句的计算结果为False因此不会执行此部分。

$ python b.py
Hello World from __main__!
Hello World again from __main__!

如您所见，执行文件时，Python将此文件中的globals()['__name__']为"__main__" 。这次， if语句的计算结果为True ，并且正在运行。

#17楼

您可以使该文件可用作脚本以及可导入模块 。

fibo.py（一个模块命名fibo ）

# Other modules can IMPORT this MODULE to use the function fib
def fib(n):    # write Fibonacci series up to na, b = 0, 1while b < n:print(b, end=' ')a, b = b, a+bprint()# This allows the file to be used as a SCRIPT
if __name__ == "__main__":import sysfib(int(sys.argv[1]))

参考： https : //docs.python.org/3.5/tutorial/modules.html

#18楼

考虑：

if __name__ == "__main__":main()

它检查Python脚本的__name__属性是否为"__main__" 。换句话说，如果程序本身被执行，则属性将为__main__ ，因此程序将被执行（在本例中为main()函数）。

但是，如果模块使用您的Python脚本，则将执行if语句之外的任何代码，因此， if \\__name__ == "\\__main__"仅用于检查程序是否用作模块，并且因此决定是否运行代码。

#19楼

的原因

if __name__ == "__main__":main()

主要是为了避免由于直接导入代码而导致的导入锁定问题。如果要直接调用文件（即__name__ == "__main__"情况），则希望main()运行，但是如果导入了代码，则导入程序必须从真正的主模块中输入代码，以避免导入锁定问题。

副作用是您自动登录支持多个入口点的方法。您可以使用main()作为入口点运行程序， 但不必如此 。 setup.py需要main() ，其他工具使用备用入口点。例如，要将文件作为gunicorn进程运行，请定义一个app()函数而不是main() 。就像setup.py ， gunicorn导入您的代码，因此您不希望它在导入时执行任何操作（由于导入锁定问题）。

#20楼

创建一个文件a.py ：

print(__name__) # It will print out __main__

每当运行该文件时， __name__始终等于__main__ ，直接表明它是主文件。

在同一目录中创建另一个文件b.py ：

import a  # Prints a

运行。它将打印一个，即被导入文件的名称。

因此，为了显示同一文件的两种不同行为 ，这是一个常用的技巧：

# Code to be run when imported into another python fileif __name__ == '__main__':# Code to be run only when run directly

#21楼

在解释有关if __name__ == '__main__'任何内容之前，重要的是要了解__name__是什么以及它的作用。

__name__是__name__ ？

__name__是DunderAlias-可以被视为全局变量（可从模块访问），并以与global相似的方式工作。

它是一个由type(__name__)表示的字符串（如上所述，是全局的type(__name__) （产生<class 'str'> type(__name__) <class 'str'> ），并且是Python 3和Python 2版本的内置标准。

哪里：

它不仅可以在脚本中使用，而且可以在解释器和模块/包中找到。

口译员：

>>> print(__name__)
__main__
>>>

脚本：

test_file.py ：

print(__name__)

导致__main__

模块或包装：

somefile.py：

def somefunction():print(__name__)

test_file.py：

import somefile
somefile.somefunction()

产生somefile

请注意，在包或模块中使用__name__时，使用文件名。没有给出实际模块或包路径的路径，但是具有其自己的DunderAlias __file__ ，因此可以做到这一点。

您应该看到，在__name__ （它是主文件（或程序）的位置）将始终返回__main__ ，并且如果它是模块/软件包或正在运行的其他Python脚本中的任何内容，则将返回文件名。它来自哪里。

实践：

作为变量意味着它的值可以被覆盖（“可以”并不意味着“应该”），覆盖__name__的值将导致缺乏可读性。因此，无论出于任何原因都不要这样做。如果需要变量，请定义一个新变量。

始终假定__name__的值为__main__或文件名。再次更改此默认值将引起更多混乱，这会带来好处，并进一步导致问题。

例：

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

通常，在脚本中包含if __name__ == '__main__'被认为是一种好习惯。

现在回答if __name__ == '__main__' ：

现在我们知道__name__的行为变得更清楚了：

if给定的值为true，则将执行if是包含代码块的流控制语句。我们已经看到__name__可以采用__main__或从中导入的文件名。

这意味着如果__name__等于__main__则该文件必须是主文件并且必须实际上正在运行（或者它是解释器），而不是导入脚本的模块或包。

如果确实__name__确实采用__main__的值，那么该代码块中的所有内容都将执行。

这告诉我们，如果正在运行的文件是主文件（或者直接从解释器运行），则必须执行该条件。如果它是一个包，则不应，并且其值将不是__main__ 。

模块：

__name__也可以在模块中使用以定义模块的名称

变体：

也可以使用__name__做其他一些不太常见但有用的事情，我将在这里展示一些：

仅当文件是模块或软件包时才执行：

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

如果文件是主文件，则运行一个条件，如果文件不是主文件，则运行另一个条件：

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

您也可以使用它在软件包和模块上提供可运行的帮助功能/实用程序，而无需精心使用库。

它还允许模块作为主脚本从命令行运行，这也非常有用。

#22楼

如果name ==' main '：

我们经常查看__name__ == '__main__':情况。

它检查是否正在导入模块。

换句话说，仅在直接运行代码时，才会执行if块中的代码。这里directly表示not imported 。

让我们看一下使用打印模块名称的简单代码的作用：

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

如果我们直接通过python test.py运行代码，则模块名称为__main__ ：

call test()
test module name=__main__

#23楼

所有答案都对功能进行了解释。但是，我将提供其用法的一个示例，这可能有助于进一步澄清该概念。

假设您有两个Python文件a.py和b.py。现在，a.py导入b.py。我们运行a.py文件，首先执行“ import b.py”代码。在其余的a.py代码运行之前，文件b.py中的代码必须完全运行。

在b.py代码中，有一些代码是该文件b.py专有的，我们不希望导入b.py文件的任何其他文件（b.py文件除外）来运行它。

这就是这行代码检查的内容。如果它是运行代码的主文件（即b.py）（在这种情况下不是）（运行a.py是主文件），则仅执行代码。

#24楼

如果此.py文件是由其他.py文件导入的，则“ if语句”下的代码将不会执行。

如果此.py由python this_py.py在外壳下运行python this_py.py或在Windows中双击运行。 “ if语句”下的代码将被执行。

通常是为了测试而编写的。

#25楼

在本页的所有答案中，我都读了很多东西。我想说的是，如果您知道这件事，那么您肯定会理解这些答案，否则，您仍然会感到困惑。

简而言之，您需要了解以下几点：

import a操作实际上会运行所有可以在“ a”中运行import a操作
由于第1点，导入时可能不希望所有内容都在“ a”中运行
为了解决第2点的问题，python允许您进行条件检查
__name__是所有.py模块中的隐式变量；导入__name__ ，将a.py模块的__name__的值设置为其文件名“ a”；当使用“ python a.py”直接运行a.py时，这意味着a.py是入口点，则a.py模块的__name__的值设置为字符串__main__
基于python如何为每个模块设置变量__name__的机制，您知道如何实现第3点吗？答案很简单，对吧？放置一个if条件： if __name__ == "__main__": ... ; 您甚至可以根据自己的功能需要输入__name__ == "a"

python特殊之处很重要的一点是第4点！其余只是基本逻辑。

#26楼

该答案适用于学习Python的Java程序员。每个Java文件通常包含一个公共类。您可以通过两种方式使用该类：

从其他文件调用类。您只需要将其导入调用程序中即可。
出于测试目的，单独运行类。

对于后一种情况，该类应包含一个公共的静态void main（）方法。在Python中，此目的由全局定义的标签'__main__' 。

#27楼

就像在C编程语言中的main功能一样，它只是运行文件的入口点。

#28楼

python中的每个模块都有一个称为name的属性。当模块直接运行时， name属性的值为' main '。否则， name的值就是模块的名称。

简短说明一下小例子。

#Script test.pyapple = 42def 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()

我们可以直接执行为

python test.py

输出量

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

现在假设我们从其他脚本中调用上述脚本

#script external_calling.pyimport test
print(test.apple)
test.hello_world()print(test.__name__)

当您执行此

python external_calling.py

输出量

42
I am inside hello_world
test

因此，上面的解释是，当您从其他脚本调用test时，如果test.py中的循环名不会执行。

#29楼

如果python解释器正在运行特定模块，则__name__全局变量的值将为"__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()

运行此脚本打印件时， 您可以看到我

一种

如果您导入此文件，请说A到文件B并执行文件B，那么if __name__ == "__main__"文件A中的if __name__ == "__main__"变为false，则将其打印出来您看不到我

name ==“ main”怎么办？相关推荐

浅析python 中__name__ = '__main__' 的作用
很多新手刚开始学习python的时候经常会看到python 中__name__ = \'__main__\' 这样的代码,可能很多新手一开始学习的时候都比较疑惑,python 中__name__ = ...
python 中if __name__ = '__main__' 的作用
python 中if __name__ = '__main__' 的作用前言首先我们要知道在python里面万物皆对象,模块也是对象,并且所有的模块都有一个内置属性 __name__. 一个模块的 ...
Python的if __name__ == ‘__main__‘:的作用
程序入口对于很多编程语言来说,程序都必须要有一个入口,比如 C,C++,以及完全面向对象的编程语言 Java,C# 等.如果你接触过这些语言,对于程序入口这个概念应该很好理解,C 和 C++ 都需要 ...
python if __name__ == '__main__'
参考:知乎网友旷世的忧伤博主Arkenstone python 中 if name == 'main'的作用:简单地说,if__name__=='main'是一个开关,当一个程序(用A表示)需要调用 ...
if __name__ == __main__
Python文件可以作为可复用的模块(module),也可以作为独立的程序单独运行. __name__是内置变量,它用来获取当前模块的名称. 当Python源文件作为主程序运行时,它的__name__ ...
python使用笔记：if __name__ == ‘__main__‘ 如何理解
大部分内容来自: 作者:初识CV 链接:https://www.zhihu.com/question/49136398/answer/1654722335 来源:知乎著作权归作者所有.商业转载请联系 ...
python中if __name__ == '__main__': 的解析
2019独角兽企业重金招聘Python工程师标准>>> python中if __name__ == '__main__': 的解析当你打开一个.py文件时,经常会在代码的最下面看到 ...
python 中 if __name__ == '__main__' 判断的作用
假设这样一个a.py文件 def fun1(): ........ def fun2(): ......... if __name__=='__main__': ......#执行的一些语句当你执行 ...
__name__ == '__main__'的作用
当你打开一个.py文件时,经常会在代码的最下面看到if __name__ == '__main__':,现在就来介绍一下它的作用. 模块是对象,并且所有的模块都有一个内置属性 __name__.一个 ...

__name__ ==“ __main__”怎么办？

#1楼

#2楼

#3楼

if __name__ == "__main__":什么作用？

开发和测试您的代码

问题

更好的方法

更好的方法

#4楼

#5楼

if __name__ == "__main__":怎么办？

#6楼

#7楼

#8楼

#9楼

#10楼

#11楼

#12楼

#13楼

#14楼

代码样例

特殊变量

执行模块的代码

为什么这样工作？

思想的食物

#15楼

#16楼

#17楼

#18楼

#19楼

#20楼

#21楼

#22楼

如果name ==' main '：

#23楼

#24楼

#25楼

#26楼

#27楼

#28楼

#29楼

__name__ ==“ __main__”怎么办？相关推荐

最新文章

热门文章

name ==“ main”怎么办？

`if name == "main":`什么作用？

`if name == "main":`怎么办？

name ==“ main”怎么办？相关推荐