当你import具有此条件的代码, 它会返回False(除进口编码外),但将返回True将要运行的代码的代码 。

当您的脚本作为命令传递给 Python 口译员时,

python myscript.py

缩进级别 0 的所有代码都得到执行。 定义的函数和类别是, 定义的, 定义明确, 但他们的代码没有运行 。 与其他语言不同, 没有main()函数自动运行 -main()函数是最高层所有代码的隐含值。

在这种情况下,最高层代码是if区块。__name__是一个内嵌变量。该变量对当前模块的名称进行评估。但是,如果模块直接运行,则该模块直接运行(如myscript.py above), then __name__而不是设置为字符串"__main__"因此,您可以测试您的脚本是直接运行的,还是通过测试输入其它东西的脚本。

if __name__ == "__main__":
    ...

如果您的脚本正在导入到另一个模块中, 它的各种函数和类定义将会导入, 并且它的顶层代码将会被执行, 但是在当时if以上条款将无法运行,因为不符合条件。作为一个基本例子,考虑以下两个脚本:

# 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__ == '__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__

如果你是初学者 可能你现在唯一需要的答案就是此代码没有必要简单脚本的简单脚本。它只有在您想要能够import您的脚本 (或)unpickle等; 等; 参见关于其他一些非初始情景的其他答案 。

以略微不同的措辞,if __name__警卫是隐藏代码的机制, 用于隐藏其它代码 。 如果您没有特定的理由隐藏某些信息, 不要: 如果您不需要隐藏一些代码 。import,不要把它背后的警卫, 如果你这样做, 隐藏尽可能少的隐藏。

更详细一点,假设你有一个简单的脚本fib.py(改编回答本答案):

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

现在,如果你只是跑跑python fib.py效果不错,但是...__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))

现在,你不能import fib新版本的版本, 但如果你一开始不打算这样做, 这个版本其实更好, 因为它简单明了。

如果你(如果)do do do 做想要能够import fib,第一个版本也是没用的,因为有用的代码是在一个区域中,当您import此文件( 在哪个情况下)__name__将不为"__main__"))。在这种情况下,适当的设计将是重新设定代码,以便有用的部分在函数中发挥作用,在您想要运行时,可以运行importEd it. Ed. Ed it. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. Ed. 编辑。 编辑 编辑。 编辑。 编辑 编辑。 编辑。

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

如果你现在import fib,呼吁main()将不会被执行;但当您运行时python fib.py会的

实际上,更好的设计仍然是将可重复使用部分(实际计算)与用户可看到的投入/产出分开:

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

现在,你可以from fib import fibn然后喊叫,fibn()运行此功能的代码的函数import.

(我调用函数)fibn()只是为了让这个例子更清楚什么是这个例子。在现实生活中,你可以把它称为fib()并且确实from fib import fib.)

同样,你也可以import然后喊叫,main函数。

在回到问题中的代码时,我同样将代码从if功能中也包含一个功能,因此呼叫者如果愿意,可以援引该功能。

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

这改变了lock变量;如果周围代码需要访问它,您需要将其global(或,也许,更好的是,重构main至return lock,并让调用者在自己的本地变量中捕捉到值。)

(不同于C类语言中的名称)mainPython 对 Python 没有具体意义; 但使用它作为将要运行的事物的名称, 是一个常见的公约 。 您仍然必须实际明确称呼它, 比如 :main(),不同于C.)

有关代码的机理有很多不同之处, “如何” 但对我而言,除非我理解“为什么” , 否则这些都说不通。 这应该对新的程序员有特别的帮助。

获取文件“ 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。导入语句在导入时立即运行模块,因此ab业务在剩余时间之前完成xy完成后ab,它继续xy.

口译员跟踪脚本运行的脚本__name__。当您运行一个脚本时,不管你叫什么,口译员都叫它"__main__",使它成为在运行外部脚本后返回的主人或“家”脚本。

任何其它的脚本 从这里调用"__main__"将其文件名指定为脚本__name__(例如,__name__ == "ab.py"因此,线线if __name__ == "__main__":是口译员的测试, 以确定它是否在解释/ 区分最初执行的“ 家” 脚本, 或者它是否临时偷看另一个( 外部) 脚本。 这让程序员具有灵活性, 如果直接执行的话, 脚本行为会有所不同 。

让我们跨过上面的代码 来理解发生了什么, 首先关注未缩入的行和它们出现在脚本中的顺序。 记住这个函数 - 或者def翻译会说,如果自己自欺欺人的话:

• 打开 xy.py 作为“ home” 文件; 调用它"__main__"和在__name__变量。
• 导入并打开文件__name__ == "ab.py".
• 哦,一个功能,我会记住的
• Ok, 函数函数a(); 我刚学到了这一点。打印ab 文件中的函数'.
• 文件结束; 返回到"__main__"!
• 哦,一个功能,我会记住的
• 再来一个
• 函数职能职能职能职能职能职能职能职能x(); OK, 打印 '外围任务:在其他项目中可能有用'.
• 这是什么?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 的回答, 终于帮助我理解为什么, 而不是如何。 不幸的是, 它被标记为重复这个我认为这是一个错误。 )

下代码的代码if __name__ == '__main__':会仅仅如果将模块作为脚本引用,则执行该模块。

例如,考虑以下模块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')

第一种可能性:进口my_test_module.py在另一个模块中

# main.py

import my_test_module

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

如果你现在祈祷main.py:

python main.py

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

请注意,只有最高层print()语中的语中my_test_module执行。

第二种可能性:my_test_module.py作为脚本

现在,如果你现在跑my_test_module.py作为 Python 脚本, 两者print()将执行语句:

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'

更全面的解释,可读作:什么是什么东西if __name__ == '__main__'在 Python 中做.