Gdy skrypt jest uruchamiany, przekazując go jako polecenie do interpretera Pythona,

python myscript.py

Cały kod znajdujący się na poziomie wcięcia 0 jest wykonywany. Funkcje i klasy, które są zdefiniowane, są dobrze zdefiniowane, ale żaden z ich kodu nie zostanie uruchomiony. W przeciwieństwie do innych języków, nie ma funkcji main(), która jest uruchamiana automatycznie-Funkcja main() jest w domyśle całym kodem na najwyższym poziomie.

W tym przypadku kod najwyższego poziomu jest blokiem if. __name__ jest wbudowanym zmienna, która ewaluuje do nazwy bieżącego modułu. Jeśli jednak moduł jest uruchamiany bezpośrednio (jak w myscript.py powyżej), to zamiast tego __name__ jest ustawiony na łańcuch "__main__". W ten sposób możesz sprawdzić, czy twój skrypt jest uruchamiany bezpośrednio, czy importowany przez coś innego, testując

if __name__ == "__main__":
    ...

Jeśli twój skrypt jest importowany do innego modułu, jego różne definicje funkcji i klas zostaną zaimportowane i jego kod najwyższego poziomu zostanie wykonany, ale kod w ciele wtedy if powyższa klauzula nie zostanie uruchomiona, ponieważ warunek nie jest spełniony. Jako podstawowy przykład rozważ następujące dwa skrypty:

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

Teraz, jeśli wywołasz interpreter jako

python one.py

Wyjście będzie

top-level in one.py
one.py is being run directly

If you run two.py instead:

python two.py

Dostajesz

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

Tak więc, gdy moduł one zostanie załadowany, jego __name__ równa się "one" zamiast "__main__".

Najprostsze wyjaśnienie zmiennej __name__ (imho) jest następujące:

Utwórz następujące pliki.

# a.py
import b

I

# b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__

Uruchomienie ich da ci to wyjście:

$ python a.py
Hello World from b!

Jak widzisz, gdy moduł jest importowany, Python ustawia globals()['__name__'] w tym module na nazwę modułu.

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

Jak widzisz, gdy plik jest wykonywany, Python ustawia globals()['__name__'] w tym Pliku na "__main__".

Co robi if __name__ == "__main__":?

Aby zarysować podstawy:

• Zmienna globalna, __name__, w module, który jest punktem wejścia do twojego programu, to '__main__'. W przeciwnym razie jest to nazwa, którą importujesz moduł.

• Tak więc kod w bloku if będzie uruchamiany tylko wtedy, gdy moduł jest punktem wejścia do twojego programu.

• Pozwala to na importowanie kodu w module przez inne moduły, bez wykonywania kodu blok pod importem.

Tworzenie i testowanie kodu

Powiedz, że piszesz skrypt Pythona zaprojektowany do użycia jako moduł:

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

Można można przetestować moduł dodając to wywołanie funkcji na dole:

do_important()

I uruchomienie go (w wierszu polecenia) z czymś w rodzaju:

~$ python important.py

Problem

Jeśli jednak chcesz zaimportować moduł do innego scenariusz:

import important

Przy imporcie, funkcja do_important zostanie wywołana, więc prawdopodobnie skomentujesz wywołanie funkcji, do_important(), na dole.

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

I wtedy będziesz musiał pamiętać, czy skomentowałeś swoje wywołanie funkcji testowej. Ta dodatkowa złożoność oznaczałaby, że prawdopodobnie zapomnisz, co sprawi, że proces rozwoju będzie bardziej kłopotliwy.

A Better Way

Zmienna __name__ wskazuje przestrzeń nazw wszędzie tam, gdzie występuje interpreter Pythona być w tej chwili.

Wewnątrz zaimportowanego modułu, jest to nazwa tego modułu.

Ale wewnątrz modułu podstawowego (lub interaktywnej sesji Pythona, tj. pętli Read, Eval, Print lub REPL interpretera) uruchamiasz wszystko z jego "__main__".

Więc jeśli sprawdzisz przed wykonaniem:

if __name__ == "__main__":
    do_important()

Z powyższym kodem, Twój kod będzie wykonywany tylko wtedy, gdy uruchomisz go jako główny moduł (lub celowo wywołasz go z innego skryptu).

An Even Better Way

