if __name__ == "__main__": 做什么?

python namespaces main python-module idioms

这是做什么的,为什么要包含 if 语句?

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

仅作记录 - 什么是“main”:docs.python.org/3/reference/…,什么是“name”:docs.python.org/3/reference/…

对于重复的关闭器:如果您试图告诉某人使用此习惯用法以避免在导入模块时出现代码运行问题,请不要使用它 - 改用 stackoverflow.com/questions/6523791

N
Neuron

简答

它是样板代码,可防止用户在无意中意外调用脚本。以下是脚本中省略守卫时的一些常见问题:

如果您在另一个脚本中导入无保护脚本(例如 import my_script_without_a_name_eq_main_guard),则后一个脚本将触发前者在导入时运行并使用第二个脚本的命令行参数。这几乎总是一个错误。

如果您在无保护脚本中有一个自定义类并将其保存到一个 pickle 文件中,那么在另一个脚本中将其取消腌制将触发无保护脚本的导入,与上一个项目符号中概述的问题相同。

长答案

为了更好地理解这为什么以及如何重要,我们需要退后一步来了解 Python 如何初始化脚本以及它如何与其模块导入机制进行交互。

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

它设置了一些特殊变量,如 __name__,然后

它执行在文件中找到的所有代码。

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

代码示例

让我们使用一个稍微不同的代码示例来探索导入和脚本是如何工作的。假设以下内容位于名为 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")

特殊变量

当 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 文件(以及搜索一些其他变体),并且在执行该模块之前,它会将名称 "foo" 从导入语句分配给 __name__ 变量,即

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

执行模块的代码

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

总是

它在“导入前”打印字符串(不带引号)。它加载数学模块并将其分配给一个名为数学的变量。这相当于将 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")

它在“function_a 之前”打印字符串。它执行 def 块,创建一个函数对象,然后将该函数对象分配给一个名为 function_a 的变量。它在“function_b 之前”打印字符串。它执行第二个 def 块,创建另一个函数对象,然后将它分配给一个名为 function_b 的变量。它在“__name__ guard”之前打印字符串。

仅当您的模块是主程序时

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

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

(相反)如果您的模块不是主程序而是由另一个程序导入,那么 __name__ 将是“foo”,而不是“__main__”,它会跳过 if 语句的主体。

总是

在这两种情况下,它都会打印字符串“在 __name__ 守卫之后”。

概括

总而言之,以下是两种情况下打印的内容:

# 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

为什么它会这样工作?

你可能自然想知道为什么有人会想要这个。好吧,有时您想编写一个 .py 文件,它既可以被其他程序和/或模块用作模块,也可以作为主程序本身运行。例子:

您的模块是一个库,但您希望有一个脚本模式,它可以运行一些单元测试或演示。

您的模块仅用作主程序,但它具有一些单元测试,并且测试框架通过导入脚本等 .py 文件并运行特殊测试功能来工作。您不希望它仅仅因为它正在导入模块而尝试运行脚本。

您的模块主要用作主程序,但它也为高级用户提供了对程序员友好的 API。

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

深思熟虑

问题:我可以有多个 __name__ 检查块吗?答:这样做很奇怪,但语言不会阻止你。

假设以下内容在 foo2.py 中。如果你在命令行上说 python foo2.py 会发生什么?为什么?

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

现在,弄清楚如果删除 foo3.py 中的 __name__ 会发生什么:

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

当用作脚本时,它会做什么?当作为模块导入时?

# 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 调用,因为大多数调试器不会跨越进程边界,它会增加非平凡的系统开销来创建和销毁额外的进程等。

我对思考部分中的 foo2.py 示例有疑问。 from foo2.py import functionB 有什么作用?在我看来,它只是从 functionB 导入 foo2.py

可能会导入您的代码的模块之一是 multiprocessing,尤其是在 Windows 上需要进行此测试。

非常次要的一点,但我相信python实际上是从import语句中确定导入模块的__name__,而不是从文件名中剥离“.py”。因为python标识符区分大小写但文件名可能不区分(例如在windows上),文件名中不一定有足够的信息来确定正确的python模块名称。

T
Tonechas

当您的脚本通过将其作为命令传递给 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__"

所以,if __name__ == "__main__": 基本上检查您是否正在运行您的 python 脚本本身,而不是导入它或其他什么?

@Adam Rosenfield 如果您的脚本被导入另一个模块,它的各种函数和类定义将被导入并执行其顶级代码.... 什么是顶级代码?缩进为零的代码?

