__name__ == "_main__"인 경우:는 어떻게 합니까?

__name__ == "_main__"인 경우:는 어떻게 합니까?

하는 것입니까?또, 「」, 「」를 포함할 가 있는 이유는 입니까?if★★★★★★★★★★★★?

if __name__ == "__main__":
    print("Hello, World!")

---

_{이 질문에서는, 코드의 동작과 동작에 대해 설명합니다.누군가가 이 관용구를 사용해야 하는 장소와 사용하지 않아야 하는 질문을 닫으려면 "Import할 때 Python이 내 모듈을 실행하고 있는 이유와 이를 중지하는 방법"을 복제하여 닫는 것을 고려해 보십시오.}

단답

사용자가 의도하지 않았을 때 실수로 스크립트를 호출하지 않도록 보호하는 상용 코드입니다.스크립트에서 가드를 생략할 때 자주 발생하는 문제를 다음에 나타냅니다.

• 스크립트로 경우( Import:import my_script_without_a_name_eq_main_guard)의 경우, 후자의 스크립트는, Import시에 실행되어 두 번째 스크립트의 커맨드 라인 인수를 사용합니다.이것은 거의 항상 실수입니다.

• 가드리스 스크립트에 커스텀클래스가 있어 피클파일에 보존되어 있는 경우는, 다른 스크립트로 언픽 하면, 가드리스 스크립트의 Import가 트리거 됩니다.이 문제는 앞의 글머리 기호와 동일합니다.

장황한 답변

이것이 왜 그리고 어떻게 중요한지를 더 잘 이해하기 위해서는 Python이 스크립트를 어떻게 초기화하고 이것이 모듈 Import 메커니즘과 어떻게 상호 작용하는지 한 걸음 물러서 이해할 필요가 있습니다.

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

• 이런 해 줍니다.__name__ 나서, 리 ,리 , , 。

• 파일에 있는 모든 코드를 실행합니다.

어떻게 있는지, 있는지, 그리고 볼까요?__name__파이썬

코드 샘플

조금 다른 코드샘플을 사용하여 Import와 스크립트의 구조를 살펴보겠습니다.를 들어 다음과 같은 , 라는 가정해 봅시다.foo.py.

# Suppose this is foo.py.

print("before import")
import math

print("before function_a")
def function_a():
    print("Function A")

print("before function_b")
def function_b():
    print("Function B {}".format(math.sqrt(100)))

print("before __name__ guard")
if __name__ == '__main__':
    function_a()
    function_b()
print("after __name__ guard")

특수 변수

Python 인터프리터는 소스 파일을 읽을 때 먼저 몇 가지 특수 변수를 정의합니다.때는 '아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 이런__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__" 

다른 모듈이 Import된 경우

한편, 다른 모듈이 메인프로그램이고, 그것이 모듈을 Import한다고 가정합니다.즉, 메인 프로그램 또는 메인 프로그램이 가져오는 다른 모듈에는 다음과 같은 문장이 있습니다.

# 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__는 문자열을 사용하여 실제 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 function_a".

4. 「」를 합니다.def오브젝트를 그 인 "함수 오브젝트", "함수 오브젝트", "함수 오브젝트", " 오브젝트는 "함수 오브젝트", "함수 오브젝트", "함수 오브젝트", "함수 오브젝트", "함수 오브젝트"에 할당됩니다.function_a.

5. ."before function_b".

6. 합니다.def오브젝트를 , 인 ,, 른, 른, 른, 이, 이, 이, 이, 이, 이, 이, 이, 이, 이, 이, 이, block, block, block, block, block, block, block, block, block, block, block, block, block.function_b.

7. ."before __name__ guard".

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

8. 프로그램인 , 에는 '메인 프로그램'이 됩니다.__name__ was was was was was was was was was was was was was was로 되어 "__main__"두 가지 인쇄하면 두 기능을 불러옵니다."Function A" ★★★★★★★★★★★★★★★★★」"Function B 10.0".

다른 모듈이 Import된 경우에만

8. (표준)모듈이 메인 프로그램이 아니라 다른 프로그램에 의해 Import된 경우__name__ 되다"foo" 아니라, 이에요."__main__"합니다.if★★★★★★ 。

항상

9. 됩니다."after __name__ guard"두 가지 상황에서 모두요.

요약

요약하면, 다음의 2개의 케이스로 인쇄되는 내용을 나타냅니다.

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