Co jeśli chcemy uruchomić ten proces biznesowy spoza modułu?

Jeśli umieścimy kod, który chcemy ćwiczyć podczas tworzenia i testowania w funkcji takiej jak ta, a następnie wykonamy naszą kontrolę dla '__main__' natychmiast po:

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

Mamy teraz ostateczną funkcję dla końca naszego modułu, która będzie działać, jeśli uruchomimy moduł jako moduł podstawowy.

Pozwoli modułowi i jego funkcje i klasy mają być zaimportowane do innych skryptów bez uruchamiania funkcji main, a także umożliwią wywołanie modułu (oraz jego funkcji i klas) podczas uruchamiania z innego modułu '__main__', tj.

import important
important.main()

Ten idiom można również znaleźć w dokumentacji Pythona w wyjaśnieniu modułu __main__. tekst ten stwierdza:

Ten moduł reprezentuje (inaczej anonimowy) zakres, w którym główny program interpretera wykonuje - polecenia odczytane z standardowe wejście, z pliku skryptu lub z interaktywnego monitu. Informatyka czy to środowisko, w którym idiomatyczny "skrypt warunkowy" powoduje uruchomienie skryptu:

if __name__ == '__main__':
    main()

if __name__ == "__main__" jest częścią, która jest uruchamiana, gdy skrypt jest uruchamiany z (powiedzmy) linii poleceń przy użyciu polecenia python myscript.py.

Co robi if __name__ == "__main__":?

__name__ jest zmienną globalną (w Pythonie globalna oznacza w rzeczywistości na poziomie modułu), która istnieje we wszystkich przestrzeniach nazw. Zazwyczaj jest to nazwa modułu (jako typ str).

Jako jedyny szczególny przypadek, jednak w każdym uruchomionym procesie Pythona, jak w mycode.py:

python mycode.py

W przeciwnym wypadku anonimowa globalna przestrzeń nazw jest przypisana do jej __name__.

Tak więc, włączając Finał linie

if __name__ == '__main__':
    main()

• na końcu twojego mycode.py skrypt,
Gdy jest to podstawowy moduł punktu wejścia, który jest uruchamiany przez proces Pythona,]}

Spowoduje uruchomienie unikalnie zdefiniowanej funkcji main skryptu.

Kolejna zaleta użycia tej konstrukcji: możesz zaimportować kod jako moduł do innego skryptu, a następnie uruchomić główną funkcję, jeśli i kiedy twój program zdecyduje:

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

Istnieje wiele różnych ujęć na temat mechaniki danego kodu, "Jak", ale dla mnie nic z tego nie miało sensu, dopóki nie zrozumiałem "dlaczego". Powinno to być szczególnie pomocne dla nowych programistów.

Weź plik "ab.py": {]}

def a():
    print('A function in ab file');
a()

I drugi plik "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()

Co ten kod właściwie robi?

Kiedy wykonujesz xy.py, TY import ab. Instrukcja import uruchamia moduł natychmiast przy imporcie, więc operacje ab get executed before the rest of xy ' s. raz zakończone ab, it continues with xy.

Interpreter śledzi, które skrypty są uruchomione z __name__. Kiedy uruchamiasz skrypt - bez względu na jego nazwę - interpreter wywołuje go "__main__", czyniąc z niego skrypt główny lub domowy, do którego jest zwracany po uruchomieniu zewnętrznego skryptu.

Każdy inny skrypt wywołany z tego skryptu "__main__" ma przypisaną nazwę pliku jako jego __name__ (np. __name__ == "ab.py"). Stąd linia if __name__ == "__main__": jest testem interpretera, który określa, czy interpretuje / analizuje skrypt 'home', który został pierwotnie wykonany, czy też tymczasowo zagląda do innego (zewnętrznego) skryptu. Daje to programiście elastyczność, aby skrypt zachowywał się inaczej, jeśli jest wykonywany bezpośrednio, a nie wywoływany zewnętrznie.

Przejdźmy przez powyższy kod, aby zrozumieć, co się dzieje, skupiając się najpierw na niezindeksowanych liniach i kolejności, w jakiej pojawiają się w skryptach. Zapamiętaj tę funkcję-lub def - bloki same nic nie robią, dopóki nie zostaną wezwane. Co tłumacz może powiedzieć, jeśli mamrotał do siebie:

