무엇 if__name__=="__main__":니까?

Question

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

Answer 1

Python 통역사가 소스 파일을 읽을 때마다 두 가지를 수행합니다.

• 몇 가지 특수 변수를 설정합니다 __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, 벗겨냅니다 .py, 그 문자열을 모듈에 할당하십시오 __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", 아니다 "__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

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

당신은 자연스럽게 누군가가 이것을 원하는지 궁금 할 것입니다. 글쎄, 때때로 당신은 a를 쓰고 싶어합니다 .py 다른 프로그램 및/또는 모듈에서 모듈로 사용할 수 있으며 기본 프로그램 자체로도 실행할 수있는 파일. 예 :

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

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

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

그 예를 넘어서, 파이썬에서 스크립트를 실행하는 것이 몇 가지 마법 변수를 설정하고 스크립트를 가져 오는 것이 우아합니다. "실행"스크립트는 스크립트 모듈을 가져 오는 부작용입니다.

생각할 거리

• 질문 : 여러 가지 가질 수 있습니까? __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")

Answer 2

Python 통역사에게 명령으로 전달하여 스크립트를 실행하면

python myscript.py

들여 쓰기 레벨 0에있는 모든 코드가 실행됩니다. 정의 된 기능과 클래스는 잘 정의되어 있지만 코드 중 어느 것도 실행되지 않습니다. 다른 언어와 달리, 아니요 main() 자동으로 실행되는 함수 - the main() 함수는 암시 적으로 모든 코드입니다.

이 경우 최상위 코드는 an입니다 if 차단하다. __name__ 현재 모듈의 이름으로 평가되는 내장 변수입니다. 그러나 모듈이 직접 실행되는 경우 ( myscript.py 위에서), 그렇다면 __name__ 대신 문자열로 설정됩니다 "__main__". 따라서 스크립트가 직접 실행 중인지 또는 테스트를 통해 다른 것에 의해 가져 오는지 테스트 할 수 있습니다.

if __name__ == "__main__":
    ...

스크립트가 다른 모듈로 가져 오면 다양한 기능 및 클래스 정의가 가져오고 최상위 코드가 실행되지만 당시의 코드는 if 조건이 충족되지 않아 위의 절은 실행되지 않습니다. 기본적인 예로 다음 두 스크립트를 고려하십시오.

# 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__".

Answer 3

가장 간단한 설명 __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!

보시다시피 모듈이 가져 오면 파이썬이 세트됩니다. globals()['__name__'] 이 모듈에서 모듈 이름으로. 또한 가져 오면 모듈의 모든 코드가 실행 중입니다. 로서 if 진술은 평가합니다 False 이 부분은 실행되지 않습니다.

$ python b.py
Hello World from __main__!
Hello World again from __main__!

보시다시피 파일이 실행되면 파이썬이 설정됩니다. globals()['__name__'] 이 파일에서 "__main__". 이번에는 if 진술은 평가합니다 True 그리고 실행 중입니다.

Answer 4

무엇을합니까 if __name__ == "__main__": 하다?

기본 사항을 설명하려면 :

• 글로벌 변수, __name__, 프로그램의 진입 지점 인 모듈에서 '__main__'. 그렇지 않으면 모듈을 가져 오는 이름입니다.

• 따라서 코드 아래 if 블록은 모듈이 프로그램의 진입 점 인 경우에만 실행됩니다.

• 가져 오기의 코드 블록을 실행하지 않고 모듈의 코드를 다른 모듈로 가져올 수 있습니다.

---

왜 우리는 이것을 필요로합니까?

코드를 개발하고 테스트합니다

모듈로 사용하도록 설계된 파이썬 스크립트를 작성한다고 가정 해보십시오.

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 통역사가 현재 어디에 있는지 네임 스페이스를 가리 킵니다.

가져온 모듈 내에서 해당 모듈의 이름입니다.

그러나 기본 모듈 내부 (또는 대화식 파이썬 세션, 즉 통역사의 읽기, 평가, 인쇄 루프 또는 REPL) 내부에서 모든 것을 실행하고 있습니다. "__main__".

