if __name__ == "__main__": 하면 어떻게 되나요?

질문자 :Devoted

다음 코드가 주어지면 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))

답변자 : Mr Fooz

짧은 답변

의도하지 않은 스크립트를 실수로 호출하지 않도록 사용자를 보호하는 상용구 코드입니다. 다음은 스크립트에서 가드를 생략할 때 발생하는 몇 가지 일반적인 문제입니다.

• 다른 스크립트에서 가드리스 스크립트를 가져오면(예: import my_script_without_a_name_eq_main_guard ), 두 번째 스크립트는 첫 번째 스크립트를 트리거하여 가져올 때 두 번째 스크립트의 명령줄 인수를 사용하여 실행합니다 . 이것은 거의 항상 실수입니다.

• 가드리스 스크립트에 사용자 정의 클래스가 있고 이를 피클 파일에 저장하는 경우 다른 스크립트에서 이를 언피클링하면 가드리스 스크립트 가져오기가 트리거되며 이전 글머리 기호에서 설명한 것과 동일한 문제가 발생합니다.

긴 답변

이것이 왜 그리고 어떻게 중요한지 더 잘 이해하려면 Python이 스크립트를 초기화하는 방법과 이것이 모듈 가져오기 메커니즘과 상호 작용하는 방법을 이해하기 위해 한 걸음 물러나야 합니다.

Python 인터프리터는 소스 파일을 읽을 때마다 두 가지 작업을 수행합니다.

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

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

이것이 어떻게 작동하는지, 그리고 이것이 Python 스크립트에서 항상 볼 수 __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 인터프리터는 소스 파일을 읽을 때 먼저 몇 가지 특수 변수를 정의합니다. 이 경우 우리는 __name__ 변수에 __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 파일을 검색하고(몇 가지 다른 변형 검색과 함께) 해당 모듈을 실행하기 전에 import 문에서 __name__ 변수에 "foo"

 # 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__ 는 문자열을 취하고 실제 가져오기를 트리거하는 Python의 저수준 함수입니다).

 # 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__ 은 "__main__" 아니라 "foo" 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. import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters 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")

• foo3.py __name__ 체크를 제거하면 어떻게 되는지 알아보세요.

 # Suppose this is foo3.py. import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters 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")

답변자 : Adam Rosenfield

스크립트를 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__ 은 "__main__" 대신 "one" 같습니다.

답변자 : pi.

__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__'] 을 모듈의 이름으로 설정합니다. 또한 가져올 때 모듈의 모든 코드가 실행됩니다. if 문은 False 평가되므로 이 부분은 실행되지 않습니다.

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

보시다시피, 파일이 실행될 때 Python은 이 파일의 globals()['__name__'] "__main__" 합니다. 이번에는 if 문이 True 평가되어 실행 중입니다.

답변자 : Aaron Hall

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 세션, 즉 인터프리터의 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()

__main__ 모듈에 대한 설명에서도 찾을 수 있습니다. 그 텍스트는 다음과 같이 말합니다.

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

 if __name__ == '__main__': main()

답변자 : Harley Holcombe

if __name__ == "__main__" python myscript.py 와 같은 명령을 사용하여 명령줄에서 스크립트를 실행할 때 실행되는 부분입니다.

답변자 : Aaron Hall

if __name__ == "__main__": 하면 어떻게 되나요?

__name__ 은 모든 네임스페이스에 존재하는 전역 변수(파이썬에서 전역은 실제로 모듈 수준을 의미합니다)입니다. 일반적으로 모듈의 이름( str 유형)입니다.

그러나 mycode.py에서와 같이 실행하는 Python 프로세스가 무엇이든 유일한 특별한 경우입니다.

 python mycode.py

그렇지 않으면 익명의 전역 네임스페이스에는 '__main__' __name__ 할당됩니다.

따라서 마지막 줄을 포함하여

 if __name__ == '__main__': main()

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