• Otwórz xy.py jako plik 'home'; nazwij go "__main__" W Zmiennej __name__.
• Importuj i otwórz plik za pomocą __name__ == "ab.py".
• Oh, funkcja. Zapamiętam to.
• Ok, funkcja a(); właśnie się tego nauczyłem. Drukowanie " funkcji w pliku ab ".
• koniec pliku; powrót do "__main__"!
• Oh, funkcja. I ' ll remember to.
• kolejny.
• Function x(); ok, drukowanie ' peripheral task: may be useful in other projects '.
Co to jest? if oświadczenie. Cóż, warunek został spełniony( zmienna __name__ została ustawiona na "__main__"), więc wprowadzę funkcję main() i wydrukuję " main function: this is where the action is ".

Dwie dolne linie oznaczają: "jeśli jest to skrypt "__main__" lub 'home', wykonaj funkcję o nazwie main()". Dlatego zobaczysz def main(): blok u góry, który zawiera główny przepływ funkcjonalności skryptu.

Po co to wdrażać?

Pamiętasz, co mówiłem wcześniej o deklaracjach importu? Po zaimportowaniu modułu nie tylko go "rozpoznaje" i czeka na dalsze instrukcje - w rzeczywistości uruchamia wszystkie operacje wykonywalne zawarte w skrypcie. Tak więc, umieszczenie mięsa skryptu w funkcji main() skutecznie go kwarantanny, umieszczenie go w izolacji tak, że nie zostanie natychmiast uruchomiony po zaimportowaniu przez inny skrypt.

Znowu będą wyjątki, ale powszechną praktyką jest to, że main() zwykle nie jest wywoływany zewnętrznie. Więc może zastanawiasz się jeszcze jedna rzecz: jeśli nie dzwonimy main(), dlaczego w ogóle dzwonimy do skryptu? Dzieje się tak dlatego, że wiele osób konstruuje swoje skrypty za pomocą autonomicznych funkcji, które są zbudowane tak, aby były uruchamiane niezależnie od reszty kodu w pliku. Są później nazywane gdzieś indziej w ciele scenariusz. Co sprowadza mnie do tego:

Ale kod działa bez niego

Jeśli w naszym module (M.py) znajdują się pewne instrukcje, które chcemy wykonać, gdy będzie on uruchamiany jako main (nie importowany), możemy umieścić te instrukcje (przypadki testowe, instrukcje print) w tym bloku if.

Domyślnie (gdy moduł działa jako main, a nie importowany) zmienna __name__ jest ustawiona na "__main__", A gdy zostanie zaimportowana, zmienna __name__ otrzyma inną wartość, najprawdopodobniej nazwę modułu ('M'). Jest to pomocne w uruchamianiu różnych wariantów Moduły razem i oddzielenie ich konkretnych instrukcji wejściowych i wyjściowych, a także jeśli istnieją jakieś przypadki testowe.

W skrócie , użyj tego bloku ' if __name__ == "main"', aby zapobiec uruchamianiu (pewnego) kodu podczas importowania modułu.

Spójrzmy na odpowiedź w bardziej abstrakcyjny sposób:

Załóżmy, że mamy ten kod w x.py:

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

Bloki A i B są uruchamiane, gdy bierzemy "x.py".

