파이썬 인터프리터는 소스 파일을 읽을 때마다 다음 두 가지를 수행합니다.

• 와 같은 몇 가지 특수 변수를 설정 한 __name__다음

• 파일에서 찾은 모든 코드를 실행합니다.

이것이 어떻게 작동하고 __name__파이썬 스크립트에서 항상 볼 수 있는 검사 에 대한 질문과 어떻게 관련되는지 봅시다 .

코드 샘플

약간 다른 코드 샘플을 사용하여 가져 오기 및 스크립트 작동 방식을 살펴 보겠습니다. 다음 파일이 파일에 있다고 가정하십시오 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 interpeter는 소스 파일을 읽을 때 먼저 몇 가지 특수 변수를 정의합니다. 이 경우 __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"import 문에서 __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__파이썬에서 문자열을 가져 와서 실제 가져 오기를 트리거하는 저수준 함수입니다).

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")

3. 문자열을 인쇄합니다 "before functionA".

4. def블록을 실행하여 함수 객체를 만든 다음 해당 함수 객체를이라는 변수에 할당합니다 functionA.

5. 문자열을 인쇄합니다 "before functionB".

6. 두 번째 def블록을 실행하여 다른 함수 객체를 만든 다음이라는 변수에 할당합니다 functionB.

7. 문자열을 인쇄합니다 "before __name__ guard".

모듈이 메인 프로그램 인 경우에만

8. 모듈이 주 프로그램 인 경우 __name__실제로 설정되어 있음을 확인 "__main__"하고 문자열 "Function A"및을 인쇄하는 두 가지 함수를 호출합니다 "Function B 10.0".

다른 사람이 모듈을 가져 오는 경우에만

8. ( 대신 ) 모듈이 기본 프로그램이 아니지만 다른 프로그램에서 가져온 __name__경우 "foo", not "__main__"이 아니라 if명령문 본문을 건너 뜁니다 .

항상

9. "after __name__ guard"두 상황 모두 에서 문자열 을 인쇄합니다 .

요약

요약하면 다음 두 경우에 인쇄됩니다.

# What gets printed if foo is the main program
before import
before functionA
before functionB
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 functionA
before functionB
before __name__ guard
after __name__ guard

왜 이런 식으로 작동합니까?

왜 누군가가 이것을 원하는지 궁금 할 것입니다. 글쎄, 때로는 .py다른 프로그램이나 모듈에서 모듈로 사용할 수 있는 파일 을 작성 하고 주 프로그램 자체로 실행할 수도 있습니다. 예 :

• 모듈은 라이브러리이지만 일부 단위 테스트 또는 데모를 실행하는 스크립트 모드를 원합니다.

• 모듈은 기본 프로그램으로 만 사용되지만 몇 가지 단위 테스트가 있으며 테스트 프레임 워크는 .py스크립트와 같은 파일 을 가져오고 특수 테스트 기능을 실행하여 작동합니다. 모듈을 가져 오기 때문에 스크립트를 실행하려고하지 않습니다.

• 모듈은 주로 기본 프로그램으로 사용되지만 고급 사용자를위한 프로그래머 친화적 인 API도 제공합니다.

이 예제 외에도 Python에서 스크립트를 실행하는 것은 몇 가지 마법 변수를 설정하고 스크립트를 가져 오는 것만으로도 우아합니다. 스크립트를 “실행 중”은 스크립트 모듈을 가져 오는 데 따른 부작용입니다.

생각할 거리

• 질문 : __name__검사 블록 을 여러 개 가질 수 있습니까 ? 답 : 그렇게하는 것이 이상하지만 언어는 당신을 막을 수 없습니다.

• 다음에 있다고 가정합니다 foo2.py. python foo2.py명령 행에서 말하면 어떻게됩니까 ? 왜?

# Suppose this is foo2.py.

def functionA():
    print("a1")
    from foo2 import functionB
    print("a2")
    functionB()
    print("a3")

def functionB():
    print("b")

print("t1")
if __name__ == "__main__":
    print("m1")
    functionA()
    print("m2")
print("t2")

• 이제 __name__체크인 을 제거하면 어떻게 될지 알아 봅니다 foo3.py.

# Suppose this is foo3.py.

def functionA():
    print("a1")
    from foo3 import functionB
    print("a2")
    functionB()
    print("a3")

def functionB():
    print("b")

print("t1")
print("m1")
functionA()
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 myscript.py

if __name__ == "__main__":
    ...

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

python mycode.py

if __name__ == '__main__':
    main()

import mycode
# ... any amount of other code
mycode.main()

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