따라서 실행하기 전에 확인하면 :

if __name__ == "__main__":
    do_important()

위의 경우 코드는 기본 모듈로 실행할 때만 실행됩니다 (또는 의도적으로 다른 스크립트에서 호출).

더 나은 방법

그래도이를 향상시키는 피스닉 방법이 있습니다.

모듈 외부 에서이 비즈니스 프로세스를 실행하려면 어떻게해야합니까?

우리가 코드를 넣으면 이와 같은 기능으로 개발하고 테스트 할 때 운동을하고 싶습니다. '__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()

이 관용구는 또한 Python 문서에서 찾을 수 있습니다. __main__ 기준 치수. 그 텍스트는 다음과 같습니다.

이 모듈은 통역사의 기본 프로그램이 실행하는 (그렇지 않으면 익명) 범위를 나타냅니다 (표준 입력, 스크립트 파일 또는 대화식 프롬프트에서 명령이 읽습니다. 이 환경은 관용적 인 "조건부 스크립트"스탠자가 스크립트를 실행하게하는 환경입니다.

if __name__ == '__main__':
    main()

Answer 5

if __name__ == "__main__" 스크립트가 (say)에서 실행될 때 실행되는 부분은 명령을 사용하여 명령 줄입니다. python myscript.py.

Answer 6

무엇을 하는가 if __name__ == "__main__": 하다?

__name__ 글로벌 변수입니다 (Python에서 글로벌은 실제로 모듈 레벨) 모든 네임 스페이스에 존재합니다. 일반적으로 모듈의 이름입니다 ( str 유형).

그러나 MyCode.py에서와 같이 실행하는 파이썬 프로세스에서 유일한 특별한 경우 :

python mycode.py

그렇지 않으면 익명의 글로벌 네임 스페이스는 다음의 값이 할당됩니다. '__main__' 그것에 __name__.

따라서 마지막 줄

if __name__ == '__main__':
    main()

• mycode.py 스크립트의 끝에서
• Python 프로세스에 의해 실행되는 기본 입력 포인트 모듈 인 경우

스크립트가 고유하게 정의되어 있습니다 main 실행할 기능.

이 구성 사용의 또 다른 이점 : 다른 스크립트에서 코드로 모듈로 코드를 가져오고 프로그램이 다음과 같은 경우 기본 기능을 실행할 수도 있습니다.

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

Answer 7

문제의 코드의 역학에 대해서는 "어떻게"라는 점에 대해 여러 가지가 있습니다. 그러나 "왜"를 이해할 때까지는 아무런 의미가 없었습니다. 이것은 새로운 프로그래머에게 특히 도움이되어야합니다.

"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. 가져 오기 명세서는 즉시 가져 오기 모듈을 실행하므로 ab나머지 기기 전에 운영이 실행됩니다 xy'에스. 일단 끝났습니다 ab, 그것은 계속됩니다 xy.

통역사는 어떤 스크립트가 실행 중인지 추적합니다. __name__. 스크립트를 실행할 때 - 이름이 무엇이든 상관없이 통역사는 그것을 호출합니다. "__main__", 외부 스크립트를 실행 한 후에 반환되는 마스터 또는 '홈'스크립트로 만듭니다.

이것에서 호출되는 다른 스크립트 "__main__" 스크립트는 파일 이름으로 할당됩니다 __name__ (예 : __name__ == "ab.py"). 따라서 라인 if __name__ == "__main__": 초기에 실행 된 '홈'스크립트를 해석/파싱하는지 판단하는 통역사의 테스트 또는 다른 (외부) 스크립트로 일시적으로 엿볼 것인지 확인하는 것입니다. 이로 인해 프로그래머가 스크립트가 외부로 직접적으로 실행되면 스크립트가 다르게 행동하도록 유연하게 유연하게 만듭니다.

위의 코드를 통해 무슨 일이 일어나고 있는지 이해하고, 중단되지 않은 줄과 스크립트에 나타나는 순서에 먼저 초점을 맞추겠습니다. 그 기능을 기억하십시오 - 또는 def - 블록은 호출 될 때까지 스스로 아무것도하지 않습니다. 통역사가 스스로 중얼 거렸다면 말할 수있는 것 :

• '홈'파일로 xy.py를 엽니 다. 불러라 "__main__" 에서 __name__ 변하기 쉬운.
• 가져 오기 및 열 수 있습니다 __name__ == "ab.py".
• 오, 기능. 나는 그것을 기억할 것이다.
• 좋아, 기능 a(); 방금 배웠습니다. 인쇄 'AB 파일의 함수'.
• 파일의 끝; 돌아가다 "__main__"!
• 오, 기능. 나는 그것을 기억할 것이다.
• 다른 것.
• 기능 x(); 좋아, 인쇄 '주변 작업 : 다른 프로젝트에서 유용 할 수 있습니다'.
• 이게 뭐야? an if 성명. 조건이 충족되었습니다 (변수 __name__ 설정되었습니다 "__main__"), 그래서 입력하겠습니다 main() 기능과 인쇄 '주요 기능 : 이것은 행동이있는 곳입니다'.

하단 두 줄은 다음과 같습니다. "이것이 바로 "__main__" 또는 '홈'스크립트, main()". 그래서 당신은 당신이 볼 수있는 이유입니다 def main(): 스크립트 기능의 주요 흐름이 포함 된 차단 상단.

왜 이것을 구현합니까?

수입 명세서에 대해 앞서 말한 것을 기억하십니까? 모듈을 가져 오면 모듈을 '인식'하고 추가 지침을 기다리는 것이 아닙니다. 실제로 스크립트에 포함 된 모든 실행 가능한 작업을 실행합니다. 그래서 대본의 고기를 main() 기능적으로 검역소를 작동시켜 다른 스크립트로 가져올 때 즉시 실행되지 않도록 분리되어 있습니다.

다시 한 번 예외가 있지만 일반적인 관행은 main() 일반적으로 외부로 불려지 않습니다. 그래서 당신은 하나 더 궁금해 할 것입니다 : 우리가 전화하지 않는다면 main(), 우리는 왜 대본을 전혀 부르고 있습니까? 많은 사람들이 파일의 나머지 코드와 독립적으로 실행되도록 만들어진 독립형 기능으로 스크립트를 구성하기 때문입니다. 그들은 나중에 스크립트의 본문에있는 다른 곳에서 전화를 걸었습니다. 이것으로 나를 데려옵니다.

그러나 코드는 그것 없이는 작동합니다

네, 맞습니다. 이 별도의 기능 ~할 수 있다 내부에 포함되지 않은 인라인 스크립트에서 호출됩니다. main() 기능. 당신이 당신이 필요로하는 것을 정확하게 수행하는 인라인 스크립트를 구축하는 데 익숙하다면 (내가 프로그래밍의 초기 학습 단계에서) 익숙하다면, 그 작업이 다시 필요한 경우 다시 알아 내려고 노력할 것입니다. . 글쎄, 당신은 코드에 대한 이런 종류의 내부 구조에 익숙하지 않습니다. 왜냐하면 빌드가 더 복잡하고 읽기에 직관적이지 않기 때문입니다.

그러나 그것은 아마도 외부 적으로 불리는 함수를 가질 수없는 스크립트입니다. 왜냐하면 그것이 바로 변수를 계산하고 할당하기 시작하기 때문입니다. 그리고 함수를 재사용하려고 할 가능성이 있습니다. 새 스크립트는 변수가 상충 될 수있는 이전 스크립트와 밀접하게 관련되어 있습니다.

독립적 인 기능을 분할 할 때 이전 작품을 다른 스크립트로 호출하여 이전 작품을 재사용 할 수 있습니다. 예를 들어, "example.py"는 "xy.py"를 가져 와서 호출 할 수 있습니다. x(), "xy.py"에서 'x'함수를 사용합니다. (아마도 주어진 텍스트 문자열의 세 번째 단어를 대문자로 만들고, 숫자 목록에서 낭비가 많은 배열을 만들거나 제곱하거나 3D 표면을 훼손합니다. 가능성은 무한합니다.)

(여담으로, 이 질문 @kindall의 답변을 포함하여 마침내 내가 이해하는 데 도움이되었습니다. 불행히도 그것은 복제본으로 표시되었습니다 이 하나, 나는 실수라고 생각합니다.)

Answer 8

우리 모듈에 특정 진술이있을 때 (M.py) 우리는 메인으로 실행될 때 실행되기를 원합니다 (수입되지 않음). if 차단하다.

기본적으로 (모듈이 메인으로 실행되고 가져 오지 않은 경우) __name__ 변수가 설정됩니다 "__main__", 그리고 그것이 수입 될 때 __name__ 변수는 다른 값, 아마도 모듈의 이름 일 것입니다 ('M'). 이는 모듈의 다른 변형을 함께 실행하고 특정 입력 및 출력 명령문을 분리하고 테스트 케이스가있는 경우에도 도움이됩니다.

요컨대, 이것을 사용하십시오 'if __name__ == "main" '모듈이 가져 오면 (특정) 코드가 실행되는 것을 방지하는 블록.

Answer 9

더 추상적 인 방식으로 답을 살펴 보겠습니다.

이 코드가 X.py에 있다고 가정 해 봅시다 :

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

블록 A와 B는 "X.py"를 실행할 때 실행됩니다.

그러나 다른 모듈 "Y.py"를 실행할 때 블록 a (b가 아닌) 만 실행됩니다. Y.Py에서 호출).