Ale po prostu Blok A (a nie B) jest uruchamiany, gdy uruchamiamy inny moduł, "y.py" na przykład, w którym importowany jest x. y i stamtąd uruchamiany jest kod (np. gdy funkcja w x.py " nazywa się od y.py).

Podczas interaktywnego uruchamiania Pythona lokalnej zmiennej __name__ przypisana jest wartość __main__. Podobnie, gdy wykonujesz moduł Pythona z linii poleceń, zamiast importować go do innego modułu, jego atrybutowi __name__ przypisywana jest wartość __main__, a nie rzeczywista nazwa modułu. W ten sposób moduły mogą spojrzeć na własną wartość __name__, Aby samodzielnie określić, w jaki sposób są używane, czy to jako wsparcie dla innego programu, czy jako główna aplikacja wykonywana z wiersz poleceń. Dlatego następujący idiom jest dość powszechny w modułach Pythona:

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.

Mówiąc prościej, __name__ jest zmienną zdefiniowaną dla każdego skryptu, która określa, czy skrypt jest uruchamiany jako główny moduł, czy jest uruchamiany jako importowany moduł.

Więc jeśli mamy dwa skrypty;

#script1.py
print "Script 1's name: {}".format(__name__)

I

#script2.py
import script1
print "Script 2's name: {}".format(__name__)

Wyjście z wykonującego skrypt1 to

Script 1's name: __main__

A wyjście z wykonującego skrypt2 to:

Script1's name is script1
Script 2's name: __main__

Jak widzisz, __name__ mówi nam, który kod jest 'głównym' modułem. Jest to świetne, ponieważ możesz po prostu napisać kod i nie musisz się martwić o problemach strukturalnych, takich jak w C / C++, gdzie, jeśli plik nie implementuje funkcji 'main', to nie może być skompilowany jako plik wykonywalny, a jeśli tak, nie może być używany jako biblioteka.

Powiedzmy, że piszesz skrypt Pythona, który robi coś wielkiego i implementujesz mnóstwo funkcji, które są przydatne do innych celów. Jeśli chcę ich użyć, mogę po prostu zaimportować Twój skrypt i używać go bez wykonywania programu (biorąc pod uwagę, że Twój kod jest wykonywany tylko w kontekście if __name__ == "__main__":). Natomiast w C / c++ trzeba by te kawałki podzielić na osobny moduł, który następnie zawiera plik. Obraz sytuacji poniżej;

Strzałki są odnośnikami do importu. Dla trzech modułów, z których każdy próbuje dołączyć poprzedni kod modułów, jest sześć plików (dziewięć, licząc pliki implementacyjne) i pięć linków. Utrudnia to włączenie innego kodu do projektu C, chyba że jest on skompilowany specjalnie jako biblioteka. Teraz wyobraź sobie to dla Python:

Piszesz moduł, a jeśli ktoś chce użyć Twojego kodu, po prostu go importuje i zmienna __name__ może pomóc oddzielić część wykonywalną programu od części biblioteki.

Rozważmy:

if __name__ == "__main__":
    main()

Sprawdza, czy __name__ atrybutem skryptu Pythona jest "__main__". Innymi słowy, jeśli program jest wykonywany, atrybutem będzie __main__, więc program zostanie wykonany(w tym przypadku funkcja main()).

Jednakże, jeśli twój skrypt w Pythonie jest używany przez moduł, każdy kod spoza instrukcji if zostanie wykonany, więc if \__name__ == "\__main__" jest używany tylko do sprawdzenia, czy program jest używany jako moduł, czy nie, i dlatego decyduje, czy uruchomić kod.

przed wyjaśnieniem czegokolwiek na temat if __name__ == '__main__' ważne jest, aby zrozumieć, czym jest __name__ i co robi.

Co to jest __name__?

__name__ jest DunderAlias - może być traktowana jako zmienna globalna (dostępna z modułów) i działa w podobny sposób jak global.

Gdzie:

Może być używany nie tylko w skryptach, ale może być również znaleziony zarówno w interpreterze, jak i w modułach/pakietach.

Interpreter:

>>> print(__name__)
__main__
>>>

Skrypt:

test_file.py :

print(__name__)

W wyniku __main__

Moduł lub pakiet:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

W wyniku somefile

Zauważ, że gdy jest używany w pakiecie lub module, __name__ przyjmuje nazwę pliku. Ścieżka rzeczywistego modułu lub ścieżki pakietu nie jest podana, ale posiada własne DunderAlias __file__, które na to pozwala.

Powinieneś zobaczyć, że gdzie __name__, gdzie jest głównym plikiem (lub programem), zawsze zwróci __main__, a jeśli moduł / pakiet lub cokolwiek, co jest uruchamiane z innego skryptu Pythona, zwróci nazwę pliku, z którego pochodzi.

Praktyka:

Bycie zmienną oznacza, że jej wartość może być nadpisana ("can" nie oznacza "powinna"), nadpisanie wartości __name__ spowoduje brak czytelności. Więc nie rób tego, z jakiegokolwiek powodu. Jeśli potrzebujesz zmiennej, zdefiniuj nową zmienną.

Zawsze zakłada się, że wartość __name__ to __main__ lub nazwa pliku. Po raz kolejny zmiana tej wartości domyślnej spowoduje więcej zamieszania, że będzie to dobre, powodując problemy dalej w dół linii.

przykład:

>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>

Ogólnie uważa się za dobrą praktykę umieszczanie if __name__ == '__main__' w skryptach.

Teraz odpowiedz if __name__ == '__main__':

teraz wiemy, że zachowanie __name__ rzeczy stają się jaśniejsze:

An if jest Instrukcja flow control zawierająca blok kodu zostanie wykonana, jeśli podana wartość jest prawdziwa. Widzieliśmy, że {[8] } może przyjąć albo __main__ lub nazwa pliku, z którego został zaimportowany.

Oznacza to, że jeśli {[8] } jest równe __main__, to plik musi być plikiem głównym i musi być rzeczywiście uruchomiony( lub jest to interpreter), a nie moduł lub pakiet zaimportowany do skryptu.

Jeśli rzeczywiście __name__ przyjmuje wartość __main__ to cokolwiek jest w tym bloku kodu będzie wykonać.

To mówi nam, że jeśli uruchomiony plik jest plikiem głównym (lub uruchamiany bezpośrednio z interpretera), to warunek ten musi zostać spełniony. Jeśli jest to pakiet, to nie powinien, a wartość nie będzie __main__.

Moduły:

__name__ może być również używany w modułach do definiowania nazwy modułu

Warianty:

Możliwe jest również wykonywanie innych, mniej powszechnych, ale przydatnych rzeczy z __name__, Niektóre pokażę tutaj:

Wykonanie tylko wtedy, gdy plik jest modułem lub Pakietem:

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

Uruchomienie jednego warunku, jeśli plik jest głównym, a drugiego, jeśli nie jest:

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

Można go również używać do dostarczania uruchamialnych funkcji pomocy / narzędzi w pakietach i modułach bez skomplikowanego użycia bibliotek.

Pozwala również na uruchamianie modułów z linii poleceń jako skryptów głównych, co również może być bardzo przydatne.

Istnieje wiele zmiennych, które System (interpreter Pythona) dostarcza dla plików źródłowych (modułów). Możesz uzyskać ich wartości w dowolnym momencie, więc skupmy się na zmiennej/atrybucie __name__:

Gdy Python ładuje plik kodu źródłowego, wykonuje on cały kod znajdujący się w nim. (Zauważ, że nie wywołuje wszystkich metod i funkcji zdefiniowanych w pliku, ale je definiuje.)

Zanim interpreter wykona plik kodu źródłowego, definiuje kilka specjalnych zmiennych dla tego pliku; __name__ jest jedną z tych specjalnych zmiennych, które Python automatycznie definiuje dla każdego pliku kodu źródłowego.

Jeśli Python ładuje ten plik kodu źródłowego jako główny program (tzn. plik, który uruchamiasz), to ustawia specjalną zmienną __name__, aby ten plik miał wartość "__main__".

Jeśli jest importowany z innego modułu, __Nazwa _ _ zostanie ustawiona na nazwę tego modułu.

Więc w twój przykład w części:

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

Oznacza, że blok kodu:

lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

Zostanie uruchomiony tylko wtedy, gdy uruchomisz moduł bezpośrednio; blok kodu nie zostanie uruchomiony, jeśli inny moduł wywoła / importuje go, ponieważ wartość __name _ _ nie będzie równa " main" w tym konkretnym przypadku.

Myślę, że najlepiej jest złamać odpowiedź dogłębnie i prostymi słowami:

__name__: każdy moduł w Pythonie ma specjalny atrybut o nazwie __name__. Jest to wbudowana zmienna, która zwraca nazwę modułu.

__main__: podobnie jak inne języki programowania, Python ma również punkt wejścia do wykonania, np. main. '__main__' jest nazwą zakresu, w którym kod najwyższego poziomu wykonuje . Zasadniczo masz dwa sposoby użycia modułu Pythona: uruchom go bezpośrednio jako skrypt lub zaimportuj go. Gdy moduł jest uruchamiany jako skrypt, jego __name__ jest ustawione na __main__.

Tak więc wartość atrybutu __name__ jest ustawiana na __main__, gdy moduł jest uruchamiany jako główny program. W przeciwnym razie wartość __name__ jest ustawiona na nazwę modułu.

Jest to specjalne, gdy plik Pythona jest wywoływany z linii poleceń. Jest to zwykle używane do wywołania funkcji" main () " lub wykonania innego odpowiedniego kodu startowego, na przykład obsługi argumentów wiersza poleceń.

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

Nie mówię, że powinieneś używać tego w kodzie produkcyjnym, ale służy to do zilustrowania, że nie ma nic "magicznego" w if __name__ == '__main__'. Jest to dobra Konwencja wywoływania głównej funkcji w Pythonie pliki.

if __name__ == "__main__": jest w zasadzie środowiskiem skryptów najwyższego poziomu i określa interpreter, który ('mam najwyższy priorytet do wykonania jako pierwszy').

'__main__' to nazwa zakresu, w którym wykonuje się kod najwyższego poziomu. Moduł __name__ jest ustawiony na '__main__' Podczas odczytu ze standardowego wejścia, skryptu lub interaktywnego monitu.

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

Powód

if __name__ == "__main__":
    main()

Jest przede wszystkim po to, aby uniknąć problemów import lock , które mogłyby wyniknąć z posiadania kodu bezpośrednio importowanego. Chcesz uruchomić main(), Jeśli Twój plik został wywołany bezpośrednio( jest to przypadek __name__ == "__main__"), ale jeśli twój kod został zaimportowany, importer musi wprowadzić kod z prawdziwego modułu głównego, aby uniknąć problemów z blokadą importu.

Efektem ubocznym jest automatyczne logowanie się do metodologii, która obsługuje wiele punktów wejścia. Możesz uruchom program używając main() jako punktu wejścia, , ale nie musisz . Podczas gdy setup.py oczekuje main(), Inne narzędzia używają alternatywnych punktów wejścia. Na przykład, aby uruchomić plik jako proces gunicorn, definiujesz funkcję app() zamiast main(). Tak jak z setup.py, gunicorn importuje kod, więc nie chcesz, aby robił cokolwiek podczas importowania (z powodu problemu z blokadą importu).

Możesz uczynić plik użytecznym jako skrypt , a także importowalny Moduł .

Fibo.py (moduł o nazwie 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]))

