这样做做什么,为什么应该包括:if语句?
if __name__ == "__main__":
print("Hello, World!")
如果你试图结束一个问题 如果你想要结束一个问题 在那里有人应该应该 使用这个学说,而不是,是不是, 考虑关闭作为 重复的为什么Python在我进口时 运行我的模块? 我该如何阻止它?。而对于某些问题,如果有人只是没有调用任何函数,或者错误地期望指定函数main自动用作切入点,使用当我启动 Python 脚本时, 主函数为何不运行? 脚本从哪里开始运行 ?.
当前回答
在解释之前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
您也可以使用它在软件包和模块上提供可运行的帮助功能/用途,而不必精密使用图书馆。
它还允许模块作为主脚本从命令行运行,这也非常有用。
其他回答
当我们的模块中有某些语句时(M.py)我们想要当它作为主(而非导入)运行时被执行, 我们可以将这些语句( 测试案例、 打印语句) 置于此下if区块。
默认值( 当模块作为主模式运行时, 不导入)__name__变量设置为"__main__",当它将进口__name__变量将获得不同的值, 最有可能是模块的名称('M'这有助于将模块的不同变量合并运行,并区分其具体的输入和输出语句,以及如果有任何测试案例的话。
简简,使用此“if __name__ == "main"防止模块导入时运行(确定)代码的块。
if __name__ == "__main__"是在脚本从命令行运行时运行的部分,使用类似命令python myscript.py.
下代码的代码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'
请注意,只有最高层print()语中的语中my_test_module执行。
第二种可能性: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'
更全面的解释,可读作:什么是什么东西if __name__ == '__main__'在 Python 中做.
创建文件,a.py , a.py , a.py , a.py , a.py , a.py , a.py , a.py:
print(__name__) # It will print out __main__
__name__始终等于__main__当该文件为直接直接运行显示此为主文件 。
创建另一个文件,b.py b.py,在同一目录中:
import a # Prints a
运行它,它会打印a,即哪个文件的名称已导入.
所以,为了展示同一文件的两种不同行为,这是一个常用的把戏:
# Code to be run when imported into another python file
if __name__ == '__main__':
# Code to be run only when run directly
保护用户在无意时不意外地引用剧本的锅炉牌代码。 当剧本遗漏了警卫时, 这里有一些常见的问题:
如果您在另一个脚本中导入了无保护脚本(例如 ) 。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"
设置特殊变量后, 口译员将执行模块中的所有代码, 一次执行一个语句。 您可能想要用代码样本在侧面打开另一个窗口, 以便您可以随此解释一起执行 。
总是
它印着弦"before import"(没有引文)。
里面装满了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")
它印着弦"before function_a".
它执行def键,创建函数对象,然后将该函数对象指定给一个被称作变量的变量function_a.
它印着弦"before function_b".
它执行第二个def键,创建另一个函数对象,然后将其指派到一个被调用的变量function_b.
它印着弦"before __name__ guard".
只有当您的模块是主程序时
__name__确实设定"__main__"它调用两个功能, 打印字符串"Function A"和"Function B 10.0".只有当您的模块被另一个模块导入时
__name__将"foo",而不是"__main__"它会跳过if语句。总是
"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")
