接收“ab.py”文件:

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

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 时,您将导入 ab. 导入声明立即在导入上运行模块,因此 ab 的操作在 xy 的剩余之前进行。

当你运行一个脚本 - 无论你命名什么 - 翻译者称之为“__main__”,使它成为主或“家”脚本,在运行一个外部脚本后返回。

下面的两行意味着:“如果这是“__main__”或“home”脚本,执行称为main()的函数”。这就是为什么你会看到一个 def main():锁上顶部,其中包含脚本的功能的主要流。

為什麼要實施這一點?

但代码在没有它的情况下工作。

短答

它是字符串代码,保护用户在他们不打算时偶然提起脚本,这里有一些常见问题,当警卫被忽略了一个脚本:

长答

每当Python翻译器阅读源文件时,它都会做两件事:

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

让我们使用一个稍微不同的代码样本来探索进口和脚本是如何工作的。

# 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 foo.py

# 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

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

如果您的模块是主要程序,那么它会看到 __name__ 实际上设置为“__main__”并称为两个功能,打印线“函数 A”和“函数 B 10.0”。

只有当您的模块被另一个模块进口时

总是

它将在两种情况下打印“ __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

為什麼它會這樣工作?

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

# 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时,本地 __name__ 变量被分配为 __main__ 的值。 同样,当您从命令行中执行一个Python 模块时,而不是将其导入到另一个模块时,其 __name__ 属性被分配为 __main__ 的值,而不是模块的实际名称。

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.

我们看到是否 __name__ ==“__main__”:相当常见。

它检查一个模块是否正在进口。

换句话说,如果区块内部的代码只有当代码直接运行时才会执行。

让我们看看它使用一个简单的代码打印模块的名称:

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

当我们模块(M.py)中有某些声明时,我们希望当它作为主要(不进口)运行时,我们可以将这些声明(测试文件夹、印刷声明)置于此下,如果它被阻止。

默认情况下(当模块作为主运行时,不进口) __name__ 变量设置为“__main__”,当它被进口时, __name__ 变量将获得不同的值,最有可能是模块的名称(“M”)。

简而言之,使用这个“如果 __name__ ==“主””块,以防止(一定)代码在模块进口时运行。

如果 __name__ ==“__main__”是当脚本从(说)命令线运行时运行的部分,使用像 python myscript.py 这样的命令。