什么是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()

您可以将文件作为脚本脚本脚本和(或)可导入可导入模块.

vibbo.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

短答

保护用户在无意时不意外地引用剧本的锅炉牌代码。 当剧本遗漏了警卫时, 这里有一些常见的问题:

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

• 如果您在无警卫的脚本中有自定义类, 并将其保存为泡菜文件, 那么在另一部脚本中拆开它就会触发无警卫的脚本的输入, 与前一颗子弹中描述的相同问题 。

长答答

为了更好地了解为什么和如何看待这一问题,我们需要退一步,了解Python初始化脚本的方式,以及这如何与其模块输入机制相互作用。

Python 译员读到源文件时,

• 它设置了几个特殊的变量,比如__name__,然后

• 它执行文件中发现的所有代码。

让我们看看这是怎么回事 和它与你的问题有什么关系__name__我们总是在 Python 脚本中看到检查。

代码样本

让我们使用略微不同的代码样本来探索导入和脚本是如何工作的。 假设以下是在一个名为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"

执行模块代码

设置特殊变量后, 口译员将执行模块中的所有代码, 一次执行一个语句。 您可能想要用代码样本在侧面打开另一个窗口, 以便您可以随此解释一起执行 。

总是

1. 它印着弦"before import"(没有引文)。

2. 里面装满了math模块,然后将它指派给一个变量,该变量被称为math。这等于替换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")

3. 它印着弦"before function_a".

4. 它执行def键,创建函数对象,然后将该函数对象指定给一个被称作变量的变量function_a.

5. 它印着弦"before function_b".

6. 它执行第二个def键,创建另一个函数对象,然后将其指派到一个被调用的变量function_b.

7. 它印着弦"before __name__ guard".

只有当您的模块是主程序时

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

• 现在,找出如果你删除__name__检查中foo3.py:

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

除了已经提供的资料外,if __name__ == "__main__":技术也是确保pytest和unittest如果您不小心调用脚本, 脚本仍然在运行python代替pytest(或)python -m unittest举例来说:

def test_assert():
    assert 1 + 2 == 3

if __name__ == "__main__":
    import pytest
    pytest.main([__file__])

现在不管怎么称呼你的测试 都会在测试中进行pytest或python。在这里,这是unittest版本 :

import unittest

class Tests(unittest.TestCase):
    def test_assert(self):
        self.assertTrue(1 + 2 == 3)

if __name__ == "__main__":
    unittest.main()

然后您的脚本用python以一计号,以python -m unittest拨打。

现在,如果你也想确保 你所有的价码都通过pytest如果被召唤时python或者,如果你也想加入额外的参考物呢?

def test_assert():
    assert 1 + 2 == 3

if __name__ == "__main__":
    from pytest import main
    from sys import argv
    main([*argv, "-s"])

现在,你的python -v --html=report.html具有与pytest -v --html=report.html,等等。这是一个很好的方法,可以确保脚本仍然照原意运行, 即使没有按照预期运行pytest或python -m unittest电话

if __name__ == "__main__":无法在导入文件时运行不需要的代码 。

例如,这是test1.py无if __name__ == "__main__"::

# "test1.py"

def hello()
    print("Hello")

hello()

还有test2.py进口test1.py:

# "test2.py"

import test1 # Here

然后,当奔跑的时候,test2.py, 1个Hello打印是因为不需要的代码hello()内test1.py同时运行 :

python test2.py
Hello

当然,你可以打给test1.hello()内test2.py:

# "test2.py"

import test1

test1.hello() # Here

然后,当奔跑的时候,test2, 二Hello已经打印 :

python test2.py
Hello
Hello

现在,添加if __name__ == "__main__":至test1.py并放hello()在其之下:

# "test1.py"

def hello()
    print("Hello")

if __name__ == "__main__":
    hello()

这是test2.py:

# "test2.py"

import test1

test1.hello()

然后,当奔跑的时候,test2.py, 只有一个Hello打印是因为if __name__ == "__main__":防止要运行不需要的代码hello()何时test2.py进口进口进口test1.py:

python test2.py
Hello

此外,是否test1.py拥有if __name__ == "__main__":或非:

# "test1.py"

def hello()
    print("Hello")

if __name__ == "__main__":
    hello()

# "test1.py"

def hello()
    print("Hello")

hello()

一个Hello运行时正确打印test1.py:

python test1.py
Hello

执行模块(源文件)时如果检查模块是直接被调用还是从其它源文件调用。 这里直接表示未导入 。

如果直接被叫执行,模块名称将设置为“main”,然后在如果块将被执行。