왜 이런 식으로 동작하는가?

당신은 당연히 왜 누군가가 이것을 원하는지 궁금할 것이다. 가끔은 이렇게 때도 요..py다른 프로그램 및/또는 모듈에서 모듈로 사용할 수 있으며 메인 프로그램 자체로도 실행할 수 있는 파일입니다.§:

• 모듈은 라이브러리이지만 몇 가지 유닛테스트나 데모를 실행하는 스크립트모드로 하겠습니다

• 몇 는 Import를 통해 합니다..py스크립트나 특수 테스트 기능을 실행하는 등의 파일입니다.모듈을 Import한다고 해서 스크립트를 실행하려고 하면 안 됩니다.

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

이러한 예 외에도 Python에서 스크립트를 실행하는 것은 몇 가지 마법 변수를 설정하고 스크립트를 Import하는 것만으로 우아합니다.스크립트의 "실행"은 스크립트의 모듈을 Import할 때의 부작용입니다.

생각할 거리

• 를 가질 수 요?__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 function_a():
    print("a1")
    from foo2 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

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

• 그럼 이번에는 '어울릴까'를 한 번 .__name__foo3.py:

# Suppose this is foo3.py.
import os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters

def function_a():
    print("a1")
    from foo3 import function_b
    print("a2")
    function_b()
    print("a3")

def function_b():
    print("b")

print("t1")
print("m1")
function_a()
print("m2")
print("t2")

• 이것을 스크립트로 사용하면 어떻게 됩니까?모듈로 Import되는 경우

# 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 인터프리터에 명령어로 전달하여 실행하면,

python myscript.py

들여쓰기 레벨0 의 모든 코드가 실행됩니다.정의된 함수 및 클래스는 정의되어 있지만 해당 코드는 실행되지 않습니다.언어와는 른른른른 unlike 는 없다.main() - " " " " : "main()함수는 암묵적으로 최상위 수준의 모든 코드입니다.

는 " " " 입니다.if__name__는 현재 모듈의 이름으로 평가되는 삽입 변수입니다.이 직접 되고 있는 와)myscript.py으로 ( )을 클릭합니다.__name__됩니다."__main__", 아니면 다른 에 의해 Import되고 할 수

if __name__ == "__main__":
    ...

스크립트의 및 되지만 Import의 가 Import됩니다.if위의 절은 조건이 충족되지 않아 실행되지 않습니다.기본적인 예로서 다음 2개의 스크립트를 검토합니다.

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

다음 두 개의 파일을 만듭니다.

# a.py

import b

# b.py

print("__name__ equals " + __name__)

if __name__ == '__main__':
    print("if-statement was executed")

이제 각 파일을 개별적으로 실행합니다.

---

.python a.py:

$ python a.py
__name__ equals b

a.py를 Import합니다.b로 인해, 「 」의 모든 b달려야 합니다.이 Python을 globals()['__name__'] b인 " (모듈 이름)로 합니다.b.

.python b.py:

$ python b.py
__name__ equals __main__
if-statement was executed