Answer 10

간단히 말하다 __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__ 어떤 코드가 '기본'모듈인지 알려줍니다. 코드를 작성할 수 있고 C/C ++와 같은 구조적 문제에 대해 걱정할 필요가 없기 때문에 파일이 '기본'함수를 구현하지 않으면 실행 파일로 컴파일 할 수 없으며 그렇게하는 경우에는 좋습니다. 그런 다음 라이브러리로 사용할 수 없습니다.

훌륭한 일을하는 파이썬 스크립트를 작성하고 다른 목적에 유용한 보트로드를 구현한다고 가정 해보십시오. 사용하려면 사용하려면 스크립트를 가져 와서 프로그램을 실행하지 않고 사용할 수 있습니다 (코드가 if __name__ == "__main__": 문맥). C/C ++에서는 해당 조각을 별도의 모듈로 나누어 파일을 포함해야합니다. 아래 상황을 묘사하십시오.

화살표는 가져 오기 링크입니다. 이전 모듈 코드를 포함시키려는 3 개의 모듈의 경우 6 개의 파일 (9 개, 구현 파일 계산)과 5 개의 링크가 있습니다. 이로 인해 라이브러리로 특별히 컴파일되지 않는 한 다른 코드를 C 프로젝트에 포함시키기가 어렵습니다. 이제 파이썬을 위해 사진을 찍습니다.