Numer referencyjny: https://docs.python.org/3.5/tutorial/modules.html

Rozważmy:

print __name__

Wyjście dla powyższego to __main__.

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

Powyższe stwierdzenie jest prawdziwe i wypisuje "metodę bezpośrednią" . Załóżmy, że jeśli zaimportowali tę klasę do innej klasy, to nie wyświetli "metoda bezpośrednia" , ponieważ podczas importowania ustawia __name__ equal to "firstmodel name".

Czytałem tak wiele w odpowiedziach na tej stronie. Powiedziałbym, że jeśli znasz tę rzecz, na pewno zrozumiesz te odpowiedzi, w przeciwnym razie nadal jesteś zdezorientowany.

Aby być krótkim, musisz znać kilka punktów:

1. import a akcja uruchamia wszystko, co można uruchomić w "a"

2. Ze względu na punkt 1, możesz nie chcieć, aby wszystko było uruchamiane w "a" podczas importowania

3. Aby rozwiązać problem w punkcie 2, python pozwala na aby sprawdzić stan

4. __name__ jest zmienną ukrytą we wszystkich modułach. py; gdy a.py jest importowana, wartość __name__ z a.py moduł jest ustawiony na jego nazwę pliku "a"; gdy a.py jest uruchamiany bezpośrednio przy użyciu "python a.py" , co oznacza a.py jest punktem wejścia, wtedy wartość __name__ z a.py moduł jest ustawiony na ciąg znaków __main__