'''만 있는 b.py되면 Python은 Python을 설정합니다.globals()['__name__']에서 " " "로 이동합니다."__main__"★★★★★★★★★★★★★★★★★.if이 되다True★★★★★★★★★★★★★★★★★★.

「 」가 죠?if __name__ == "__main__": 할수 수 do do do?

기본을 간략히려면:

• 변수 " " "__name__의 경우, 는 「」입니다.'__main__'수입하다

• 코드 코드, 코드.if블록은 모듈이 프로그램의 진입점일 경우에만 실행됩니다.

• 이를 통해 모듈 내의 코드를 Import 시 아래의 코드 블록을 실행하지 않고 다른 모듈에서 Import할 수 있습니다.

---

이게 왜 필요하죠?

코드 개발 및 테스트

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

def do_important():
    """This function does something very important"""

이 함수의 콜을 하단에 추가하여 모듈을 테스트할 수 있습니다.

do_important()

(명령 프롬프트에서) 다음과 같이 실행합니다.

~$ python important.py

문제

단, 모듈을 다른 스크립트로 Import할 경우 다음 절차를 수행합니다.

import important

»do_important호출을 수 .do_important()

# do_important() # I must remember to uncomment to execute this!

그런 다음 테스트 함수 호출에 대한 코멘트를 작성했는지 여부를 기억해야 합니다.그리고 이러한 복잡성은 여러분이 잊어버리기 쉽다는 것을 의미하기 때문에 개발 과정이 더 까다로워질 것입니다.

더 나은 방법

__name__변수는 Python 인터프리터가 있는 네임스페이스를 가리킵니다.

Import된 모듈 내에서는 해당 모듈의 이름입니다.

, 모듈Loop REP 인터프리터의 세션에서는 모든 을 Python에서 ."__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()

이것으로 모듈을 프라이머리 모듈로 실행할 경우 모듈의 마지막 기능을 수행하게 되었습니다.

및 그 및를 Import를 실행하지 수 .main 그 및 클래스)이 다른 및 그 및 )에서 실행될 때는 모듈(및 그 기능 및 을 할 수 .'__main__' 모듈, »

import important
important.main()

이 관용구는 Python 설명서에서 모듈에 대한 설명을 참조하십시오.이 텍스트는 다음과 같습니다.

이 모듈은 표준 입력, 스크립트 파일 또는 인터랙티브프롬프트에서 읽는 명령어 등 인터프리터의 메인 프로그램이 실행되는 (그렇지 않으면 익명) 범위를 나타냅니다.이 환경에서 관용적인 "conditional script" 스탠자가 스크립트를 실행합니다.

if __name__ == '__main__':
    main()

if __name__ == "__main__"는, 할 때(, 커맨드 라인으로부터 실행해 주세요), 라인으로부터 실행할 수 있는 부분입니다.python myscript.py.

무인 does does 가 뭐죠?if __name__ == "__main__": 할수 수 do do do?

__name__는 모든 네임스페이스에 존재하는 글로벌 변수(Python에서 global은 모듈레벨을 의미합니다)입니다.일반적으로 모듈 이름(예:str라고 입력합니다

단, 마이코드에서와 같이 Python 프로세스에서 실행하는 유일한 특수한 경우입니다.py:

python mycode.py

에는 '네임스페이스' 됩니다.'__main__'__name__.

따라서, 최종 라인을 포함하여

if __name__ == '__main__':
    main()

• mycode의 마지막에 표시됩니다.py 스크립트,
• Python 프로세스에 의해 실행되는 기본 엔트리 포인트 모듈인 경우

스크립트가하게 정의되어 .main실행할 기능.

이 구성을 사용하는 또 다른 장점은 다른 스크립트의 모듈로 코드를 Import한 후 프로그램이 다음을 결정할 때 주요 기능을 실행할 수 있다는 것입니다.

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

문제의 코드인 "어떻게"의 메커니즘에 대한 많은 다른 견해가 있지만, "왜"를 이해하기 전까지는 이 모든 것이 말이 되지 않았습니다.이것은 특히 새로운 프로그래머들에게 도움이 될 것이다.

파일 "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 abImport 모듈이 합니다.ab은 의 실행됩니다.xy 끝나면 s.가 끝납니다ab됩니다.xy.

는 어떤 합니다.__name__에, 통역사가 대본을 .라고."__main__"외부 스크립트를 실행한 후 반환되는 마스터 스크립트 또는 '홈' 스크립트로 만듭니다.

호출되는 "__main__"에는, 이 「마음대로」로되어 있습니다.__name__ (예:__name__ == "ab.py"） 、 「 」 、 「 。if __name__ == "__main__":는 인터프리터의 테스트로, 최초로 실행된 「홈」스크립트를 해석/복원하고 있는지, 또는 일시적으로 다른(복원) 스크립트를 엿보고 있는지를 판별합니다.이로 인해 프로그래머는 스크립트를 직접 실행하는 경우와 외부에서 호출하는 경우의 동작을 달리할 수 있습니다.

위 코드에서 무슨 일이 일어나고 있는지 이해하기 위해 먼저 의도하지 않은 행과 스크립트에 표시되는 순서에 초점을 맞추겠습니다.- 이 함수에 해 주세요.또는def블록은 호출될 때까지 혼자 아무것도 하지 않습니다.통역사가 혼잣말처럼 중얼거리면 뭐라고 할 수 있을까?

• 이 파일은 xy.py이라고 부릅니다."__main__" __name__★★★★★★ 。
• .__name__ == "ab.py".
• 오, 함수.내가 그걸 기억할게요.
• , 기능 OK, ★★a(); 방금 배웠어요.'ab 파일의 A 함수'를 출력합니다.
• 끝: 일일 to로 , end아아 end end end end end end end end end"__main__"!
• 오, 함수.내가 그걸 기억할게요.
• 하나 더.
• ★★x(); ok, '추가 태스크: 다른 프로젝트에서 유용할 수 있음'을 인쇄합니다.
• 게 ? 안안?if되었습니다(변수).__name__ 설정되었습니다."__main__"）을main()기능을 수행하고 '주기능: 여기가 동작 위치'를 인쇄합니다.

두 은 '이 '만약에 '는 의미입니다 '이렇게 하면'"__main__"하여 'home'이라는 합니다.main() '. 렇, 」, 」, 」, 」, 」, 」, 」, 」, 」, 」, 」, ", ", ", ", ", ", ".def main():블록 업은 '블럭 업'입니다.

왜 이것을 실장하는가?

아까 수입 명세서에 대해 말했던 거 기억나?모듈을 Import하면 모듈을 '인식'하고 다음 명령을 기다리는 것만이 아니라 스크립트에 포함된 모든 실행 가능한 작업이 실행됩니다.는 ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★.main()다른 스크립트에서 가져올 때 즉시 실행되지 않도록 격리하여 효과적으로 격리합니다.

, 으로는 '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '하다', '다', '다', '다'가 .main()외부로부터 전화를 받지 않는 경우가 많습니다. 한 더 , 하는 게 요? 리리면면면면면면면면면면main()스크립트를 호출하는 이유는 무엇입니까?많은 사람들이 파일의 나머지 코드와 독립적으로 실행되도록 구축된 독립형 함수로 스크립트를 구성하기 때문입니다.그런 다음 나중에 스크립트 본문의 다른 곳으로 호출됩니다.그래서 이렇게 된 거야

하지만 코드가 없어도 작동한다.

네, 그렇습니다.이러한 개별 함수는 내부에는 포함되어 있지 않은 인라인 스크립트에서 호출할 수 있습니다.main()기 if.를 작성하는 데 그 가 더 이지 않기 때문에 구조에 않습니다프로그래밍의 초기 단계에서 필요한 작업을 수행하는 인라인 스크립트를 작성하는 데 익숙해져 있다면, 다시 그 작업을 수행할 필요가 있다면...읽을 수 있습니다.

그러나 이 스크립트는 함수를 외부에서 호출할 수 없습니다. 호출할 경우 변수의 계산과 할당을 즉시 시작할 수 있기 때문입니다.기능을 재사용하려고 하면 새로운 스크립트가 이전 스크립트와 매우 밀접하게 관련되어 있기 때문에 서로 모순되는 변수가 있을 수 있습니다.

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

(여담이지만, 이 질문에는 @kindall의 답변이 포함되어 있습니다.이 답변은 방법을 이해하는 것이 아니라 이유를 이해하는 데 도움이 되었습니다.유감스럽게도, 이것은 복제품이라고 마크 되어 있습니다만, 착오가 있는 것 같습니다.)

「 」의 .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')

---

첫 번째 Import ( Import)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'

레벨의 「」: 「」만이, 「」인 해 주세요.print()입니다.my_test_module행됩니니다다

---

두 번째 : 호출하다my_test_module.py

''를 실행하면''' 이 됩니다.my_test_module.py로 Python 스크립트, Python 스크립트, Python 스크립트, 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'

