简单地说,它是运行文件的入口点,就像 main 在 C类 编程语言。

如果python解释器正在运行一个特定的模块,那么 __name__ 全局变量将具有值 "__main__"

  def a():
      print("a")
  def b():
      print("b")

  if __name__ == "__main__": 

          print ("you can see me" )
          a()
  else: 

          print ("You can't see me")
          b()

当你运行这个脚本时 你可以看到我

一

如果你导入这个文件,比如说A到文件B,然后执行文件B if __name__ == "__main__" 在文件A中变为假,所以它会打印 你看不见我

乙

所有的答案几乎都解释了这个功能但我将提供一个使用它的例子,这可能有助于进一步澄清这个概念。

假设您有两个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),而在本例中不是(a.py是运行的主文件),则只执行代码。

如果 名称 == ' 主要 ':

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

创建一个文件, a.py公司 :

print(__name__) # It will print out __main__

__name__ 总是等于 __main__ 无论什么时候 直接运行 显示这是主文件。

创建另一个文件, b.py公司 ,在同一目录中:

import a  # Prints a

运行它它会打印出来 一 ,即 是进口的 .

所以,为了显示 同一文件的两种不同行为 ,这是一个常用的技巧:

# Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly

python中的每个模块都有一个称为 名称 . 价值 名称 属性为' 主要的 '当模块直接运行时。否则 名称 是模块的名称。

简而言之就是一个小例子。

#Script test.py

apple = 42

def hello_world():
    print("I am inside hello_world")

if __name__ == "__main__":
    print("Value of __name__ is: ", __name__)
    print("Going to call hello_world")
    hello_world()

我们可以直接执行

python test.py  

输出

Value of __name__ is: __main__
Going to call hello_world
I am inside hello_world

现在假设我们从其他脚本调用上面的脚本

#script external_calling.py

import test
print(test.apple)
test.hello_world()

print(test.__name__)

当你执行这个

python external_calling.py

输出

42
I am inside hello_world
test

因此,上面的内容不言而喻,当您从其他脚本调用test时,if循环 名称 在test.py中将不执行。

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

如果这个.py被运行 python this_py.py 在shell下,或在Windows中双击。将执行“if语句”下的代码。

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

这个答案是给学习Python的Java程序员的。 每个Java文件通常包含一个公共类。您可以通过两种方式使用该类:

1. 从其他文件调用类。你只需要把它导入到调用程序中。

2. 为了测试的目的,单独运行这个类。

对于后一种情况,该类应包含公共静态void main()方法在Python中,这个目的由全局定义的标签来实现 '__main__' .

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

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

考虑:

print __name__

上面的输出是 __main__ .

if __name__ == "__main__":
  print "direct method"

上面的陈述是真的 “直接法” . 假设他们将这个类导入到另一个类中,它不会打印 “直接法” 因为在导入时 __name__ equal to "first model name" .

原因

if __name__ == "__main__":
    main()