5. Opierając się na mechanizmie, w jaki sposób python ustawia zmienną __name__ dla każdego modułu, Czy wiesz, jak osiągnąć punkt 3? Odpowiedź jest dość prosta, prawda? Put a if condition: if __name__ == "__main__": ...; można nawet put if __name__ == "a" w zależności od potrzeb funkcjonalnych

Ważne, że python jest wyjątkowy w punkcie 4! Reszta to tylko podstawowa logika.

Utwórz plik, a.py : {]}

print(__name__) # It will print out __main__

__name__ jest zawsze równe __main__, gdy ten plik jest uruchamiany bezpośrednio pokazując, że jest to plik główny.

Utwórz inny plik, b.py , w tym samym katalogu:

import a  # Prints a

Tak więc, aby pokazać dwa różne zachowania tego samego pliku , jest to powszechnie używana sztuczka:

# Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly

Wszystkie odpowiedzi wyjaśniają funkcjonalność. Ale podam jeden przykład jego użycia, który może pomóc wyjaśnić koncepcję dalej.

Załóżmy, że masz dwa pliki Pythona, a.py oraz b.py teraz, a.py przywóz b.py. prowadzimy a.py plik, gdzie "import b.py" kod jest wykonywany jako pierwszy. Przed resztą a.py kod działa, kod w pliku b.py musi działać całkowicie.

