我们看看__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__

让我们更抽象地看待答案:

假设我们有这个密码x.py:

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

区块 A 和 B 正在运行时运行x.py.

但是,在我们运行另一个模块时,只运行A区块(而不是B区块),y.py例如,x.py导入并运行代码(例如当函数在x.py调自y.py).

什么是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 会话, 即口译员的读、 Eval、 打印圈或 REPL) 内, 您正在运行来自它的一切"__main__".

如果您在执行前检查 :

if __name__ == "__main__":
    do_important()

有了以上内容, 您的代码只有在运行为主模块时才会执行( 或者故意从其它脚本中调用它 ) 。

更好的办法

不过有种共音法可以改进

如果我们想从模块之外运行这个业务流程呢?

如果我们把代码放进去, 我们想在开发过程中练习, 在这样的功能中进行测试, 然后核对'__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()

创建以下两个文件 :

# 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 设置globals()['__name__']和在b模块的模块到模块名称,b.

运行中python b.py:

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

仅在文件b.py已执行, Python 设置globals()['__name__']在此文件中的文件中"__main__"因此,if用于True这一次。

如果你是初学者 可能你现在唯一需要的答案就是此代码没有必要简单脚本的简单脚本。它只有在您想要能够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.)

我们看看__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__