主要是为了避免 import lock 可能产生的问题 having code directly imported . 你想要的 main() 如果直接调用了您的文件(即 __name__ == "__main__" 但如果您的代码是导入的,则导入程序必须从真正的主模块输入您的代码,以避免导入锁定问题。

一个副作用是自动登录到支持多个入口点的方法。您可以使用 主() 作为切入点, 但你不必 . 当 setup.py 期望 主() ,其他工具使用备用入口点例如,以 gunicorn 过程,定义 app() 函数而不是 主() . 就像 安装程序.py , 古尼孔 导入您的代码,以便您不希望它在导入时执行任何操作(因为导入锁定问题)。

我在这一页的答案里读了这么多我想说,如果你知道这件事,你肯定会明白那些答案,否则,你仍然困惑。

简而言之,你需要知道以下几点:

1. import a action实际上运行“a”中可以运行的所有内容

2. 由于第1点的原因,您可能不希望在导入时所有内容都在“a”中运行

3. 为了解决第2点中的问题,python允许您进行条件检查

4. __name__ 是所有.py模块中的隐式变量;当导入.py时 __姓名__ 将a.py模块的值设置为其文件名“a”;当使用“python a.py”直接运行a.py时,这意味着a.py是入口点,则 __姓名__ .py模块设置为字符串 __main__

5. 基于python设置变量的机制 __姓名__ 对于每个模块,你知道如何达到第3点吗?答案很简单,对吧设置if条件: if __name__ == "__main__": ... ;你甚至可以把 __name__ == "a" 根据你的功能需要

python在第4点是特别的剩下的只是基本的逻辑。

if __name__ == "__main__": 基本上是顶级脚本环境,它指定了解释器(“我有最高的优先级要先执行”)。

'__main__' 是执行顶级代码的作用域的名称模块 __name__ 设置为等于 '''.''Mi'Ny'' 从标准输入、脚本或交互提示中读取时。

if __name__ == "__main__":
    # Execute only if run as a script
    main()

系统(Python解释器)为源文件(模块)提供了许多变量你可以随时得到他们的价值观,所以,让我们关注 __姓名__ 变量/属性:

当Python加载源代码文件时,它将执行其中找到的所有代码(请注意,它不会调用文件中定义的所有方法和函数,但会定义它们。)

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

如果Python将这个源代码文件作为主程序(即您运行的文件)加载,那么它将设置 __姓名__ 变量使此文件具有值 “主要” .

如果这是从另一个模块导入的, __姓名__ 将设置为该模块的名称。

所以,在你的例子中:

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

仅当您直接运行模块时才会执行;如果另一个模块正在调用/导入它,则不会执行代码块,因为 __姓名__ 不等于“ 主要的 “在这种情况下。

希望这有帮助。

当从命令行调用Python文件时,它是一个特殊的这通常用于调用“main()”函数或执行其他适当的启动代码,例如命令行参数处理。

它可以用多种方式书写另一个是:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

我不是说你应该在产品代码中使用这个,但它可以说明没有什么“神奇的” if __name__ == '__main__' . 在Python文件中调用main函数是一个很好的约定。

我认为最好是用深入浅出的话来回答:

__name__ :Python中的每个模块都有一个名为 __姓名__ . 它是一个内置变量,返回模块的名称。

__main__ :与其他编程语言一样,Python也有一个执行入口点,即main。 '__main__' 是顶级代码在其中执行的作用域的名称 . 基本上有两种使用Python模块的方法:直接将其作为脚本运行,或者导入它当模块作为脚本运行时 __姓名__ 设置为 __主要__ .

因此 __姓名__ 属性设置为 __主要__ 当模块作为主程序运行时。否则 __姓名__ 设置为包含模块的名称。

在解释之前 if __name__ == '__main__' 重要的是要了解 __name__ 是什么,它做什么。

是什么 __姓名__ ?

__姓名__ 是一个 DunderAlias -可以将其视为全局变量(可从模块访问),其工作方式与 global .

它是一个字符串(如上所述为全局字符串),由 type(__name__) (屈服 <class 'str'> ),是两者的内置标准 Python 3 和 Python 2 版本。

哪里:

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

翻译:

>>> print(__name__)
__main__
>>>

脚本:

测试文件.py :

print(__name__)

导致 __main__

模块或包:

somefile.py文件:

def somefunction():
    print(__name__)

测试文件.py:

import somefile
somefile.somefunction()

导致 somefile

注意,当在包或模块中使用时, __姓名__ 获取文件名。未给出实际模块或包路径的路径,但有自己的DunderAlias __file__ ,这样就可以了。

你应该看看,在哪 __姓名__ ,其中主文件(或程序)将 总是 返回 __主要__ ,如果它是一个模块/包,或者任何正在运行其他Python脚本的东西,那么它将返回源文件的名称。

练习:

作为一个变量意味着它的值 可以 被覆盖(“can”不代表“should”),覆盖 __姓名__ 将导致可读性不足所以,无论如何,不要这样做。如果需要变量,请定义新变量。

通常假设 __姓名__ 成为 __主要__ 或文件名再次更改此默认值将导致更多的混淆,即它将起到良好的作用,从而进一步引发问题。

例子:

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

一般来说,包括 如果u name_uuuu='\uu main_uuu' 在剧本里。

现在回答 如果u name_uuuu='\uu main_uuu' :

现在我们知道 __姓名__ 事情变得更清楚了:

一个 if 是一个流控制语句,包含给定值为真时将执行的代码块。我们已经看到了 __姓名__ 两种都可以 __主要__ 或者从中导入的文件名。

这意味着如果 __姓名__ 等于 __主要__ 然后该文件必须是主文件,并且必须实际运行(或者它是解释器),而不是导入到脚本中的模块或包。

如果真的 __姓名__ 是否取 __主要__ 然后代码块中的任何内容都将执行。

这告诉我们,如果运行的文件是主文件(或者直接从解释器运行),则必须执行该条件如果它是一个包,那么它不应该,并且值将不是 __主要__ .

模块:

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

变体:

也可以做其他不太常见但有用的事情 __姓名__ ,一些我将在这里展示:

仅当文件是模块或包时执行:

if __name__ != '__main__':
    # Do some useful things 

如果文件是主文件,则运行一个条件;如果不是主文件,则运行另一个条件:

if __name__ == '__main__':
    # Execute something
else:
    # Do some useful things

您还可以使用它在包和模块上提供可运行的帮助函数/实用程序,而无需精心使用库。

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

考虑:

if __name__ == "__main__":
    main()

它检查 __name__ Python脚本的属性是 "__main__" . 换句话说,如果程序本身被执行,那么 __main__ ,因此程序将被执行(在本例中 main() 功能)。

但是,如果Python脚本由模块使用,则 if 语句将被执行,因此 if \__name__ == "\__main__" 仅用于检查程序是否用作模块,因此决定是否运行代码。

当您以交互方式运行Python时 __name__ 变量被赋值为 __main__ . 同样,当您从命令行执行一个Python模块,而不是将其导入另一个模块时,它的 __姓名__ 属性的值为 __主要__ ,而不是模块的实际名称。这样,模块可以查看自己的 __姓名__ 值来自行确定如何使用它们,是作为对另一个程序的支持,还是作为从命令行执行的主应用程序。因此,以下习惯用法在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.

让我们以更抽象的方式来看待答案:

假设我们在x.py中有这个代码:

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

当我们运行“x.py”时,块A和块B运行。

但是当我们运行另一个模块“y.py”时,只运行块A(而不是块B),例如,在这个模块中,x.y被导入,代码从那里运行(就像从y.py调用“x.py”中的函数一样)。