Python 如果“你的名字”是什么意思__主要内容:做
给定以下代码,如果uuu name uuu==“uuuu main uuu”:做什么Python 如果“你的名字”是什么意思__主要内容:做,python,namespaces,main,python-module,idioms,Python,Namespaces,Main,Python Module,Idioms,给定以下代码,如果uuu name uuu==“uuuu main uuu”:做什么 # Threading example import time, thread def myfunction(string, sleeptime, lock, *args): while True: lock.acquire() time.sleep(sleeptime) lock.release() time.sleep(sleepti
# 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))
如果使用类似于python myscript.py的命令从(比如)命令行运行脚本时运行的部分是
,如果如果
是从(比如)命令行运行脚本时运行的部分命令行使用类似于python myscript.py的命令
# Suppose this is foo.py.
print("before import")
import math
print("before functionA")
def functionA():
print("Function A")
print("before functionB")
def functionB():
print("Function B {}".format(math.sqrt(100)))
print("before __name__ guard")
if __name__ == '__main__':
functionA()
functionB()
print("after __name__ guard")
这是一个样板代码,可以防止用户无意中调用脚本。以下是脚本中省略保护时的一些常见问题:
- 如果在另一个脚本中导入无担保脚本(例如,
导入不带\u a\u name\u eq\u main\u guard的my\u script\u
),则第二个脚本将触发第一个脚本在导入时运行,并使用第二个脚本的命令行参数。这几乎总是一个错误
- 如果在无担保脚本中有一个自定义类并将其保存到pickle文件中,则在另一个脚本中取消对其的pickle将触发无担保脚本的导入,问题与上一个项目符号中概述的相同
长话短说
为了更好地理解这一点的原因和方式,我们需要后退一步,了解Python如何初始化脚本,以及它如何与其模块导入机制交互
每当Python解释器读取源文件时,它都会做两件事:
- 它设置一些特殊变量,如
\uuuuu name\uuuuu
,然后
- 它执行文件中找到的所有代码
让我们看看这是如何工作的,以及它与您关于Python脚本中经常出现的\uuuu name\uuuu
检查的问题的关系
代码示例
让我们使用稍微不同的代码示例来探索导入和脚本是如何工作的。假设以下内容位于名为foo.py
的文件中
# Suppose this is foo.py.
print("before import")
import math
print("before functionA")
def functionA():
print("Function A")
print("before functionB")
def functionB():
print("Function B {}".format(math.sqrt(100)))
print("before __name__ guard")
if __name__ == '__main__':
functionA()
functionB()
print("after __name__ guard")
特殊变量
当Python解释器读取源文件时,它首先定义几个特殊变量。在本例中,我们关心\uuu name\uu
变量
当您的模块是主程序时
如果您将模块(源文件)作为主程序运行,例如
python foo.py
解释器将硬编码字符串“\uuuuu main\uuuuuu”
分配给\uuuuu name\uuuuuuu
变量,即
# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__"
# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"
当您的模块被其他模块导入时
另一方面,假设其他模块是主程序,它导入您的模块。这意味着在主程序或主程序导入的其他模块中有这样的语句:
# Suppose this is in some other main program.
import foo
解释器将搜索您的foo.py
文件(同时搜索一些其他变量),在执行该模块之前,解释器将把import语句中的名称“foo”
分配给\u name\u
变量,即
# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__name__ = "__main__"
# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"
执行模块的代码
设置特殊变量后,解释器执行模块中的所有代码,每次执行一条语句。您可能希望在代码示例旁边打开另一个窗口,以便按照此说明进行操作
始终
它在导入之前打印字符串”
(不带引号)
它加载math
模块并将其分配给名为math
的变量。这相当于将import math
替换为以下内容(请注意,\uuuuuu import\uuuuu
是Python中的一个低级函数,它接受字符串并触发实际导入):
它在function“
之前打印字符串
它执行def
块,创建函数对象,然后将该函数对象分配给名为function
的变量
它在functionB“
之前打印字符串
它执行第二个def
块,创建另一个函数对象,然后将其分配给名为functionB
的变量
它在
之前打印字符串
仅当您的模块是主程序时
如果您的模块是主程序,那么它将看到\uuuu name\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
仅当您的模块由其他模块导入时
(相反)如果您的模块不是主程序,而是由另一个主程序导入的,则\uuuu name\uuuuuuuuu
将是“foo”
,而不是“\uuuuu main\uuuuuuuuuu”
,如果
语句,它将跳过的主体
始终
在这两种情况下,它都会在_name _guard
之后打印字符串
摘要
总之,以下是两种情况下的打印内容:
#如果foo是主程序,会打印什么
进口前
功能前
职能B之前
在u u name _;警卫之前
功能A
功能B10.0
在“姓名”之后
#如果foo作为常规模块导入,将打印什么
进口前
功能前
职能B之前
在u u name _;警卫之前
在“姓名”之后
为什么会这样?
你可能很自然地想知道为什么有人会想要这个。有时,您需要编写一个.py
文件,该文件既可以被其他程序和/或模块用作模块,也可以作为主程序本身运行。示例:
- 您的模块是一个库,但您希望有一个脚本模式,在该模式下运行一些单元测试或演示
- 您的模块仅用作主程序,但它有一些单元测试,测试框架通过导入脚本之类的
.py
文件并运行特殊的测试函数来工作。你不知道吗
# 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
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
# 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 b.py
Hello World from __main__!
Hello World again from __main__!
def some_function_for_instance_main():
dosomething()
__name__ == '__main__' and some_function_for_instance_main()
def do_important():
"""This function does something very important"""
do_important()
~$ python important.py
import important
# do_important() # I must remember to uncomment to execute this!
if __name__ == "__main__":
do_important()
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()
import important
important.main()
if __name__ == '__main__':
main()
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.
python mycode.py
if __name__ == '__main__':
main()
import mycode
# ... any amount of other code
mycode.main()
...
<Block A>
if __name__ == '__main__':
<Block B>
...
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))
if __name__ == "__main__":
# Execute only if run as a script
main()
print __name__
if __name__ == "__main__":
print "direct method"
def a():
print('A function in ab file');
a()
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()
#script1.py
print "Script 1's name: {}".format(__name__)
#script2.py
import script1
print "Script 2's name: {}".format(__name__)
Script 1's name: __main__
Script1's name is script1
Script 2's name: __main__
# 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]))
if __name__ == "__main__":
main()
if __name__ == "__main__":
main()
print(__name__) # It will print out __main__
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
>>> print(__name__)
__main__
>>>
print(__name__)
def somefunction():
print(__name__)
import somefile
somefile.somefunction()
>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>
if __name__ != '__main__':
# Do some useful things
if __name__ == '__main__':
# Execute something
else:
# Do some useful things
# test.py
def test():
print('test module name=%s' %(__name__))
if __name__ == '__main__':
print('call test()')
test()
call test()
test module name=__main__
#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
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()
# 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')
# main.py
import my_test_module
if __name__ == '__main__':
print('Hello from main.py')
python main.py
>> 'This is going to be printed out, no matter what'
>> 'Hello from main.py'
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'