당신은 모듈을 작성하고 누군가가 당신의 코드를 사용하려면 단지 그것을 가져오고 있습니다. __name__ 변수는 프로그램의 실행 가능한 부분을 라이브러리 부분에서 분리하는 데 도움이 될 수 있습니다.

Answer 11

Python을 대화식으로 실행할 때 로컬 __name__ 변수에는 값이 할당됩니다 __main__. 마찬가지로, 명령 줄에서 Python 모듈을 다른 모듈로 가져 오지 않고 Python 모듈을 실행할 때 __name__ 속성에는 값이 할당됩니다 __main__, 모듈의 실제 이름보다는. 이런 식으로 모듈은 자체적으로 볼 수 있습니다. __name__ 다른 프로그램에 대한 지원 또는 명령 줄에서 실행 된 기본 응용 프로그램으로서 사용 방법, 사용 방법을 스스로 결정하는 값. 따라서, 다음 관용구는 파이썬 모듈에서 매우 일반적입니다.

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.

Answer 12

고려하다:

if __name__ == "__main__":
    main()

그것은 있는지 확인합니다 __name__ 파이썬 스크립트의 속성은 다음과 같습니다 "__main__". 다시 말해, 프로그램 자체가 실행되면 속성은 다음과 같습니다. __main__, 프로그램이 실행됩니다 (이 경우 main() 기능).