스크립트의 고유하게 정의된 main 기능이 실행되도록 합니다.

이 구성을 사용하는 또 다른 이점: 코드를 다른 스크립트의 모듈로 가져온 다음 프로그램이 다음과 같이 결정하는 경우 주 함수를 실행할 수도 있습니다.

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

답변자 : joechoj

문제의 코드 역학, 즉 "How"에 대해 다양한 해석이 있지만 "Why"를 이해하기 전까지는 그 어떤 것도 이해가 되지 않았습니다. 이것은 새로운 프로그래머에게 특히 도움이 될 것입니다.

"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 를 실행하면 ab를 import ab . import 문은 가져올 때 모듈을 즉시 실행하므로 ab xy 의 나머지 부분보다 먼저 실행됩니다. ab 끝나면 xy 계속됩니다.

__name__ 으로 실행 중인 스크립트를 추적합니다. 스크립트를 실행할 때 이름을 무엇으로 지정했는지에 상관없이 인터프리터는 이를 "__main__" 이라고 부르며 외부 스크립트를 실행한 후 반환되는 마스터 또는 '홈' 스크립트로 만듭니다.

"__main__" 스크립트에서 호출되는 다른 모든 스크립트에는 파일 이름이 __name__ 으로 할당됩니다(예: __name__ == "ab.py" ). 따라서 if __name__ == "__main__": 행은 처음에 실행된 'home' 스크립트를 해석/파싱하는지 또는 일시적으로 다른(외부) 스크립트를 엿보고 있는지 결정하기 위한 인터프리터의 테스트입니다. 이것은 프로그래머가 스크립트가 직접 실행되는 경우와 외부에서 호출되는 경우 다르게 동작하도록 할 수 있는 유연성을 제공합니다.

위의 코드를 단계별로 실행하여 무슨 일이 일어나고 있는지 이해하고 먼저 들여쓰기되지 않은 줄과 스크립트에 나타나는 순서에 초점을 맞춰 보겠습니다. function - 또는 def - 블록은 호출될 때까지 자체적으로 아무것도 하지 않는다는 것을 기억하십시오. 통역사가 스스로 중얼거린다면 다음과 같이 말할 수 있습니다.

