简言之:

您所看到的代码下面的代码if __name__ == "__main__":只有当您的 Python 文件被执行时才会被调用 。python example1.py

但是,如果您想要导入您的 Python 文件example1.py以模块的形式使用另一个 Python 文件, 例如example2.py下的代码if __name__ == "__main__":将不会运行或产生任何效果。

短答

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

• 如果您在另一个脚本中导入了无保护脚本(例如 ) 。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")

当执行 Python 文件时, 它会创建许多特殊的变量, 例如__name__变量__name__您问题的答案是:

if __name__ == "__main__":
       # Do something

这意味着,如果所执行的文件的名称作为源文件运行,并且非模块然后它会运行里面的代码。 这可以用简单的示例来证明。 创建两个 Python 文件,foo.py和second.py。然后在foo.py,类型如下:

if __name__ == "__main__":
       print("file is not imported")
else:
       print("file is imported")

和在second.py,类型如下:

import foo

if foo.__name__ == "__main__":
       print("file is not imported")
else:
       print("file is imported")

除此以外,如果你们要这样做,print(__name__)然后将打印__main__为什么?

因为文件以主要源代码,如果你愿意print(foo.__name__)将打印fuo fuo的默认值,因为__name__变量是文件的名称,默认是文件的默认名称,我的意思是,您也可以更改它。要做到这一点,只需去foo.py并做此操作的文件 :__name__ = "name"。然后当你运行文件,例如,

__name__ = "Hello, World!"
print(__name__)

然后产出将是:

Hello, World!

当您的脚本作为命令传递给 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__使用此简单示例 :

创建创建文件1. py

if __name__ == "__main__":
    print("file1 is being run directly")
else:
    print("file1 is being imported")

创建 *file2。平平

import file1 as f1

print("__name__ from file1: {}".format(f1.__name__))
print("__name__ from file2: {}".format(__name__))

if __name__ == "__main__":
    print("file2 is being run directly")
else:
    print("file2 is being imported")

执行文件2. py

Output:

file1 is being imported
__name__ from file1: file1
__name__ from file2: __main__
file2 is being run directly

在解释之前if __name__ == '__main__'了解什么是__name__和它的作用。

什么是__name__?

__name__是 a 是达德阿里亚斯Name- 可被视为全球变量(可从模块中获取),工作方式与global.

它是一个字符串(如上所述,全球范围),如下文所示:type(__name__)(年均(年均)<class 'str'>),而两者都是一个内在的标准,Python 3和Python 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” 并不意味着“sh') , 覆盖__name__将会导致缺乏可读性。 所以无论出于什么原因都不要这样做。 如果您需要变量定义新的变量, 请定义新的变量 。

人们总是认为,人们总是认为,__name__待 待 待 待 待 待 待 待__main__或文件的名称。 再次更改此默认值将会造成更多的混乱, 从而导致问题更加严重 。

示例:

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

一般认为良好做法包括:if __name__ == '__main__'在脚本中。

现在回答if __name__ == '__main__':

现在我们知道__name__(b) 使情况更加明确:

A 音 Aif是一个流量控制语句,其中含有如果给定值是真实的将执行的代码块块。我们已经看到__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

您也可以使用它在软件包和模块上提供可运行的帮助功能/用途,而不必精密使用图书馆。

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