---

보다 포괄적인 설명은 "파이썬에서 하는 일"을 참조하십시오.

가 있는 ( 「」 「」 「」M.py가져오지될 때 이러한 케이스,는, 「Import」아래에 할 수 .이 아래에 이러한 스테이트먼트(테스트 케이스, 인쇄 스테이트먼트)를 배치할 수 있습니다.if

Import하지 ) """ ("Import")__name__가 "예상하지 않다"로 설정됩니다."__main__"는되 를 할__name__은 다른 , 이름)을 얻을 수 있을 것입니다.'M'의 모듈을 함께 및 케이스가 이 됩니다 이것은 다양한 종류의 모듈을 함께 실행하여 특정 입출력 스테이트먼트를 구분하고 테스트 케이스가 있는 경우에도 도움이 됩니다.

요컨대, 이것을 사용하세요.if __name__ == "main"수입하다

말하면, '아예'입니다.__name__는 스크립트를 메인모듈로 실행할지 Import된 모듈로 실행할지를 정의하는 각 스크립트에 정의되는 변수입니다.

스크립트가 2개 있는 경우

#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 스크립트를 작성하고, 다른 목적에 도움이 되는 함수의 보트를 실장한다고 합시다.는, 를 Import 해, 사용할 수는 「」, 「 Import」, 「Import」, 「Import」, 「Import」, 「Import」, 「Import」, 「Import」의 범위내에서만 실행됩니다).if __name__ == "__main__":콘텍스트)를 참조해 주세요.반면 C/C++에서는 파일을 포함하는 다른 모듈로 분할해야 합니다.아래의 상황을 상상해 보세요.

화살표는 Import 링크입니다.3개의 모듈이 각각 이전 모듈코드를 포함하려고 하면 6개의 파일(9개의 실장 파일 카운트)과 5개의 링크가 있습니다.이 때문에 C프로젝트가 특별히 라이브러리로 컴파일되지 않는 한 다른 코드를 C프로젝트에 포함시키기가 어렵습니다.이제 Python을 상상해 보십시오.

모듈을 작성하면 누군가가 코드를 사용하려고 하면 Import만 하고__name__변수는 프로그램의 실행 가능 부분을 라이브러리 부분에서 분리하는 데 도움이 됩니다.

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

이 코드가 에 있다고 가정합니다.x.py:

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

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

단, 다른 모듈을 실행하고 있을 때는 블록A(B가 아닌)가 실행됩니다.y.py예를 들어, 어떤 경우x.pyImport 되어 거기서 코드가 실행됩니다(예를 들어 함수가x.py에서 호출됩니다.y.py).

요약하자면, 몇 가지 사항을 알아야 합니다.

1. import a동작은 실제로 실행할 수 있는 모든 것을 실행합니다.a.py의 각 행을 의미합니다.a.py

2. 포인트 1이 있기 때문에 모든 것을 실행하고 싶지 않을 수 있습니다.a.py가져올 때

3. 포인트 2의 문제를 해결하기 위해 Python은 상태 체크를 사용할 수 있습니다.

4. __name__모두 암묵적인 변수입니다..py모듈:

• 언제a.py이imported, 가치__name__의a.pymodule 이 파일명으로 설정되어 있습니다.a"
• 언제a.py를 사용하여 직접 실행됩니다.python a.py", 가치__name__문자열로 설정됩니다.__main__

5. Python이 변수를 설정하는 방법에 따라__name__각 모듈에 대해 포인트 3을 달성하는 방법을 알고 있습니까?답은 꽤 쉽죠?if 조건 사용:if __name__ == "__main__": // do A

• 그리고나서python a.py파트를 실행하다// do A
• 그리고.import a이 부분은 생략합니다.// do A

6. 만약을 위해서도 넣을 수 있다.__name__ == "a"기능적인 요구에 따라 다르지만, 거의 그렇지 않습니다.

Python의 특별한 점은 4점!나머지는 기본적인 논리일 뿐입니다.

_{이 페이지 내내 답을 너무 많이 읽었어요.만약 당신이 그 답을 안다면, 당신은 확실히 이해할 수 있을 것이고, 그렇지 않다면 당신은 여전히 혼란스러울 것이라고 말할 것입니다.}

Python을 인터랙티브하게 실행하면 로컬의__name__variable에는 값이 할당되어 있습니다.__main__마찬가지로 명령줄에서 Python 모듈을 실행하면 다른 모듈로 Import하지 않고 Python 모듈을 실행할 수 있습니다.__name__Atribute에는 값이 할당됩니다.__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.

고려사항:

if __name__ == "__main__":
    main()

이 체크에 의해,__name__Python 스크립트의 속성은 다음과 같습니다."__main__"즉, 프로그램 자체가 실행되면 속성은__main__따라서 프로그램이 실행됩니다(이 경우,main()기능).

단, Python 스크립트가 모듈에 의해 사용되는 경우 외부 코드는if스테이트먼트가 실행되기 때문에if __name__ == "__main__"프로그램이 모듈로 사용되는지 여부를 확인하는 데만 사용되며, 따라서 코드를 실행할지 여부를 결정합니다.

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

뭐가__name__?

__name__는 DunderAlias: 글로벌 변수(모듈에서 접근 가능)로 간주할 수 있으며 와 동일하게 동작합니다.

이것은 다음에 나타내는 문자열(위에서 설명한 바와 같이 글로벌)입니다.type(__name__)(비활성화)<class 'str'>Python 3 버전과 Python 2 버전 모두에 내장된 표준입니다.

어디에

스크립트에서만 사용할 수 있는 것이 아니라 인터프리터와 모듈/패키지에서도 사용할 수 있습니다.

인터프리터:

>>> print(__name__)
__main__
>>>

스크립트:

test_file.py:

print(__name__)

그 결과__main__

모듈 또는 패키지:

some file.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__모든 것이 명확해집니다.

는 지정된 값이 참일 경우 실행되는 코드 블록을 포함하는 흐름 제어문입니다.우리는 그것을 보았다.__name__어느쪽이든 좋다__main__또는 Import된 파일명을 지정합니다.

즉, 만약__name__와 동등하다__main__파일은 메인 파일이어야 하며 스크립트에 Import된 모듈 또는 패키지가 아니라 실제로 실행 중이어야 합니다(또는 인터프리터).

사실이라면__name__의 가치를 가지고 있다__main__그러면 그 코드 블록에 무엇이 있든지 실행될 겁니다.

이는 실행 중인 파일이 메인 파일(또는 인터프리터에서 직접 실행 중인 파일)인 경우 해당 조건을 실행해야 함을 나타냅니다.패키지의 경우 패키지는 사용할 수 없습니다.또한 이 값은__main__.

모듈

__name__모듈 이름을 정의하기 위해 모듈에서 사용할 수도 있습니다.

변종

다른, 덜 흔하지만 유용한 작업도 할 수 있습니다.__name__, 여기에 몇 가지 보여 드리겠습니다.

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

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

파일이 메인일 경우 한 가지 조건 실행 및 메인 파일이 아닌 경우 다른 조건 실행

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

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

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

저는 그 답을 심도 있고 간단한 말로 설명하는 것이 가장 좋다고 생각합니다.

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

__main__: 다른 프로그래밍 언어와 마찬가지로 Python도 실행 엔트리 포인트(메인)가 있습니다. '__main__' 는 최상위 코드가 실행되는 스코프 이름입니다.기본적으로 Python 모듈을 사용하는 방법은 두 가지가 있습니다.스크립트로 직접 실행하거나 Import합니다.모듈이 스크립트로서 동작하고 있는 경우,__name__로 설정되어 있다.__main__.

그 때문에, 의 가치는__name__Atribute가 로 설정되어 있다.__main__모듈이 메인 프로그램으로 실행될 때.그 이외의 경우,__name__모듈 이름을 포함하도록 설정됩니다.

명령줄에서 Python 파일을 호출할 때 특히 유용합니다.이것은 보통 "main()" 함수를 호출하거나 명령줄 인수 처리와 같은 다른 적절한 시작 코드를 실행하기 위해 사용됩니다.

그것은 여러 가지 방법으로 쓰여질 수 있다.또 다른 예는 다음과 같습니다.

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

프로덕션 코드에 이 코드를 사용해야 한다는 것은 아니지만, 이 코드에 대해 "만화적인" 것이 없다는 것을 보여주는 역할을 합니다.if __name__ == '__main__'.

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

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

Python은 소스 코드 파일을 로드하면 그 안에 있는 모든 코드를 실행합니다.(파일에 정의되어 있는 모든 메서드와 함수를 호출하는 것은 아니지만 정의되어 있습니다.)

인터프리터는 소스 코드 파일을 실행하기 전에 해당 파일에 대한 몇 가지 특수 변수를 정의합니다. __name_은 Python이 각 소스 코드 파일에 대해 자동으로 정의하는 특수 변수 중 하나입니다.

Python이 이 소스 코드 파일을 메인 프로그램(즉, 실행 중인 파일)으로 로드하는 경우, 이 파일의 특별한 __name_ 변수를 값 "_main__"으로 설정합니다.

다른 모듈에서 Import할 경우 __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"과 동일하지 않기 때문입니다.

도움이 됐으면 좋겠네요.

if __name__ == "__main__":는 기본적으로 최상위 스크립트 환경이며 인터프리터를 지정합니다('먼저 실행할 우선순위가 가장 높다').

'__main__'는 최상위 코드가 실행되는 스코프 이름입니다.모듈의__name__와 동등하게 설정되어 있다.'__main__'표준 입력, 스크립트 또는 대화형 프롬프트에서 읽을 때 사용합니다.

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

고려사항:

print __name__

위의 출력은 다음과 같습니다.__main__.

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

위의 문장은 참이며 "direct method"로 출력됩니다.다른 클래스에서 이 클래스를 Import한 경우 Import 중에 "direct method"가 출력되지 않는다고 가정합니다.__name__ equal to "first model name".

파일을 스크립트 및 Import 가능한 모듈로 사용할 수 있습니다.

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

이유

if __name__ == "__main__":
    main()

는 주로 코드를 직접 Import함으로써 발생할 수 있는 Import Lock 문제를 회피하기 위한 것입니다.너는 원한다main()파일이 직접 호출된 경우 실행할 수 있습니다(즉,__name__ == "__main__"그러나 코드를 Import한 경우에는 Import 잠금 문제를 피하기 위해 Import자가 실제 메인 모듈에서 코드를 입력해야 합니다.

단, 여러 진입점을 지원하는 방법론에 자동으로 서명할 수 있습니다.다음을 사용하여 프로그램을 실행할 수 있습니다.main()하지만 그럴 필요는 없어요하는 동안에setup.py예기하다main(), 다른 도구에서는 대체 진입점을 사용합니다.예를 들어 파일을 실행한다.gunicorn프로세스를 정의한다.app()대신 기능하다main()와 마찬가지로setup.py,gunicornImport Lock 문제로 인해 Import 중에 아무 작업도 수행하지 않도록 코드를 Import합니다.

Python의 모든 모듈에는__name__의 가치__name__속성은__main__모듈을 직접 실행하는 경우, 예를 들어python my_module.py그렇지 않은 경우(예:import my_module)의 가치__name__는 모듈 이름입니다.

간단히 설명하자면 작은 예시입니다.

스크립트 테스트화이

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

이제 위의 스크립트를 다른 스크립트에서 호출한다고 가정합니다.

스크립트 external_calling.화이

import test

print(test.apple)
test.hello_world()

print(test.__name__)

이 작업을 실행하면

python external_calling.py

산출량

42
I am inside hello_world
test

따라서 위의 내용은 다른 스크립트에서 테스트를 호출할 때 루프가 발생할 경우__name__에test.py실행되지 않습니다.

초보자라면 간단한 스크립트에는 이 코드가 필요하지 않다는 답변만 필요할 것입니다.이 기능은 다음 작업을 수행할 수 있는 경우에만 유용합니다.import스크립트(또는unpickle기타 기타 문제 이외의 시나리오에 대해서는 여기를 참조하십시오).

조금 다른 말로 하자면if __name__guard는 코드를 다른 코드로부터 숨기는 메커니즘입니다.무언가를 숨길 특별한 이유가 없는 경우, 다음을 수행하지 마십시오.코드를 숨길 필요가 없는 경우import이 경비대 뒤에 두지 말고, 만약 그렇다면, 가능한 한 숨기지 마세요.

조금 더 자세히 설명하자면 간단한 스크립트가 있다고 합시다.fib.py(이 답변에서 추출):

# XXX FIXME: useless (see below)
if __name__ == "__main__":
    n = int(input('Write a number: '))
    a, b = 0, 1
    while b < n:
        a, b = b, a+b
    print('Fibonacci number %i: %i' % (n, b))

자, 이제, 당신이 단순히python fib.py정상적으로 동작합니다.그렇지만__name__항상 그럴 것이다"__main__"이 시나리오에서는 이 조건은 실제로 불필요합니다.이 스크립트는 단순화할 수 있습니다.

n = int(input('Write a number: '))
a, b = 0, 1
while b < n:
    a, b = b, a+b
print('Fibonacci number %i: %i' % (n, b))

지금, 당신은 할 수 없다.import fib새 버전을 사용할 수 있지만 처음부터 그렇게 할 계획이 없다면 이 버전이 더 낫습니다. 왜냐하면 더 단순하고 명확하기 때문입니다.

만약 당신이 할 수 있습니다.import fib첫 번째 버전도 쓸모가 없습니다.유효한 코드가 사용자가 실행하지 않는 섹션에 있기 때문입니다.import이 파일(이 경우)__name__하지 않을 것이다"__main__"이 경우 적절한 설계는 코드를 리팩터링하여 유용한 부품이 필요할 때 실행할 수 있도록 하는 것입니다.imported it.

def main():
    n = int(input('Write a number: '))
    a, b = 0, 1
    while b < n:
        a, b = b, a+b
    print('Fibonacci number %i: %i' % (n, b))

if __name__ == "__main__":
    main()

자, 만약 당신이import fib에의 문의main()실행은 되지 않지만 실행 시python fib.py,그것은 그럴거다.

실제로 더 나은 설계는 재사용 가능한 부품(실제 계산)을 사용자가 볼 수 있는 입력/출력에서 분리하는 것입니다.

def fibn(n: int) -> int:
    a, b = 0, 1
    while b < n:
        a, b = b, a+b
    return b

def main() -> None:
    n = int(input('Write a number: '))
    print('Fibonacci number %i: %i' % (n, fibn(n)))

if __name__ == "__main__":
    main()

이제 할 수 있습니다.from fib import fibn에 전화합니다.fibn()이 기능을 수행하는 코드에서 기능합니다.import.

(기능을 호출했습니다.fibn()이 예의 내용을 명확히 하기 위해서입니다.실생활에서는 그렇게 말할 수 있다.fib()하고 있다from fib import fib.)

마찬가지로,import에 전화합니다.main사용할 수 있습니다.

질문의 코드로 돌아가서 마찬가지로 코드를if발신자가 원할 경우 해당 기능을 호출할 수 있도록 함수로도 변환합니다.

def main():
    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__":
    main()

이것에 의해, 의 범위가 변경됩니다.lock변수: 주변 코드에 액세스 할 필요가 있는 경우는, 그 코드에 액세스 할 필요가 있습니다.global(혹은 아마, 더 나은 리팩터, 리팩터main로.return lock발신자가 자신의 로컬 변수에 값을 캡처하도록 합니다).

(C와 같은 언어와는 달리 이름은mainPython에는 특별한 의미가 없지만 실행할 물건의 이름으로 사용하는 것은 일반적인 관례입니다.아직까진 명시적으로 불러야 해main()(C와 달리)

간단히 말하면:

아래에 표시되는 코드if __name__ == "__main__":Python 파일이 실행되었을 때만 호출됩니다.python example1.py

단, Python 파일을 Import하고 싶다면example1.py예를 들어 다른 Python 파일을 사용하기 위한 모듈로서example2.py, 아래의 코드if __name__ == "__main__":실행되거나 효과가 없습니다.

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

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

2. 테스트 목적으로 클래스 스탠드를 단독으로 실행합니다.

후자의 경우 클래스에는 public static void main() 메서드가 포함되어 있어야 합니다.Python에서는 이 용도는 글로벌하게 정의된 라벨에 의해 제공됩니다.'__main__'.

이 .py 파일이 다른 .py 파일에 의해 Import된 경우 아래 코드는if문이 실행되지 않습니다.

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

그것은 보통 테스트용으로 쓰여져 있다.

Python 인터프리터가 특정 모듈을 실행하고 있는 경우__name__global variable의 값은 다음과 같은 값을 가집니다."__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

이 파일을 Import 할 경우 A를 파일B로 하고 B를 실행합니다.if __name__ == "__main__"파일 A가 거짓이 되서 출력되니까 날 볼 수 없어

b

과연.__name__ == '__main__':꽤 자주.

모듈의 Import 여부를 확인합니다.

즉, 내부 코드는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__

모든 답변이 기능을 거의 설명했습니다.다만, 그 사용의 예를 들면, 한층 더 컨셉을 클리어 하는 데 도움이 될 가능성이 있습니다.

Python 파일 a.py과 b.py이 2개 있다고 가정합니다.여기서 a.py은 b.py을 Import합니다.a.py 파일을 실행하면 "import b.py" 코드가 먼저 실행됩니다.나머지 a.py 코드가 실행되기 전에 파일 b.py 내의 코드가 완전히 실행되어야 합니다.

b.py 코드에는 b.py 파일만의 코드가 있으며 b.py 파일을 Import한 다른 파일(b.py 파일 이외)은 실행하고 싶지 않습니다.

이게 바로 이 코드 행이 체크하는 것입니다.코드를 실행하고 있는 메인파일(즉, b.py)인 경우(이 경우는 실행되고 있는 메인파일)에는 코드만 실행됩니다.

언급URL : https://stackoverflow.com/questions/419163/what-does-if-name-main-do