M
Mateen Ulhaq

创建以下两个文件:

# a.py

import b
# b.py

print("__name__ equals " + __name__)

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

现在单独运行每个文件。

运行 python a.py

$ python a.py
__name__ equals b

执行 a.py 时,它会导入模块 b。这会导致 b 内的所有代码运行。 Python 将 b 模块中的 globals()['__name__'] 设置为模块的名称 b

运行 python b.py

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

当仅执行文件 b.py 时,Python 将此文件中的 globals()['__name__'] 设置为 "__main__"。因此,这次 if 语句的计算结果为 True

R
Russia Must Remove Putin

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

有了上述内容,您的代码只会在您将其作为主要模块运行(或有意从另一个脚本中调用它)时执行。

更好的方法

不过,有一种 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__' 模块运行时调用模块(及其函数和类), IE

import important
important.main()

This idiom can also be found in the Python documentation in an explanation of the __main__ module. 该文本指出:

这个模块代表解释器的主程序执行的(否则是匿名的)范围——从标准输入、脚本文件或交互式提示中读取的命令。正是在这种环境中,惯用的“条件脚本”节导致脚本运行: if __name__ == '__main__': main()

抱歉,我在名为 A Better Way 的部分中提到的方法和在名为 An Even Better Way 的部分中提到的方法之间没有任何区别。你能指出来吗?

M
Mark Amery

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

为什么只有 print("hello world") 的文件 helloworld.py 可以使用命令 python helloworld.py 运行,即使没有 if __name__ == "__main__"

当您运行 python helloworld.py 时,它将运行整个脚本文件(无论您是否指定 if __name__ == "__main__" )。当您从不同的脚本导入 helloworld.py 时,只有在执行上有所不同。在这种情况下,if __name__ == "__main__" 代码块根本不会执行。

M
Mateen Ulhaq

if __name__ == "__main__": 做什么?

__name__ 是一个存在于所有命名空间中的全局变量(在 Python 中,全局实际上是指 module level 上的)。它通常是模块的名称(作为 str 类型)。

然而,作为唯一的特殊情况,在你运行的任何 Python 进程中,如在 mycode.py 中:

python mycode.py

否则匿名的全局命名空间将 '__main__' 的值分配给它的 __name__

因此,包括 the final lines

if __name__ == '__main__':
    main()

在 mycode.py 脚本的末尾,

当它是由 Python 进程运行的主要入口点模块时,

将导致您的脚本唯一定义的 main 函数运行。

使用此构造的另一个好处:您还可以将代码作为模块导入另一个脚本中,然后在您的程序决定时运行 main 函数:

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

这里对所讨论的代码机制有很多不同的看法,即“如何”,但对我来说,在我理解“为什么”之前,这一切都没有意义。这应该对新程序员特别有帮助。

获取文件“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)块在被调用之前不会自行执行任何操作。如果口译员自言自语,可能会说什么:

打开 xy.py 作为“主”文件;在 __name__ 变量中将其称为“__main__”。

使用 __name__ == "ab.py" 导入和打开文件。

哦,一个函数。我会记住的。

好的,函数 a();我刚刚学到了。打印“ab 文件中的函数”。

文件结束;回到“__main__”!

哦,一个函数。我会记住的。

另一个。

函数 x();好的,打印“外围任务:可能在其他项目中有用”。

这是什么?一个 if 语句。好吧,条件已经满足(变量__name__ 已设置为“__main__”),所以我将进入main() 函数并打印'main function: this is where the action is'。

下面两行的意思是:“如果这是 "__main__" 或 'home' 脚本,请执行名为 main() 的函数”。这就是为什么您会在顶部看到一个 def main(): 块,其中包含脚本功能的主要流程。

为什么要实施这个?

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

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

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

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

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

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

(顺便说一句,this question 包含 @kindall 的答案,最终帮助我理解了 - 为什么,而不是如何。不幸的是,它被标记为 this one 的重复,我认为这是一个错误。)

P
Peter Mortensen

如果模块作为脚本调用,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'

请注意,仅执行 my_test_module 中的顶级 print() 语句。

第二种可能性:将 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'

如需更全面的说明,您可以阅读What does if __name__ == '__main__' do in Python

P
Peter Mortensen

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

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

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

+1有时,最好像这个答案中提到的那样获得一个简短的单行:“简而言之,使用这个'if name ==“main”'块来防止(某些)代码在导入模块时运行."。这很有用。谢谢!

P
Peter Mortensen

