如果__name__ ==“__ main__”：怎么办？-Java 学习之路

4503

if __name__ == "__main__": 做了什么？

# Threading example
import time, thread

def myfunction(string, sleeptime, lock, *args):
    while True:
        lock.acquire()
        time.sleep(sleeptime)
        lock.release()
        time.sleep(sleeptime)

if __name__ == "__main__":
    lock = thread.allocate_lock()
    thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
    thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

26 回答

64
以交互方式运行Python时，将为本地 __name__ 变量分配值 __main__ . 同样，当您从命令行执行Python模块而不是将其导入另一个模块时，会为其 __name__ 属性分配值 __main__ ，而不是模块的实际名称 . 通过这种方式，模块可以查看自己的 __name__ 值，以自行确定它们的使用方式，无论是作为对另一个程序的支持还是作为从命令行执行的主应用程序 . 因此，以下习语在Python模块中很常见：
```
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.
```
回复于 2024-05-04T01:45:34+08:00

您可以将文件用作脚本以及可导入模块 .

fibo.py (a module named 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

回复于 2024-05-04T01:45:34+08:00

9

所有答案都很漂亮很多人解释了这个功能但我将提供一个使用它的例子，这可能有助于进一步清除这个概念 .

假设您有两个Python文件，a.py和b.py.现在，a.py导入b.py.我们运行a.py文件，首先执行“import b.py”代码 . 在运行其余的a.py代码之前，文件b.py中的代码必须完全运行 .

在b.py代码中，有一些代码对该文件b.py是独占的，我们不希望任何导入b.py文件的其他文件（b.py文件除外）运行它 .

这就是这行代码检查的内容 . 如果它是运行代码的主文件（即b.py），在这种情况下它不是（a.py是运行的主文件），那么只有代码被执行 .

回复于 2024-05-04T01:45:34+08:00
441
这里有很多不同的关于代码的机制，“如何”，但对我来说，除非我理解“为什么”，否则它们都没有意义 . 这应该对新程序员特别有用 .

取文件“ab.py”：
```
def a():
    print('A function in ab file');
a()
```
第二个文件“xy.py”：
```
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 时，您 import ab . import语句在导入时立即运行模块，因此 ab 的操作在 xy 的剩余部分之前执行 . 完成 ab 后，继续 xy .

解释器使用 __name__ 跟踪正在运行的脚本 . 当您运行脚本时 - 无论您将其命名为什么 - 解释器都将其命名为 "__main__" ，使其成为运行外部脚本后返回的master或'home'脚本 .

从此 "__main__" 脚本调用的任何其他脚本都将其文件名指定为 __name__ （例如， __name__ == "ab.py" ） . 因此，行 if __name__ == "__main__": 是解释器's test to determine if it'解释/解析最初执行的'home'脚本，或者直接执行's temporarily peeking into another (external) script. This gives the programmer flexibility to have the script behave differently if it'对外部调用 .

让's step through the above code to understand what'发生，首先关注未缩进的行和它们在脚本中出现的顺序 . 请记住，函数 - 或 def - 阻止不要调用 . 如果嘟to自己，翻译可能会说些什么：
- 打开xy.py作为'home'文件;在 __name__ 变量中将其命名为 "__main__" .
- 使用 __name__ == "ab.py" 导入并打开文件 .
- 哦，一个功能 . 我会记得的 .
- 好的，功能 a() ;我刚学会了这个 . 打印'ab文件中的函数' .
- 文件结束;回到 "__main__" ！
- 哦，一个功能 . 我会记得的 .
- 另一个 .
- 功能 x() ;好的，打印'外围任务：可能在其他项目中很有用' .
- 这是什么？ if 陈述 . 好吧，条件已经满足（变量 __name__ 已设置为 "__main__" ），所以我将进入 main() 函数并打印'main函数：这就是动作的位置' .
底部两行表示：“如果这是 "__main__" 或'home'脚本，请执行名为 main() 的函数” . 那个's why you'将看到一个 def main(): 块顶部，其中包含脚本功能的主要流程 .

为什么要实现这个？

还记得我之前说的关于import语句的内容吗？当您导入模块时，它不会识别它并等待进一步的指令 - 它实际上运行脚本中包含的所有可执行操作 . 因此，将脚本的内容放入 main() 函数会有效隔离它，将其置于隔离状态，以便在由另一个脚本导入时不会立即运行 .

同样，会有例外情况，但通常的做法是 main() 不会调用 main() ，我们为什么要调用脚本呢？它's because many people structure their scripts with standalone functions that are built to be run independent of the rest of the code in the file. They'然后在脚本的主体中的其他地方调用 . 这让我想到了这个：

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

恩，那就对了 . 这些单独的函数 can 可以从不包含在 main() 函数中的内联脚本调用 . 如果你再次需要那个操作的话，你会再试一次......好吧，你的构建起来更复杂，而且阅读起来也不那么直观 .

但这是一个可能无法在外部调用其函数的脚本，因为如果这样做，它会立即开始计算和分配变量 . 如果你正在尝试重新使用某个函数，那么你的新脚本可能与旧版本密切相关，而且会有相互矛盾的变量 .

在拆分独立函数时，您可以通过将它们调用到另一个脚本来重用以前的工作 . 例如，"example.py"可能导入"xy.py"并调用 x() ，利用"xy.py"中的'x'函数 . （也许它正在大写给定文本字符串的第三个单词;从数字列表中创建NumPy数组并将它们平方;或者去除3D表面的去除 . 可能性是无限的 . ）

（顺便说一句，this question包含@kindall的答案，最终帮助我理解 - 为什么，而不是如何 . 不幸的是，它被标记为this one的副本，我认为这是一个错误 . ）
回复于 2024-05-04T01:45:34+08:00
18
创建一个文件 a.py ：
```
print(__name__) # It will print out __main__
```
__name__ 始终等于 __main__ ，只要该文件为 run directly ，表明这是主文件 .

在同一目录中创建另一个文件 b.py ：
```
import a  # Prints a
```
运行 . 它将打印 a ，即 is imported 的文件名 .

所以，要显示 two different behavior of the same file ，这是一个常用的技巧：
```
# Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly
```
回复于 2024-05-04T01:45:34+08:00
595
系统（Python解释器）为源文件（模块）提供了许多变量 . 您可以随时获取其值，因此，让我们关注 name 变量/属性：

当Python加载源代码文件时，它会执行其中的所有代码 . （请注意，它不会调用文件中定义的所有方法和函数，但它会定义它们 . ）

在解释器执行源代码文件之前，它为该文件定义了一些特殊变量; name 是Python为每个源代码文件自动定义的特殊变量之一 .

如果Python将此源代码文件作为主程序（即您运行的文件）加载，则它会将此文件的特殊 name 变量设置为值 "main" .

如果从其他模块导入，则 name 将设置为该模块的名称 .

所以，在你的例子中：
```
if __name__ == "__main__":
   lock = thread.allocate_lock()
   thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
   thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
```
意味着代码块：
```
lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
```
只有在你直接运行模块时才会执行;如果另一个模块正在调用/导入它，则代码块将不会执行，因为 name 的值在该特定实例中不等于“ main ” .

希望这会有所帮助 .
回复于 2024-05-04T01:45:34+08:00
97
当Python解释器读取源文件时，它会执行其中的所有代码 .

在执行代码之前，它将定义一些特殊变量 . 例如，如果Python解释器将该模块（源文件）作为主程序运行，则它将特殊 __name__ 变量设置为具有值 "__main__" . 如果从另一个模块导入此文件，则 __name__ 将设置为模块的名称 .

在你的脚本的情况下，让我们假设它作为主要功能执行，例如你说的话
```
python threading_example.py
```
在命令行上 . 设置特殊变量后，它将执行 import 语句并加载这些模块 . 然后它将评估 def 块，创建一个函数对象并创建一个名为 myfunction 的变量，该变量指向函数对象 . 然后它将读取 if 语句并看到 __name__ 确实等于 "__main__" ，因此它将执行那里显示的块 .

这样做的一个原因是，有时您可以编写一个模块（ .py 文件），直接执行该模块 . 或者，它也可以导入并在另一个模块中使用 . 通过执行主检查，您可以仅在希望将模块作为程序运行时执行该代码，而在有人只想导入模块并自行调用函数时不执行该代码 .

有关其他详细信息，请参阅this page .

Note （由Stainsor提供）：如果将代码放在函数定义之前，它将在main之前执行 .
```
print("This code executes before main.") 

def functionA():
    print("Function A")

def functionB():
    print("Function B")

if __name__ == '__main__':
    functionA()
    functionB()
```
如果此模块确实是主模块，则此代码会导致：
```
This code executes before main. 
Function A 
Function B
```
如果这个模块不是主要的，你得到：
```
This code executes before main.
```
回复于 2024-05-04T01:45:34+08:00
31
如果__name__ ==“__ main__”怎么办？

__name__ 是一个全局变量（在Python中，全局实际上意味着在module level上），它存在于所有名称空间中 . 它通常是模块的名称（作为 str 类型） .

但是，作为唯一的特殊情况，无论你在哪个Python进程中运行，如在mycode.py中：
```
python mycode.py
```
否则匿名全局命名空间的 '__main__' 值被赋予其 __name__ .

因此，包括the final lines
```
if __name__ == '__main__':
    main()
```
- 在mycode.py脚本的末尾，
- 当它是由Python进程运行的主要入口点模块时，
将导致脚本的唯一定义 main 函数运行 .

使用此构造的另一个好处是：您还可以将代码作为模块导入另一个脚本中，然后在程序决定时运行main函数：
```
import mycode
# ... any amount of other code
mycode.main()
```
回复于 2024-05-04T01:45:34+08:00
18
如果name =='main'：

我们经常看到 __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__
```
回复于 2024-05-04T01:45:34+08:00
12

当我们的模块中有某些语句（ M.py ）时，我们希望在它作为main（未导入）运行时执行，我们可以将这些语句（测试用例，打印语句）放在这个 if 块下 .

默认情况下（当模块作为main运行，而不是导入时） __name__ 变量设置为 "__main__" ，当它被导入时， __name__ 变量将获得不同的值，很可能是模块的名称（ 'M' ） . 这有助于将模块的不同变体一起运行，并分离它们的特定输入和输出语句，以及是否存在任何测试用例 .

In short ，使用此“ if __name__ == "main" ”块可防止在导入模块时运行（某些）代码 .

回复于 2024-05-04T01:45:34+08:00
1551
在解释有关 if __name__ == '__main__' 的任何内容之前，了解 __name__ 是什么以及它的作用非常重要 .

__name__是什么？

__name__ 是DunderAlias - 可以被认为是一个全局变量（可以从模块访问），并且以与global类似的方式工作 .

它是一个字符串（如上所述的全局），由 type(__name__) （产生 <class 'str'> ）表示，并且是Python 3和Python 2版本的内置标准 .

哪里：

它不仅可以在脚本中使用，还可以在解释器和模块/包中找到 .

Interpreter:
```
>>> print(__name__)
__main__
>>>
```
Script:

test_file.py：
```
print(__name__)
```
导致 __main__

Module or package:

somefile.py：
```
def somefunction():
    print(__name__)
```
test_file.py：
```
import somefile
somefile.somefunction()
```
导致 somefile

请注意，在包或模块中使用时， __name__ 将获取文件的名称 . 没有给出实际模块或包路径的路径，但是它有自己的DunderAlias __file__ ，允许这样做 .

您应该看到， __name__ ，其中主文件（或程序）将始终返回 __main__ ，如果它是模块/包，或任何其他Python脚本运行，将返回文件的名称它起源于哪里 .

实践：

作为变量意味着它的值可以被覆盖（"can"并不意味着"should"），覆盖 __name__ 的值将导致缺乏可读性 . 所以不要出于任何原因这样做 . 如果需要变量定义新变量 .

始终假定 __name__ 的值为 __main__ 或文件名 . 再次更改此默认值将导致更多的混淆，它将做好，导致进一步的问题 .

例：
```
>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>
```
一般认为在脚本中包含 if __name__ == '__main__' 是一种好习惯 .

现在回答如果__name__ =='__ main__'：

现在我们知道_135052事情的行为变得更加清晰了：

if是一个流控制语句，如果给定的值为true，则包含将执行的代码块 . 我们已经看到 __name__ 可以使用 __main__ 或从中导入的文件名 .

这意味着如果 __name__ 等于 __main__ ，那么该文件必须是主文件并且必须实际运行（或者它是解释器），而不是导入到脚本中的模块或包 .

如果确实 __name__ 确实取 __main__ 的值，那么该代码块中的任何内容都将执行 .

这告诉我们如果运行的文件是主文件（或者您直接从解释器运行），那么必须执行该条件 . 如果它是一个包，那么它不应该，并且该值不会是 __main__ .

模块：

__name__ 也可以在模块中用于定义模块的名称

变种：

使用 __name__ 也可以做其他不太常见但有用的事情，我将在这里展示一些：

Executing only if the file is a module or package:
```
if __name__ != '__main__':
    # Do some useful things
```
Running one condition if the file is the main one and another if it is not:
```
if __name__ == '__main__':
    # Execute something
else:
    # Do some useful things
```
您还可以使用它在包和模块上提供可运行的帮助功能/实用程序，而无需精心使用库 .

它还允许模块作为主脚本从命令行运行，这也非常有用 .
回复于 2024-05-04T01:45:34+08:00
43
的原因
```
if __name__ == "__main__":
    main()
```
主要是为了避免having code directly imported引起的_135095问题 . 如果您的文件被直接调用（这是 __name__ == "__main__" 情况），您希望 main() 运行，但如果您的代码已导入，则导入器必须从真正的主模块输入您的代码以避免导入锁定问题 .

副作用是您自动登录支持多个入口点的方法 . 您可以使用 main() 作为入口点来运行程序，但您不必这样做 . 虽然 setup.py 期望 main() ，但其他工具使用备用入口点 . 例如，要将文件作为 gunicorn 进程运行，请定义 app() 函数而不是 main() . 与 setup.py 一样， gunicorn 导入您的代码，因此您不会导入't want it do do anything while it'（因为导入锁定问题） .
回复于 2024-05-04T01:45:34+08:00
32
在本页的答案中，我一直在阅读这么多内容 . 我会说，如果你知道这件事，肯定会理解那些答案，否则，你仍然感到困惑 .

简而言之，您需要了解以下几点：
- import a 动作实际上运行了"a"中可以运行的所有动作
- 由于第1点，您可能不希望在导入时在“a”中运行所有内容
- 要解决第2点中的问题，python允许您进行条件检查
- __name__ 是所有.py模块中的隐式变量;导入a.py时，a.py模块的 __name__ 的值设置为其文件名"a";当a.py直接使用"python a.py"运行时，这意味着a.py是入口点，那么a.py模块的 __name__ 的值被设置为字符串 __main__
- 基于python为每个模块设置变量 __name__ 的机制，你知道如何实现第3点吗？答案很简单，对吧？放一个if条件： if __name__ == "__main__": ... ;您甚至可以根据您的功能需要放置 __name__ == "a"
python特别重要的是第4点！其余的只是基本逻辑 .
回复于 2024-05-04T01:45:34+08:00
27
通过将脚本作为命令传递给Python解释器来运行脚本时，
```
python myscript.py
```
处于缩进级别0的所有代码都将被执行 . 已定义的函数和类已定义，但它们的代码都不会运行 . 与其他语言不同，没有 main() 函数可以自动运行 - main() 函数隐含了顶层的所有代码 .

在这种情况下，顶级代码是 if 块 . __name__ 是一个内置变量，其值为当前模块的名称 . 但是，如果直接运行模块（如上面的 myscript.py ），则 __name__ 将设置为字符串 "__main__" . 因此，您可以通过测试来测试脚本是直接运行还是由其他内容导入
```
if __name__ == "__main__":
    ...
```
如果您的脚本被导入到另一个模块中，它的各种函数和类定义将被导入并且它的顶级代码将被执行，但上面 if 子句的then-body中的代码将不会作为条件运行没有得到满足 . 作为基本示例，请考虑以下两个脚本：
```
# 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__" .
回复于 2024-05-04T01:45:34+08:00
19
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会话，即解释器的Read，Eval，Print Loop或REPL）中，您运行的是 "__main__" 中的所有内容 .

所以如果你在执行前检查：
```
if __name__ == "__main__":
    do_important()
```
通过上述操作，您的代码将仅在您将其作为主模块运行时执行（或有意从其他脚本调用它） .

更好的方式

不过，有一种Pythonic方法可以改进 .

如果我们想从模块外部运行此业务流程怎么办？

如果我们在我们开发和测试这样的函数时放置我们想要运用的代码，然后在我之后立即检查 '__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()
```
This idiom can also be found in the Python documentation in an explanation of the main module.该文字说明：

此模块表示解释程序主程序执行的（否则为匿名）作用域 - 从标准输入，脚本文件或交互式提示读取命令 . 正是在这种环境中，惯用的“条件脚本”节导致脚本运行：if name =='__ main__'：
主要（）
回复于 2024-05-04T01:45:34+08:00
16
考虑：
```
if __name__ == "__main__":
    main()
```
它检查Python脚本的 __name__ 属性是否为 "__main__" . 换句话说，如果程序本身被执行，该属性将是 __main__ ，因此程序将被执行（在这种情况下是 main() 函数） .

但是，如果模块使用Python脚本，则会执行 if 语句之外的任何代码，因此 if \__name__ == "\__main__" 仅用于检查程序是否用作模块，因此决定是否运行代码 .
回复于 2024-05-04T01:45:34+08:00
8
从命令行调用Python文件时，这是一个特殊的功能 . 这通常用于调用“main（）”函数或执行其他适当的启动代码，例如命令行参数处理 .

它可以用几种方式编写 . 另一个是：
```
def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()
```
我并不是说你应该在生产环境代码中使用它，但它可以说明没有"magical"关于 if __name__ == '__main__' . 在Python文件中调用main函数是一个很好的约定 .
回复于 2024-05-04T01:45:34+08:00
2

我认为最好用深入简单的方式打破答案：

__name__ ：Python中的每个模块都有一个名为 __name__ 的特殊属性 . 它是一个内置变量，它返回模块的名称 .

__main__ ：与其他编程语言一样，Python也有一个执行入口点，即main . '__main__' 是顶级代码执行的范围的名称 . 基本上，您有两种使用Python模块的方法：直接将其作为脚本运行，或者导入它 . 当模块作为脚本运行时，其 __name__ 设置为 __main__ .

因此，当模块作为主程序运行时， __name__ 属性的值设置为 __main__ . 否则， __name__ 的值将设置为包含模块的名称 .

回复于 2024-05-04T01:45:34+08:00
2
简而言之， __name__ 是为每个脚本定义的变量，用于定义脚本是作为主模块运行还是作为导入模块运行 .

所以，如果我们有两个脚本;
```
#script1.py
print "Script 1's name: {}".format(__name__)
```
和
```
#script2.py
import script1
print "Script 2's name: {}".format(__name__)
```
执行script1的输出是
```
Script 1's name: __main__
```
执行script2的输出是：
```
Script1's name is script1
Script 2's name: __main__
```
如您所见， __name__ 告诉我们哪个代码是'main'模块 . 这很好，因为你可以只编写代码而不必担心C / C中的结构问题，如果文件没有实现'main'函数那么它就不能被编译为可执行文件，如果是，它就不能然后用作图书馆 .

假设您编写了一个Python脚本，它可以执行一些非常棒的操作，并且可以实现一系列对其他用途有用的函数 . 如果我想使用它们，我可以导入您的脚本并在不执行程序的情况下使用它们（假设您的代码仅在 if __name__ == "__main__": 上下文中执行） . 而在C / C中，您必须将这些部分分成一个单独的模块，然后包含该文件 . 想象下面的情况;

箭头是导入链接 . 对于每个试图包含前面的模块代码的三个模块，有六个文件（九个，计算实现文件）和五个链接 . 这使得很难将其他代码包含到C项目中，除非它专门编译为库 . 现在想象一下Python：

您编写了一个模块，如果有人想使用您的代码，他们只需导入它， __name__ 变量可以帮助将程序的可执行部分与库部分分开 .
回复于 2024-05-04T01:45:34+08:00
1
if __name__ == "__main__": 基本上是顶级脚本环境，它指定了解释器（'I have the highest priority to be executed first'） .

'__main__' 是顶级代码执行的范围的名称 . 从标准输入，脚本或交互式提示中读取时，模块的 __name__ 设置为 '__main__' .
```
if __name__ == "__main__":
    # Execute only if run as a script
    main()
```
回复于 2024-05-04T01:45:34+08:00
1
这个答案适用于学习Python的Java程序员 . 每个Java文件通常都包含一个公共类 . 您可以通过两种方式使用该类：
- 从其他文件调用该类 . 你只需要在调用程序中导入它 .
- 出于测试目的，单独运行类 .
对于后一种情况，该类应包含一个public static void main（）方法 . 在Python中，此目的由全局定义的标签 '__main__' 提供 .
回复于 2024-05-04T01:45:34+08:00
54

if __name__ == "__main__" 是使用 python myscript.py 之类的命令从命令行运行脚本时运行的部分 .

回复于 2024-05-04T01:45:34+08:00
22
让我们以更抽象的方式看待答案：

假设我们在x.py中有这个代码：
```
...
<Block A>
if __name__ == '__main__':
    <Block B>
...
```
当我们运行“x.py”时，块A和B运行 .

但是当我们运行另一个模块时，只运行块A（而不是B），例如“y.py”，其中导入x.y并运行代码从那里（就像从y.py调用“x.py”中的函数时） .
回复于 2024-05-04T01:45:34+08:00
4811
__name__ 变量（imho）的最简单解释如下：

创建以下文件 .
```
# a.py
import b
```
和
```
# b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__
```
运行它们会得到这个输出：
```
$ python a.py
Hello World from b!
```
如您所见，在导入模块时，Python会将此模块中的 globals()['__name__'] 设置为模块的名称 .
```
$ python b.py
Hello World from __main__!
Hello World again from __main__!
```
如您所见，当执行文件时，Python将此文件中的 globals()['__name__'] 设置为 "__main__" .
回复于 2024-05-04T01:45:34+08:00
8
考虑：
```
print __name__
```
上面的输出是 __main__ .
```
if __name == "__main__":
  print "direct method"
```
以上陈述为真，并打印"direct method" . 假设他们在其他类中导入了这个类，它不会打印"direct method"因为，在导入时，它会设置 __name__ equal to "firstmodel name" .
回复于 2024-05-04T01:45:34+08:00
3

如果此.py文件由其他.py文件导入，则不会执行“if语句”下的代码 .

如果此.py由shell下的 python this_py.py 运行，或者在Windows中双击 . "the if statement"下的代码将被执行 .

它通常是为测试而编写的 .

回复于 2024-05-04T01:45:34+08:00

如果__name__ ==“__ main__”：怎么办？

26 回答

如果name =='main'：

开发和测试您的代码

问题

更好的方式

更好的方式

相关问题

如果name ==“ main”：怎么办？