그러나 파이썬 스크립트가 모듈에서 사용하는 경우 외부의 코드 if 성명서가 실행됩니다 if \__name__ == "\__main__" 프로그램이 모듈로 사용되는지 여부를 확인하는 데 사용되므로 코드 실행 여부를 결정합니다.

Answer 13

설명하기 전에 if __name__ == '__main__' 무엇을 이해하는 것이 중요합니다 __name__ 그리고 그것이 무엇을하는지.

무엇인가요 __name__?

__name__ a Dunderalias - 글로벌 변수 (모듈에서 액세스 가능)로 생각할 수 있으며 비슷한 방식으로 작동합니다. global.

그것은 문자열 (위에서 언급 한대로 글로벌)입니다. type(__name__) (굽힐 수 있는 <class 'str'>), 그리고 둘 다에 대한 내장 표준입니다 파이썬 3 그리고 파이썬 2 버전.

어디에:

스크립트에서 사용할 수있을뿐만 아니라 통역사 및 모듈/패키지 모두에서도 찾을 수 있습니다.

통역사:

>>> print(__name__)
__main__
>>>

스크립트:

test_file.py:

print(__name__)

를 야기하는 __main__

모듈 또는 패키지 :

somefile.py :

def somefunction():
    print(__name__)

test_file.py :

import somefile
somefile.somefunction()

를 야기하는 somefile

패키지 나 모듈에 사용될 때 __name__ 파일 이름을 가져옵니다. 실제 모듈 또는 패키지 경로의 경로는 제공되지 않지만 고유 한 Dunderalias가 있습니다. __file__,이를 허용합니다.

당신은 그것을 어디에서 볼 수 있어야합니다 __name__, 메인 파일 (또는 프로그램) 인 경우 언제나 반품 __main__, 그리고 모듈/패키지 또는 다른 Python 스크립트를 실행하는 것이 있으면 파일이 시작된 파일의 이름을 반환합니다.

관행:

변수라는 것은 가치가 있다는 것을 의미합니다 ~할 수 있다 덮어 쓰기 ( "Can"은 "해야한다는 것을 의미하지는 않습니다), 값을 덮어 씁니다. __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__ 상황이 더 명확 해집니다.

an if 주어진 값이 true 인 경우 코드 블록이 포함되는 흐름 제어 명령문입니다. 우리는 그것을 보았습니다 __name__ 둘 중 하나를 취할 수 있습니다__main__ 또는 가져온 파일 이름.

이것은 IF를 의미합니다 __name__ 와 동등하다 __main__ 그런 다음 파일은 기본 파일이어야하며 실제로 스크립트로 가져온 모듈이나 패키지가 아닌 실제로 실행 중이며 통역사입니다.

참으로 __name__ 가치를 취합니다 __main__ 그러면 해당 코드 블록에있는 모든 것이 실행됩니다.

이것은 실행중인 파일이 기본 파일 인 경우 (또는 해석자에서 직접 실행중인 경우) 해당 조건이 실행되어야한다는 것을 알려줍니다. 패키지라면 그렇지 않아야하며 값은 __main__.

모듈 :

__name__ 모듈로 사용하여 모듈의 이름을 정의 할 수 있습니다.

변형 :

다른, 덜 일반적이지만 유용한 일을 할 수도 있습니다. __name__, 일부는 여기에 보여줄 것입니다.

파일이 모듈 또는 패키지 인 경우에만 실행합니다.

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

파일이 주된 경우 파일이 기본이고 다른 조건을 실행합니다.

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

또한 라이브러리를 정교하게 사용하지 않고도 패키지 및 모듈에 실행 가능한 도움말 기능/유틸리티를 제공 할 수도 있습니다.

또한 명령 줄에서 기본 스크립트로 모듈을 실행할 수 있으므로 매우 유용 할 수도 있습니다.

Answer 14

답을 깊이 있고 간단한 말로 깨는 것이 가장 좋다고 생각합니다.

__name__: Python의 모든 모듈에는 특수 속성이 있습니다. __name__. 모듈의 이름을 반환하는 내장 변수입니다.

__main__: 다른 프로그래밍 언어와 마찬가지로 Python에는 실행 입력 지점, 즉 메인이 있습니다. '__main__' 최상위 코드가 실행되는 범위의 이름입니다.. 기본적으로 파이썬 모듈을 사용하는 두 가지 방법이 있습니다. 스크립트로 직접 실행하거나 가져 오십시오. 모듈이 스크립트로 실행되면 __name__ 설정되었습니다 __main__.

따라서,의 가치 __name__ 속성이 설정되었습니다 __main__ 모듈이 기본 프로그램으로 실행될 때 그렇지 않으면 값 __name__ 모듈의 이름을 포함하도록 설정되었습니다.

Answer 15

명령 줄에서 Python 파일이 호출 될 때 특별합니다. 일반적으로 "main ()"함수를 호출하거나 Commandline 인수 처리와 같은 다른 적절한 시작 코드를 실행하는 데 사용됩니다.

여러 가지 방법으로 작성 될 수 있습니다. 다른 하나는 :

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

나는 당신이 이것을 생산 코드에서 사용해야한다고 말하지는 않지만, "마법"이 없다는 것을 설명하는 역할을합니다. if __name__ == '__main__'. 파이썬 파일에서 주요 기능을 호출하기위한 좋은 규칙입니다.

Answer 16

System (Python Intercer)이 소스 파일 (모듈)에 대해 제공하는 여러 변수가 있습니다. 원하는 경우 언제든지 가치를 얻을 수 있습니다. __이름__ 변수/속성 :

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

모듈을 직접 실행할 때만 실행됩니다. 다른 모듈이 호출/가져 오면 코드 블록이 실행되지 않습니다. __이름__ "와 같지 않습니다.기본"그 특정한 경우.

이것이 도움이되기를 바랍니다.

Answer 17

if __name__ == "__main__": 기본적으로 최상위 스크립트 환경이며, 통역사를 지정합니다 ( '우선 실행하기 가장 우선 순위가 가장 높습니다').

'__main__' 최상위 코드가 실행되는 범위의 이름입니다. 모듈 __name__ 동일합니다 '__main__' 표준 입력, 스크립트 또는 대화식 프롬프트에서 읽을 때.

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

Answer 18

대한 이유

if __name__ == "__main__":
    main()

주로 피하는 것입니다 가져 오기 잠금 발생할 문제 코드가 직접 가져온 것입니다. 당신은 원합니다 main() 파일이 직접 호출 된 경우 실행하려면 __name__ == "__main__" CASE), 그러나 코드가 가져 오면 수입업자는 가져 오기 잠금 문제를 피하기 위해 실제 기본 모듈에서 코드를 입력해야합니다.

부작용은 여러 입력 지점을 지원하는 방법론에 자동으로 사인한다는 것입니다. 당신은 당신의 프로그램을 사용하여 실행할 수 있습니다 main() 진입 점으로 그러나 당신은 할 필요가 없습니다. 하는 동안 setup.py 기대합니다 main(), 다른 도구는 대체 진입 지점을 사용합니다. 예를 들어 파일을 a로 실행합니다 gunicorn 프로세스, 당신은 정의합니다 app() a 대신 기능 main(). 마찬가지로 setup.py, gunicorn 코드를 가져 오면 가져 오는 동안 (가져 오기 잠금 문제로 인해) 가져 오는 동안 아무것도하지 않기를 원합니다.

Answer 19

나는 그렇게 많이 걸쳐에 대한 답변 이 페이지로 이동합니다.내가 말할 것을 알고 있는 경우,일에 대한 확신을 이해할 것이 그 해답을,그렇지 않으면,당신은 여전히 혼동된다.

게 짧은,당신은 알아야 할 여러 가지 포인트:

1. import a 작업 실제로 실행 할 수있는 모든 실행에서"a"

2. 때문에의점 1 하지 않을 수도 있습할 것이 모두가 실행에서"a"가져올 때 그

3. 문제를 해결하기 지점에서 2,python 을 넣을 수 있는 상태 확인

4. __name__ 암시적 변수에 모두.py 모듈경우.py 수입되는 값의 __name__ 니다.py 모듈 설정 파일 이름"a";경우.py 직접 실행하여"python 니다.py"을 의미한다.py 은 입국 지점의 값 __name__ 니다.py 모듈이 설정한 문자열 __main__

5. 기반 메커니즘에 어떻게 파이썬 설정 변수 __name__ 각 모듈에 대해,당신은 당신을 달성하는 방법을 지점 3?대답은 매우 간단하지 않습니까?을 넣는 경우 상태: if __name__ == "__main__": ...;수도 있습을 넣는 경우 __name__ == "a" 에 따라 기능의 필요

중요한 것은 파이썬은 특별한에서는 점 4!나머지는 그냥 기본 논리입니다.

Answer 20

고려하다:

print __name__

위의 출력은입니다 __main__.

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

위의 진술은 참이고 인쇄합니다 "직접 방법". 그들이 다른 클래스 에서이 클래스를 가져 오면 인쇄하지 않는다고 가정 해 봅시다. "직접 방법" 가져 오는 동안 설정되기 때문입니다 __name__ equal to "first model name".

Answer 21

파일을 사용할 수있게 할 수 있습니다 스크립트 뿐만 아니라 수입 모듈.

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

Answer 22

이 답변은 Python을 배우는 Java 프로그래머를위한 것입니다. 모든 Java 파일에는 일반적으로 하나의 공개 클래스가 포함됩니다. 두 가지 방법으로 해당 클래스를 사용할 수 있습니다.

1. 다른 파일에서 클래스를 호출하십시오. 호출 프로그램에서 가져와야합니다.

2. 테스트 목적으로 클래스 독립형 만 실행하십시오.

후자의 경우, 클래스에는 공개 정적 무효 메인 () 메소드가 포함되어야합니다. 파이썬 에서이 목적은 전 세계적으로 정의 된 레이블에 의해 제공됩니다. '__main__'.

Answer 23

이 .py 파일이 다른 .py 파일에 의해 가져 오면 "if 문"아래의 코드는 실행되지 않습니다.

이 .py가 실행되면 python this_py.py 쉘 아래에 있거나 Windows에서 두 번 클릭했습니다. "IF 문"에 따른 코드가 실행됩니다.

일반적으로 테스트를 위해 작성됩니다.

Answer 24

파일 만들기, 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

Answer 25

만약에 이름 == '기본':

우리는 __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__

Answer 26

모든 대답은 기능을 거의 설명했습니다. 그러나 나는 개념을 더욱 정리하는 데 도움이 될 수있는 사용법의 예를 제공 할 것입니다.

A.Py와 B.Py라는 두 개의 파이썬 파일이 있다고 가정합니다. 이제 A.py는 B.Py를 수입합니다. "import B.py"코드가 먼저 실행되는 A.Py 파일을 실행합니다. 나머지 a.py 코드가 실행되기 전에 B.py 파일의 코드는 완전히 실행되어야합니다.

B.py 코드에는 해당 파일 B.py에만 전용되는 코드가 있으며 B.py 파일을 가져온 B.Py 파일 이외의 다른 파일을 원하지 않습니다.

이것이 바로이 코드 라인이 확인하는 것입니다. 코드를 실행하는 기본 파일 (예 : B.py) 인 경우이 경우 (A.Py가 기본 파일이 실행되지 않는지) 코드 만 실행됩니다.

Answer 27

간단히 main 기능 씨 프로그래밍 언어.

Answer 28

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

따라서 위는 다른 스크립트에서 테스트를 호출 할 때 LOOP이라는 자체 설명입니다. 이름 test.py에서 실행되지 않습니다.