简而言之,__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++ 中,您必须将这些部分分成一个单独的模块,然后包含该文件。想象下面的情况;

https://i.stack.imgur.com/hWLqr.png

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

https://i.stack.imgur.com/Eql0u.png

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

C/C++ 插图是错误的:3 次相同的单元名称(file1)。

k
kubuntu

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

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

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

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

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

P
Peter Mortensen

简而言之,你需要知道几点:

import a action 实际上会运行所有可以在 a.py 中运行的内容,即 a.py 中的每一行因为第 1 点,您可能不希望在导入时所有内容都在 a.py 中运行要解决第 2 点中的问题, Python 允许您使用条件检查 __name__ 是所有 .py 模块中的隐式变量:

导入 a.py 时,a.py 模块的 __name__ 的值设置为其文件名“a”

当 a.py 直接使用“python a.py”运行时,__name__ 的值设置为字符串 __main__

基于Python如何为每个模块设置变量__name__的机制,你知道如何实现第3点吗?答案很简单,对吧?使用 if 条件: if __name__ == "__main__": // do A

然后 python a.py 将运行该部分 // 执行 A

和 import a 将跳过部分 // 做 A

您甚至可以根据您的功能需要放置 if __name__ == "a" ,但很少这样做

Python 的特别之处在于第 4 点!其余的只是基本逻辑。

我一直在阅读此页面上的所有答案。我想说,如果你知道这件事,你肯定会明白那些答案,否则,你还是一头雾水。

是的,第 1 点对于理解至关重要。由此,对这种机制的需求变得清晰。

Z
Zain

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

考虑:

if __name__ == "__main__":
    main()

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

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

t
tripleee

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

什么名字__?

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

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

在哪里

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

口译员:

>>> print(__name__)
__main__
>>>

脚本:

测试文件.py:

print(__name__)

导致 __main__

模块或包:

一些文件.py:

def somefunction():
    print(__name__)

测试文件.py:

import somefile
somefile.somefunction()

导致 somefile

请注意,在包或模块中使用时,__name__ 采用文件名。没有给出实际模块或包路径的路径,但有它自己的 DunderAlias __file__,允许这样做。

您应该看到,在哪里 __name__,它是主文件(或程序)将总是返回 __main__,如果它是一个模块/包,或者任何正在运行的东西其他 Python 脚本,将返回其来源文件的名称。

实践

作为变量意味着它的值可以被覆盖(“can”并不意味着“should”),覆盖__name__的值将导致缺乏可读性。因此,无论出于何种原因,都不要这样做。如果您需要一个变量,请定义一个新变量。

始终假定 __name__ 的值为 __main__ 或文件名。再次更改此默认值将导致更多的混乱,它会做得很好,从而导致进一步的问题。

例子:

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

通常将 if __name__ == '__main__' 包含在脚本中被认为是一种好的做法。

现在回答如果 __name__ == '__main__':

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

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

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

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

P
Peter Mortensen

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

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

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

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

P
Prof. Falken

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

它可以写成几种方式。另一个是:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

我并不是说您应该在生产代码中使用它,但它可以说明 if __name__ == '__main__' 没有什么“神奇”之处。

它只是在 Python 文件中调用 main 函数的约定。

我会认为这种不好的形式是因为您 1) 依赖副作用和 2) 滥用 andand 用于检查两个布尔语句是否都为真。由于您对 and 的结果不感兴趣,因此 if 语句更清楚地传达了您的意图。

撇开利用布尔运算符的短路行为作为流控制机制是否是不好的风格的问题不谈,更大的问题是这根本没有回答这个问题。

@jpmc26 任何具有 Perl 或 Javascript 背景的人都对这个习惯用法完全满意,使用 and 作为控制语句。我对此没有任何问题。另一个类似的习惯用法是使用 or 设置默认值。例如,x = input("what is your name? ") or "Nameless Person"

@JohnHenckel 这不是 Perl 或 JavaScript。这不是 Python 习语。在 Python 中的布尔语句中间使用具有副作用的函数被认为是一种不好的形式。特别是在这种情况下,在这里使用 and 绝对没有任何好处;该函数甚至不返回值。它只是使代码不那么明显。

@jpmc26 我正在尝试找到与您一致的权威来源。这是在某处提到的吗?例如,在 PEP8 中是否说我们应该避免使用 and 来进行控制,或者使用 or 来分配默认值?我试图用谷歌搜索它,但我找不到任何东西。

c
codewizard

