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

让我们看看它是如何工作的以及它与您__name__在Python脚本中总是看到的检查问题的关系.

代码示例

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

# Suppose this is foo.py.
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 __name__ guard")
if __name__ == '__main__':
functionA()
functionB()
print("after __name__ guard")

特殊变量

当Python interpeter读取源文件时,它首先定义一些特殊变量.在这种情况下,我们关心__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"

执行模块的代码

设置特殊变量后,解释器将执行模块中的所有代码,一次执行一个语句.您可能希望使用代码示例打开另一个窗口,以便您可以按照此说明进行操作.

总是

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

仅当您的模块是主程序时

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

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

8. (相反)如果你的模块不是主程序而是由另一个模块导入,那么__name__将是"foo",而不是"__main__",它将跳过if语句的主体.

总是

9. 它将"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既可以被其他程序和模块用作模块的文件,也可以作为主程序运行.例子:

除了这些例子之外,在Python中运行脚本只是设置一些魔术变量并导入脚本是很优雅的."运行"脚本是导入脚本模块的副作用.

思想的食物

# Suppose this is foo2.py.
def functionA():
print("a1")
from foo2 import functionB
print("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 functionB
print("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")

• 出于好奇：如果我在python脚本中运行subprocess.run（'foo_bar.py'）`会发生什么情况？我想`foo_bar`将以`__name__ ='__main__'开始，就像我在cmd中手动提示`foo_bar.py`一样。是这样吗 考虑到@MrFooz的答案，这样做应该没有问题，并且一次可以拥有多个“主要”模块。即使更改__name__的值或具有多个独立创建的实例（或由`subprocess`相互创建的实例）彼此交互，对于Python来说也应该照常进行。我想念什么吗？
• @hajef您对“ subprocess.run”如何工作是正确的。也就是说，在脚本之间共享代码的一种更好的方法是创建模块并让脚本调用共享的模块，而不是像脚本那样相互调用。由于大多数调试器都不会跨越进程边界，因此很难调试subprocess.run调用，这会增加非平凡的系统开销来创建和销毁额外的进程，等等。
• One of the modules that may import your code is `multiprocessing`, in particular making this test necessary on Windows.
• Extremely minor point, but I believe python actually determines the `__name__` of an imported module from the import statement, not from stripping ".py" off the filename. Because python identifiers are case sensitive but file names may not be (e.g. on windows), there isn't necessarily enough information in the filename to determine the correct python module name.
• 我对食品的思考部分的foo2.py示例有疑问。从foo2.py导入functionB做什么？在我看来，它只是从functionB导入foo2.py
• @user471651 In the food for thought section, `from foo2 import functionB` will trigger the Python interpreter to reload `foo2.py` a second time, but this second time it'll have `__name__='foo2'` instead of `__name__='__main__'`. There will be *two* copies of `functionB` in RAM. `functionA` in `__main__` will call the version loaded as `foo2.functionB`, not the `__main__.functionB` copy.
• I loved how subtly this line solved my confusion: " "Running" the script is a side effect of importing the script's module."

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

python myscript.py

压缩级别为0的所有代码都会被执行.已定义的函数和类已定义,但它们的代码都不会运行.与其他语言不同,没有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 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

因此,当模块one加载时,它__name__等于"one"而不是"__main__".

__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并正在运行.

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

概述基础知识:

我们为什么需要这个？

开发和测试您的代码

假设您正在编写旨在用作模块的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()

通过上述操作,您的代码将仅在您将其作为主模块运行时执行(或有意从其他脚本调用它).

更好的方式

不过,有一种Pythonic方法可以对此进行改进.

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

如果我们在我们开发和测试这样的函数时放置我们想要运用的代码,然后'__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()

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

• Why does a file `helloworld.py` with just ```print("hello world")``` in it can run with command ```python helloworld.py``` even when there is no ```if __name__ == "__main__"```?

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

__name__是一个全局变量(在Python中,全局实际上意味着在模块级别上),它存在于所有名称空间中.它通常是模块的名称(作为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()

这里有很多不同的关于代码的机制,"如何",但对我来说,除非我理解"为什么",否则它们都没有意义.这应该对新程序员特别有用.

拿文件"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__":是解释器的测试,用于确定它是否正在解释/解析最初执行的"主页"脚本,或者它是否暂时窥视另一个(外部)脚本.这为程序员提供了灵活性,使脚本的行为不同,如果它直接执行而不是外部调用.

让我们逐步执行上面的代码来了解发生了什么,首先关注的是未缩进的行以及它们在脚本中出现的顺序.请记住,函数 - 或def- 块在调用之前不会自行执行任何操作.如果嘟to自己,翻译可能会说些什么:

• 打开xy.py作为"主页"文件; "__main__"在__name__变量中调用它.
• 导入并打开文件__name__ == "ab.py".
• 哦,一个功能.我会记得的.
• 好的,功能a(); 我刚学会了这个.打印' ab文件中的函数 '.
• 文件结束; 回到"__main__"!
• 哦,一个功能.我会记得的.
• 另一个.
• 功能x(); 好的,打印' 外围任务:可能在其他项目中很有用 '.
• 这是什么？一份if声明.好吧,条件已经满足(变量__name__已经设置为"__main__"),所以我将进入main()函数并打印' main函数:这是动作的位置 '.

底部两行表示:"如果这是"__main__"'或'home'脚本,则执行名为main()" 的函数.这就是为什么你会看到一个def main():块顶部,其中包含脚本功能的主要流程.

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

同样,会有例外,但通常的做法是main()通常不会被外部调用.所以你可能想知道另一件事:如果我们不打电话main(),为什么我们要调用脚本呢？这是因为许多人使用独立函数构建脚本,这些函数构建为独立于文件中的其余代码运行.然后他们被称为剧本正文中的其他地方.这让我想到了这个:

恩,那就对了.可以从不包含在main()函数内的内联脚本调用这些单独的函数.如果您已经习惯(就像我在编程的早期学习阶段一样)构建完全符合您需要的内联脚本,并且如果您再次需要该操作,您将尝试再次弄清楚它.好吧,你不习惯你的代码的这种内部结构,因为它的构建更复杂,而且阅读不那么直观.

但这是一个可能无法在外部调用其函数的脚本,因为如果这样做,它会立即开始计算和分配变量.如果您正在尝试重新使用某个函数,那么您的新脚本可能与旧版本密切相关,因为存在冲突的变量.

在拆分独立函数时,您可以通过将它们调用到另一个脚本中来重用以前的工作.例如,"example.py"可能导入"xy.py"并调用x(),使用"xy.py" 中的"x"函数.(也许它正在大写给定文本字符串的第三个单词;从数字列表创建NumPy数组并对它们进行平方;或者去除3D表面的去除.可能性是无限的.)

(顺便说一句,这个问题包含@kindall终于让我明白一个答案-其所以然,而不是如何不幸的是它被标记为与重复这一个,我认为这是一个错误)

当我们的module(M.py)中存在某些语句时,我们希望在它作为main(未导入)运行时执行,我们可以将这些语句(测试用例,打印语句)放在此if块下.

默认情况下(当模块作为main运行,而不是导入时)__name__变量被设置为"__main__",当它被导入时,__name__变量将获得不同的值,最可能是模块的名称('M').这有助于将模块的不同变体一起运行,并将它们的特定输入和输出语句分开,以及是否存在任何测试用例.

简而言之,使用此" if __name__ == "main"块"可以防止(某些)代码在导入模块时运行.

简而言之,__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__

执行脚本2的输出是:

Script1's name is script1
Script 2's name: __main__

如您所见,__name__告诉我们哪个代码是"主要"模块.这很好,因为你可以只编写代码而不必担心C/C++中的结构问题,如果文件没有实现'main'函数那么它就不能被编译成可执行文件,如果是的话,它不能用作库.

假设您编写了一个Python脚本,它可以执行一些非常棒的操作,并且您可以实现一系列对其他用途有用的函数.如果我想使用它们,我可以导入你的脚本并使用它们而不执行你的程序(假设你的代码只在if __name__ == "__main__":上下文中执行 ).而在C/C++中,您必须将这些部分分成一个单独的模块,然后包含该文件.想象下面的情况;

箭头是导入链接.对于每个试图包含前面的模块代码的三个模块,有六个文件(九个,计算实现文件)和五个链接.这使得很难将其他代码包含到C项目中,除非它专门编译为库.现在想象一下Python:

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

• C/C++插图错误:相同单位名称的3倍(*file1*).

The code under if __name__ == '__main__': will be executed only 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')

1st 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.

2nd 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 exectued:

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.

让我们以更抽象的方式看待答案:

假设我们在x.py中有这个代码:

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

当我们运行"x.py"时,块A和B运行.

但是当我们运行另一个模块时运行块A(而不是B),例如"y.py",其中导入了xy并且从那里运行代码(就像"x.py"中的函数是从y.py调用.

以交互方式运行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.

考虑:

if __name__ == "__main__":
main()

它检查__name__Python脚本的属性是否为"__main__".换句话说,如果程序本身被执行,那么属性将被执行,__main__因此程序将被执行(在这种情况下是main()函数).

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

在解释任何事情之前,了解if __name__ == '__main__'它的作用和作用非常重要__name__.

__name__是DunderAlias - 可以被认为是一个全局变量(可从模块访问)并以类似的方式工作global.

它是一个字符串(如上所述的全局),由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__'脚本中的好习惯.

现在我们知道__name__事情的行为变得更加清晰:

An if是一个流控制语句,如果给定的值为true,则包含将执行的代码块.我们已经看到__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

您还可以使用它在包和模块上提供可运行的帮助功能/实用程序,而无需精心使用库.

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

我认为最好用深入简单的方式打破答案:

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

__main__:像其他编程语言一样,Python也有一个执行入口点,即main.'__main__' 是顶级代码执行的范围的名称.基本上,您有两种使用Python模块的方法:直接将其作为脚本运行,或者导入它.当模块作为脚本运行时,其__name__设置为__main__.

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

从命令行调用Python文件时,这是一个特殊的功能.这通常用于调用"main()"函数或执行其他适当的启动代码,例如命令行参数处理.

它可以用几种方式编写.另一个是:

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

我并不是说你应该在生产代码中使用它,但它可以说明没有任何"神奇"的东西if __name__ == '__main__'.在Python文件中调用main函数是一个很好的约定.

• 撇开是否利用布尔运算符的短路行为作为流量控制机制的问题是不好的风格,更大的问题是这个*根本不回答问题*.
• 我会考虑这种不好的形式,因为你是1)依赖副作用和2)滥用`和`.`和`用于检查两个布尔语句是否都为真.由于你对`和`的结果不感兴趣,所以`if`语句更清楚地传达了你的意图.

系统(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 ".

希望这会有所帮助.

if __name__ == "__main__": 基本上是顶级脚本环境,它指定了解释器('我首先执行的优先级最高').

'__main__'是顶级代码执行的范围的名称.模块的__name__设置等于'__main__'从标准输入,脚本或交互式提示中读取的内容.

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

在本页的答案中,我一直在阅读这么多内容.我会说,如果你知道这件事,肯定会理解那些答案,否则,你仍然感到困惑.

简而言之,您需要了解以下几点:

python特别重要的是第4点!其余的只是基本逻辑.

• 是的，第 1 点对于理解至关重要。由此，这种机制的必要性变得清晰起来。
• this should be the accepted answer..

考虑:

print __name__

上面的输出是__main__.

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

以上陈述是正确的,并打印"直接方法".假设他们在另一个类中导入了这个类,它不会打印"直接方法",因为在导入时它会设置__name__ equal to "first model name".

的原因

if __name__ == "__main__":
main()

主要是为了避免因直接导入代码而导致的导入锁定问题.如果您的文件被直接调用(这种情况),您希望运行,但如果您的代码已导入,则导入器必须从真正的主模块输入您的代码以避免导入锁定问题.main()__name__ == "__main__"

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

• 很高兴了解*import lock*.能否请您解释*签署一个方法,[*]*更多一点？

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

如果名称== ' 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__

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

对于后一种情况,该类应包含一个public static void main()方法.在Python中,此目的由全局定义的标签提供'__main__'.

简单来说：

您在下面看到的代码 if __name__ == "__main__":只会在您的 python 文件作为“python example1.py”执行时被调用。

但是，如果您希望将 python 文件“example1.py”作为模块导入到另一个 python 文件“example2.py”中，则下面的代码if __name__ == "__main__":将不会运行或生效。

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

假设您有两个 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 是运行的主文件），那么只有代码被执行。

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

简短说明一下小例子。

#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()

我们可以直接执行为

python test.py

输出量

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

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

#script external_calling.py
import test
print(test.apple)
test.hello_world()
print(test.__name__)

当您执行此

python external_calling.py

输出量

42
I am inside hello_world
test

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

创建一个文件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 file
if __name__ == '__main__':
# Code to be run only when run directly

如果此.py文件由其他.py文件导入,则不会执行"if语句"下的代码.

如果此.py由python this_py.pyshell下运行,或在Windows中双击."if语句"下的代码将被执行.

它通常是为测试而编写的.

如果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中将变为false，因此它会打印 您看不到我

b