W b.py kod jest jakiś kod, który jest wyłączny dla tego pliku b.py i my nie chcę żadnego innego pliku (innego niż b.py plik), który zaimportował b.py / align = "left" /

Więc to właśnie sprawdza ta linia kodu. Jeśli jest to plik główny (tzn. b.py) uruchamianie kodu, który w tym przypadku nie jest (a.py jest uruchomiony główny plik), wtedy zostanie wykonany tylko kod.

Jeśli ten plik .PY zostanie zaimportowany przez inne pliki .py, kod znajdujący się w instrukcji if nie zostanie wykonany.

Jeśli this. py są uruchamiane przez python this_py.py pod powłoką, lub dwukrotnie klikane w Windows. kod pod "instrukcją if" zostanie wykonany.

Jest zwykle zapisywany do testów.

If Nazwa == 'główna':

Dość często sprawdzamy, czy __name__ == '__main__':.

Sprawdza, czy moduł jest importowany, czy nie.

Innymi słowy, kod w bloku if będzie wykonywany tylko wtedy, gdy kod będzie uruchamiany bezpośrednio. Tutaj directly oznacza not imported.

Zobaczmy, co robi używając prostego kodu, który wyświetla nazwę modułu:

# test.py
def test():
   print('test module name=%s' %(__name__))

if __name__ == '__main__':
   print('call test()')
   test()

Jeśli uruchomimy kod bezpośrednio przez python test.py, Nazwa modułu to __main__:

call test()
test module name=__main__

Ta odpowiedź jest dla programistów Java uczących się Pythona. Każdy plik Java zazwyczaj zawiera jedną klasę publiczną. Możesz używać tej klasy na dwa sposoby:

(1) wywołuje klasę z innych plików. Wystarczy zaimportować go do programu wywołującego.

(2) Uruchom klasę samodzielnie, do celów testowych.

W tym drugim przypadku klasa powinna zawierać publiczną statyczną metodę Void main (). W Pythonie ten cel jest obsługiwany przez globalnie zdefiniowaną Etykietę '__main__'.

Ostatnio natknąłem się na to podczas tworzenia klasy w Pythonie (deep learning) i według mojego zrozumienia i w zgodzie z wyżej wymienionymi wyjaśnieniami, rozwiążę

Nazwa=="main "

Ponieważ czasami konstruujemy klasę w pliku. py i definiujemy wiele funkcji wewnątrz tej klasy. ale nie chcemy przetwarzać wszystkich tych funkcji klas dla jednego celu. na przykład, aby utworzyć klasę i zdefiniować niektóre funkcje dla danych kreacji (.pliki npy), a niektóre do ładowania danych. więc jeśli zdefiniujemy

Nazwa=="main "

Xxx=class_name ()

Xxx. create_data ()

Oznacza, że jeżeli wywołamy plik. py, to wytworzy on tylko Dane i nie przetworzy innych funkcji klasy. inne funkcje klasy (ładowanie danych) mogą być również importowane przez inne klasy.

_ Nazwa _ == _ main _ upewni się, że kod / instrukcje obecne w tym bloku będą działać tylko wtedy, gdy wykonamy ten plik bezpośrednio, zamiast tego, jeśli zaimportujemy go jako moduł w innym pliku Pythona, możemy wywołać funkcję zdefiniowaną w nim, a także blok, który jest obecny w _ Nazwa == main _ nie zostanie wykonany.

Co robi NAZWA if == " main ": do?

Zarys:

1, jako skrypt wykonywalny, pracuj dla siebie jako Samozatrudniony: Wykonuje kody w module, jeśli jest uruchamiany bezpośrednio jako "python foo.py"
2, jako importowany moduł do pracy dla innych:
Jego kody mogą być bezpiecznie ponownie użyte, jeśli zostaną zaimportowane do innego modułu jako "import foo"