系统(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”。

希望这会有所帮助。

嗨,您是少数解决多线程方面问题的人之一。请问这个,如果我有“main”之外的代码并且没有封装在函数中会发生什么?这段代码会被从 main 启动的每个新线程一次又一次地执行吗?

P
Peter Mortensen

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

'__main__' 是顶级代码执行的范围的名称。当从标准输入、脚本或交互式提示中读取时,模块的 __name__ 设置为 '__main__'

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

考虑:

print __name__

上面的输出是 __main__

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

上述陈述为真,并打印出“直接方法”。假设如果他们在另一个类中导入这个类,它不会打印 "direct method",因为在导入时它会设置 __name__ equal to "first model name"

k
kgf3JfUtW

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

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

p
personal_cloud

的原因

if __name__ == "__main__":
    main()

主要是为了避免由 having code directly imported 引起的 import lock 问题。如果您的文件被直接调用,您希望 main() 运行(这是 __name__ == "__main__" 的情况),但如果您的代码是导入的,那么导入器必须从真正的主模块输入您的代码以避免导入锁定问题。

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

P
Peter Mortensen

Python 中的每个模块都有一个名为 __name__ 的属性。当模块直接运行时,__name__ 属性的值为 __main__,如 python my_module.py。否则(例如当您说 import my_module 时)__name__ 的值是模块的名称。

简短的小例子来解释。

脚本 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

现在假设我们从另一个脚本调用上述脚本:

脚本 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 中的 if 循环 __name__ 将不会执行。

t
tripleee

如果您是初学者,那么您现在唯一需要的答案可能是 此代码对于简单的脚本来说是不必要的。仅当您希望能够 import 您的脚本(或 unpickle 等;请参阅此处的其他答案以了解其他一些非初学者场景)时,它才有用。

换句话说,if __name__ 守卫是一种将代码隐藏在其他代码之外的机制。如果您没有特定的理由隐藏某些内容,请不要:如果您不需要隐藏 import 中的某些代码,请不要将其置于此保护之下,如果需要,请尽可能隐藏可能的。

稍微详细一点,假设您有一个简单的脚本 fib.py(改编自 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))

现在,如果您只运行 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使用新版本,但如果您一开始不打算这样做,那么这个版本实际上更好,因为它更简单、更清晰。

如果您确实希望能够import fib,那么第一个版本也是无用的,因为有用的代码位于import此文件时不会运行的部分中(在这种情况下__name__ 不会是 "__main__")。在这种情况下,正确的设计是重构代码,以便有用的部分包含在一个函数中,您可以在import编辑它之后随时运行它。

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 并从执行此 import 的代码中调用 fibn() 函数。

(我调用函数 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 等语言不同,名称 main 对 Python 没有特定含义;但将其用作将要运行的事物的名称是一种常见约定。您仍然必须实际显式调用它,例如 {2 },与 C 不同。)

我保持示例代码简单以避免分心;在现实生活中,您需要处理 input 返回的不是数字的东西,当然,可能应该优化现实生活中的斐波那契函数以避免每次调用它时重新计算序列的开头。

n: int-> int 类型注释需要 Python >= 3.6

斐波那契数的排序惯例并非一成不变。通常的约定是第一个数字是 0,但在数学上通常是 F(0)。您可能会将简单脚本的结果视为一个错误,并相应地对其进行修复。

e
eyllanesc

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

从其他文件调用类。您只需在调用程序中导入它。单独运行该类,用于测试目的。

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

P
Peter Mortensen

如果 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,则文件 A 中的 if __name__ == "__main__" 变为 false,因此它会打印 You can't see me

b

t
tripleee

如果这个 .py 文件被其他 .py 文件导入,if语句下的代码将不会被执行。

如果这个 .py 由 python this_py.py 在 shell 下运行,或者在 Windows 中双击。 if 语句下的代码将被执行。

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

t
tripleee

简单来说:

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

但是,如果您希望将 Python 文件 example1.py 作为模块导入以使用另一个 Python 文件(例如 example2.py),则 if __name__ == "__main__": 下的代码将不会运行或生效。

t
tripleee

我们经常看到 __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__
t
tripleee

Python 中的每个模块都有一个称为 __name__ 的特殊属性。当模块作为主程序执行时(例如,运行 python foo.py),__name__ 属性的值设置为 '__main__'

否则,__name__ 的值将设置为调用它的模块的名称。

重新“...调用它的模块的名称”:不是模块本身?这听起来不太合理。如果是,您能elaborate回答吗? (但没有“编辑:”、“更新:”或类似的 - 答案应该看起来好像是今天写的。)