• xy.py를 '홈' 파일로 엽니다. __name__ 변수에서 "__main__" 이라고 부릅니다.
• __name__ == "ab.py" 파일을 가져와서 엽니다.
• 오, 기능. 기억하겠습니다.
• 좋아, 함수 a() ; 방금 배웠습니다. ' ab 파일의 함수 '를 인쇄 중입니다.
• 파일 끝; "__main__" 돌아가세요!
• 오, 기능. 기억하겠습니다.
• 다른 것.
• 함수 x() ; 알겠습니다. '주변 작업: 다른 프로젝트에서 유용할 수 있습니다 '를 인쇄 중입니다.
• 이게 뭐야? if 문. 음, 조건이 충족되었으므로(변수 __name__ "__main__" 으로 설정됨 main() 함수를 입력하고 ' main function: this is where action is '를 인쇄하겠습니다.

맨 아래 두 줄은 "이것이 "__main__" 또는 'home' 스크립트인 경우 main() 이라는 함수를 실행합니다."를 의미합니다. 이것이 스크립트 기능의 주요 흐름을 포함 def main(): block up top을 볼 수 있는 이유입니다.

이것을 구현하는 이유는 무엇입니까?

이전에 import 문에 대해 말한 것을 기억하십니까? 모듈을 가져올 때 모듈을 '인식'하고 추가 지침을 기다리는 것이 아니라 실제로 스크립트에 포함된 모든 실행 가능한 작업을 실행합니다. 따라서 스크립트의 main() 함수에 넣으면 효과적으로 격리되어 다른 스크립트에서 가져올 때 즉시 실행되지 않도록 격리됩니다.

다시 말하지만 예외가 있지만 일반적인 관행은 main() 이 일반적으로 외부에서 호출되지 않는다는 것입니다. 그래서 한 가지 더 궁금한 점이 있을 수 있습니다. main() 호출하지 않는 경우 스크립트를 전혀 호출하지 않는 이유는 무엇입니까? 많은 사람들이 파일의 나머지 코드와 독립적으로 실행되도록 빌드된 독립 실행형 기능으로 스크립트를 구성하기 때문입니다. 그런 다음 나중에 스크립트 본문의 다른 곳에서 호출됩니다. 어느 것이 나에게 이것을 가져다줍니다 :

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

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

그러나 그것은 아마도 외부에서 함수를 호출할 수 없는 스크립트입니다. 호출하면 즉시 변수를 계산하고 할당하기 시작하기 때문입니다. 함수를 재사용하려는 경우 새 스크립트가 이전 스크립트와 충분히 밀접하게 관련되어 충돌하는 변수가 있을 가능성이 있습니다.

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

(제쳐두고, 이 질문 에는 마침내 내가 이해하는 데 도움이 된 @kindall의 답변이 포함되어 있습니다. 방법이 아니라 이유입니다. 불행히도 이것은 실수라고 생각하는 이 질문의 복제본으로 표시되었습니다.)

답변자 : Nabeel Ahmed

모듈( M.py if 블록 아래에 해당 명령문(테스트 케이스, 인쇄 명령문)을 배치할 수 있습니다.

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

간단히 말해서 이 ' if __name__ == "main" ' 블록을 사용하여 모듈을 가져올 때 (특정) 코드가 실행되는 것을 방지합니다.

답변자 : redbandit

간단히 말해서 __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++에서와 같은 구조적 문제에 대해 걱정할 필요가 없기 때문에 이것은 훌륭합니다. 그러면 라이브러리로 사용할 수 없습니다.

훌륭한 작업을 수행하는 Python 스크립트를 작성하고 다른 목적에 유용한 많은 함수를 구현한다고 가정해 보겠습니다. 사용하고 싶다면 스크립트를 가져와서 프로그램을 실행하지 않고 사용할 수 있습니다(코드가 if __name__ == "__main__": 컨텍스트 내에서만 실행된다는 가정 하에). 반면 C/C++에서는 이러한 조각을 파일을 포함하는 별도의 모듈로 분할해야 합니다. 아래 상황을 상상해보십시오.

화살표는 가져오기 링크입니다. 각각 이전 모듈 코드를 포함하려고 하는 3개의 모듈에 대해 6개의 파일(구현 파일을 포함하여 9개)과 5개의 링크가 있습니다. 이것은 특별히 라이브러리로 컴파일되지 않는 한 다른 코드를 C 프로젝트에 포함하기 어렵게 만듭니다. 이제 Python용으로 그림을 그리십시오.

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

답변자 : Alisa

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

x.py 다음 코드가 있다고 가정합니다.

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

블록 A와 B는 x.py 실행할 때 실행됩니다.

그러나 블록 A(B가 아님)는 다른 모듈, 예를 들어 y.py x.py 를 가져오고 코드가 거기에서 실행됩니다(예: x.py y.py ).

답변자 : jack

나는 이 페이지의 답변 전체를 너무 많이 읽었습니다. 나는 당신이 그 사실을 알고 있다면 그 대답을 확실히 이해할 것이라고 말하고 싶습니다. 그렇지 않으면 여전히 혼란스러워합니다.

간단히 말해서 몇 가지 사항을 알아야 합니다.

1. import a 조치가 실제로에서 실행 된이 될 수있는 모든 실행 a.py 각 줄 의미 a.py

2. 포인트 1 때문에 가져올 때 a.py 에서 실행되는 것을 원하지 않을 수 있습니다.

3. 포인트 2의 문제를 해결하기 위해 python을 사용하면 조건 검사를 할 수 있습니다.

4. __name__ .py 모듈의 암시적 변수입니다.

• 때 a.py 있습니다 import 에드의 값 __name__ 의 a.py 모듈은 파일 이름 "으로 설정되어 " a
• python a.py a.py 를 직접 실행하면 __name__ 의 값이 __main__ 문자열로 설정됩니다.

5. __name__ 변수를 설정하는 메커니즘에 따라 포인트 3을 달성하는 방법을 알고 있습니까? 답은 상당히 쉽죠? if 조건을 넣으세요: if __name__ == "__main__": // do A

• 그런 다음 python a.py 는 부분을 실행합니다. // do A
• 그리고 import a 부분을 건너뛸 것입니다 // do A

6. __name__ == "a" 넣을 수도 있지만 거의 하지 않습니다.

python이 특별한 점은 포인트 4입니다! 나머지는 기본적인 논리일 뿐입니다.

답변자 : Zain

Python을 대화식으로 실행할 때 로컬 __name__ __main__ 값이 할당됩니다. 마찬가지로 명령줄에서 Python 모듈을 실행할 때 다른 모듈로 가져 __main__ __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.

답변자 : Giorgos Myrianthous

if __name__ == '__main__': 아래의 코드 는 모듈이 스크립트로 호출되는 경우에만 실행됩니다 .

예를 들어 다음 모듈 my_test_module.py 를 고려하십시오.

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

---

첫 번째 가능성: 다른 모듈에서 my_test_module.py

 # main.py import my_test_module if __name__ == '__main__': print('Hello from main.py')

main.py 를 호출하면:

 python main.py >> 'This is going to be printed out, no matter what' >> 'Hello from main.py'

my_test_module 최상위 print() 문만 실행된다는 점에 유의하십시오.

---

두 번째 가능성: my_test_module.py 를 스크립트로 호출

my_test_module.py 를 Python 스크립트로 실행하면 print() 문이 실행됩니다.

 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'

---

보다 포괄적인 설명을 보려면 What does if __name__ == '__main__' do in Python 을 읽을 수 있습니다.

답변자 : Larry

고려하다:

 if __name__ == "__main__": main()

Python 스크립트의 __name__ "__main__" 합니다. 즉, 프로그램 자체가 실행되는 경우 속성은 __main__ 이므로 프로그램이 실행됩니다(이 경우 main() 함수).

그러나 Python 스크립트가 모듈에서 사용되는 if 문 외부의 모든 코드가 실행되므로 if \__name__ == "\__main__" 은 프로그램이 모듈로 사용되는지 여부를 확인하는 데 사용되며, 따라서 코드를 실행할지 여부를 결정합니다.

답변자 : Simon

if __name__ == '__main__' 에 대해 설명하기 전에 __name__ 이 무엇이고 어떤 역할을 하는지 이해하는 것이 중요합니다.

__name__ 은(는) 무엇입니까?

__name__ A는 DunderAlias - 유사한 방식의 글로벌 (모듈에서 액세스) 변수와 작품으로 간주 할 수 있습니다 global .

type(__name__) ( <class 'str'> 생성)으로 표시된 문자열(위에서 언급한 전역 )이며 Python 3 및 Python 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__ 은 파일 이름을 사용합니다. 실제 모듈 또는 패키지 경로의 경로는 제공되지 않지만 __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__' 을 포함하는 것이 좋습니다.

if __name__ == '__main__' 과 같이 대답합니다.

__name__ 의 동작이 더 명확해집니다.

if 는 주어진 값이 true인 경우 실행할 코드 블록을 포함하는 흐름 제어 문입니다. __name__ __main__ 또는 가져온 파일 이름을 사용할 수 있음을 보았습니다.

즉, __name__ __main__ 과 같으면 파일은 스크립트로 가져온 모듈이나 패키지가 아니라 기본 파일이어야 하고 실제로 실행 중이어야 합니다(또는 인터프리터여야 함).

실제로 __name__ __main__ 의 값을 취하면 해당 코드 블록에 있는 모든 것이 실행됩니다.

이것은 실행 중인 파일이 주 파일인 경우(또는 인터프리터에서 직접 실행 중인 경우) 해당 조건이 실행되어야 함을 알려줍니다. 패키지라면 그렇게 해서는 안 되며 값은 __main__ 이 아닙니다.

모듈:

__name__ 은 모듈에서 모듈의 이름을 정의하는 데 사용할 수도 있습니다.

변형:

__name__ 하여 덜 일반적이지만 유용한 다른 작업을 수행하는 것도 가능합니다. 일부는 여기에 표시하겠습니다.

파일이 모듈 또는 패키지인 경우에만 실행:

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

파일이 기본 조건인 경우 하나의 조건을 실행하고 그렇지 않은 경우 다른 조건을 실행합니다.

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

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

또한 모듈을 명령줄에서 메인 스크립트로 실행할 수 있어 매우 유용할 수 있습니다.

답변자 : Inconnu

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

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

__main__ : 다른 프로그래밍 언어와 마찬가지로 Python에도 실행 진입점이 있습니다. 즉, main입니다. '__main__' 은 최상위 코드가 실행되는 범위의 이름입니다 . 기본적으로 Python 모듈을 사용하는 두 가지 방법이 있습니다. 스크립트로 직접 실행하거나 가져옵니다. 모듈이 스크립트로 실행될 때 __name__ __main__ 으로 설정됩니다.

__name__ 속성의 값은 모듈이 메인 프로그램으로 실행될 때 __main__ 으로 설정됩니다. __name__ 의 값이 모듈의 이름을 포함하도록 설정됩니다.

답변자 : Prof. Falken

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

여러 가지 방법으로 작성할 수 있습니다. 또 다른 것은:

 def some_function_for_instance_main(): dosomething() __name__ == '__main__' and some_function_for_instance_main()

if __name__ == '__main__' 대해 "마법 같은" 것이 없음을 설명하는 역할을 합니다.

Python 파일에서 주요 함수를 호출하기 위한 규칙일 뿐입니다.

답변자 : codewizard

시스템(Python 인터프리터)이 소스 파일(모듈)에 대해 제공하는 여러 변수가 있습니다. 언제든지 원하는 값을 얻을 수 있으므로 __name__ 변수/속성에 집중하겠습니다.

파이썬은 소스 코드 파일을 로드할 때 그 안에 있는 모든 코드를 실행합니다. (파일에 정의된 모든 메서드와 함수를 호출하지는 않지만 정의합니다.)

인터프리터는 소스 코드 파일을 실행하기 전에 해당 파일에 대한 몇 가지 특수 변수를 정의합니다. __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 "과 같지 않기 때문에 다른 모듈이 해당 모듈을 호출/가져오기하는 경우 코드 블록이 실행되지 않습니다.

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

답변자 : The Gr8 Adakron

if __name__ == "__main__": 은 기본적으로 최상위 스크립트 환경이며 인터프리터를 지정합니다.

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

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

답변자 : Janarthanan Ramu

고려하다:

 print __name__

위의 출력은 __main__ 입니다.

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

위의 문장은 true이고 "direct method"를 출력합니다. 그들이 이 클래스를 다른 클래스에서 가져온 경우 __name__ equal to "first model name" 하게 설정하기 때문에 "direct method"를 인쇄하지 않는다고 가정합니다.

답변자 : kgf3JfUtW

파일을 스크립트 로 사용할 수 있을 뿐만 아니라 가져올 수 있는 모듈 로 만들 수도 있습니다.

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

답변자 : personal_cloud

대한 이유

 if __name__ == "__main__": main()

주로 코드를 직접 가져올 때 발생 하는 가져오기 잠금 문제를 방지하기 위한 것입니다. 파일이 직접 호출된 경우(즉, __name__ == "__main__" main() 이 실행되기를 원하지만 코드를 가져온 경우 가져오기 잠금 문제를 피하기 위해 가져오기 도구는 실제 주 모듈에서 코드를 입력해야 합니다.

여러 진입점을 지원하는 방법론에 자동으로 사인온하는 부작용이 있습니다. main() 을 진입점으로 사용하여 프로그램을 실행할 수 있지만 . setup.py 는 main() 예상하지만 다른 도구는 대체 진입점을 사용합니다. 예를 들어 파일을 gunicorn main() 대신 app() 함수를 정의합니다. setup.py 와 마찬가지로 gunicorn 가져오는 동안(가져오기 잠금 문제로 인해) 아무 작업도 수행하지 않습니다.

답변자 : Rishi Bansal

파이썬의 모든 모듈에는 __name__ 이라는 속성이 있습니다. __name__ 속성의 값은 python my_module.py 와 같이 모듈이 직접 실행될 때 __main__ 입니다. import my_module 이라고 말할 때와 같이 __name__ 의 값은 모듈의 이름입니다.

간단히 설명하기 위한 작은 예입니다.

 #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를 호출할 때 test.py __name__ 루프가 실행되지 않는다는 자체 설명입니다.

답변자 : Raja

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

1. 다른 파일에서 클래스를 호출합니다. 호출 프로그램에서 가져오기만 하면 됩니다.

2. 테스트 목적으로 클래스를 독립 실행형으로 실행합니다.

후자의 경우 클래스는 public static void main() 메서드를 포함해야 합니다. Python에서 이 목적은 전역적으로 정의된 레이블 '__main__' 의해 제공됩니다.

답변자 : pah8J

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

이 .py가 python this_py.py 에 의해 실행되거나 Windows에서 두 번 클릭된 경우. "if 문" 아래의 코드가 실행됩니다.

일반적으로 테스트용으로 작성됩니다.

답변자 : Nikil Munireddy

파이썬 인터프리터가 특정 모듈을 실행하는 경우 __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()

이 스크립트를 실행하면 나를 볼 수 있습니다.

NS

이 파일을 가져오면 파일 B에 A라고 말하고 파일 B를 실행하면 파일 A의 if __name__ == "__main__" 이 false가 되어 출력됩니다. You can't see me

NS

답변자 : Ali Hallaji

이름 == ' 메인 '인 경우:

if __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__

답변자 : Mustapha Babatunde

간단히 말해서:

if __name__ == "__main__": 아래에 보이는 코드는 파이썬 파일이 "python example1.py"로 실행될 때만 호출됩니다.

그러나 파이썬 파일 'example1.py'를 다른 파이썬 파일과 함께 작동하는 모듈로 가져오려면 'example2.py'라고 말하면 if __name__ == "__main__": 아래의 코드는 실행되지 않거나 어떤 영향도 미치지 않습니다.

답변자 : preetika mondal

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

두 개의 Python 파일(.py 및 b.py)이 있다고 가정합니다. 이제.py는 b.py를 가져옵니다. "b.py 가져오기" 코드가 먼저 실행되는 a.py 파일을 실행합니다. 나머지 a.py 코드가 실행되기 전에 b.py 파일의 코드가 완전히 실행되어야 합니다.

b.py 코드에는 해당 파일 b.py 전용 코드가 있으며 b.py 파일을 가져온 다른 파일(b.py 파일 제외)이 실행되는 것을 원하지 않습니다.

이것이 이 코드 라인이 확인하는 것입니다. 코드를 실행하는 기본 파일(즉, b.py)이고 이 경우에는 실행되지 않는(a.py가 실행 중인 기본 파일) 코드만 실행됩니다.

답변자 : DARK_C0D3R

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

출처 : Here

출처 : http:www.stackoverflow.com/questions/419163/what-does-if-name-main-do">