Короткий ответ

Это шаблонный код, который защищает пользователей от случайного вызова сценария, когда они этого не собирались. Вот некоторые типичные проблемы, возникающие при отсутствии защиты в скрипте:

• Если вы импортируете скрипт без защиты в другой скрипт (например, import my_script_without_a_name_eq_main_guard), то второй скрипт инициирует запуск первого во время импорта и с использованием аргументов командной строки второго скрипта. Это почти всегда ошибка.

• Если у вас есть собственный класс в сценарии без защиты и вы сохранили его в файле pickle, то его извлечение в другом сценарии вызовет импорт сценария без защиты с теми же проблемами, что описаны в предыдущем пункте.

Длинный ответ

Чтобы лучше понять, почему и как это важно, нам нужно сделать шаг назад, чтобы понять, как Python инициализирует скрипты и как это взаимодействует с механизмом импорта модуля.

Всякий раз, когда интерпретатор Python читает исходный файл, он делает две вещи:

• он устанавливает несколько специальных переменных, например __name__, а затем

• он выполняет весь код, найденный в файле.

Давайте посмотрим, как это работает и как это связано с вашим вопросом о __name__ проверках, которые мы всегда видим в скриптах Python.

Образец кода

Давайте воспользуемся немного другим примером кода, чтобы изучить, как работают импорт и скрипты. Предположим, следующее находится в файле с именем 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__.

Когда ваш модуль является основной программой

Если вы запускаете свой модуль (исходный файл) в качестве основной программы, например

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 файл (наряду с поиском нескольких других вариантов) и перед выполнением этого модуля присвоит переменной __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__ будет "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

Почему это так работает?

Вы, естественно, можете задаться вопросом, зачем кому-то это нужно. Ну, иногда вы хотите написать .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")
      

• Теперь выясните, что произойдет, если вы уберете __name__ проверку в foo3.py:

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

Когда ваш скрипт запускается путем передачи его как команды интерпретатору Python,

python myscript.py

весь код, который находится на уровне отступа 0, будет выполнен. Определенные функции и классы, в общем, определены, но ни один их код не запускается. В отличие от других языков, здесь нет функции main(), которая запускается автоматически - функция main() неявно представляет собой весь код на верхнем уровне.

В этом случае код верхнего уровня - это if блок. __name__ - встроенная переменная, которая оценивает имя текущего модуля. Однако, если модуль запускается напрямую (как в myscript.py выше), тогда __name__ вместо этого устанавливается в строку "__main__". Таким образом, вы можете проверить, запускается ли ваш скрипт напрямую или импортируется чем-то другим путем тестирования

if __name__ == "__main__":
    ...

Если ваш скрипт импортируется в другой модуль, будут импортированы его различные определения функций и классов, и будет выполнен его код верхнего уровня, но код в then-теле предложения 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__".

Самое простое объяснение переменной __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 и выполняется.

Что делает 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 находится в данный момент.

Внутри импортированного модуля это имя этого модуля.

Но внутри основного модуля (или интерактивного сеанса 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()

Эту идиому также можно найти в документации Python в объяснении модуля __main__. Этот текст гласит:

if __name__ == "__main__" - это часть, которая запускается, когда сценарий запускается (скажем) из командной строки с помощью такой команды, как python myscript.py.

Что делает if __name__ == "__main__":?

__name__ - глобальная переменная (в Python глобальная переменная фактически означает на уровне модуля), которая существует во всех пространствах имен . Обычно это имя модуля (как типа str).

Однако в качестве единственного особого случая в любом запущенном вами процессе Python, например mycode.py:

python mycode.py

в противном случае анонимному глобальному пространству имен присваивается значение '__main__' его __name__.

Таким образом, включая последние строки

if __name__ == '__main__':
    main()

• в конце вашего скрипта mycode.py,
• когда это основной модуль точки входа, запускаемый процессом Python,

вызовет выполнение уникально определенной функции main вашего скрипта.

Еще одно преимущество использования этой конструкции: вы также можете импортировать свой код как модуль в другой скрипт, а затем запустить основную функцию, если и когда ваша программа решит:

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 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(); хорошо, напечатайте «периферийная задача: может быть полезно в других проектах».
• Что это? Заявление if. Что ж, условие выполнено (для переменной __name__ установлено значение "__main__"), поэтому я ввожу функцию main() и печатаю «основная функция: здесь действие».

Две нижние строки означают: «Если это "__main__" или« домашний »сценарий, выполните функцию с именем main()». Вот почему вы увидите вверху блок def main():, который содержит основной поток функций скрипта.

Зачем это реализовывать?

Помните, что я говорил ранее о операторах импорта? Когда вы импортируете модуль, он не просто «распознает» его и ждет дальнейших инструкций - он фактически выполняет все исполняемые операции, содержащиеся в скрипте. Таким образом, помещение вашего скрипта в функцию main() эффективно помещает его в карантин, помещая его в изоляцию, чтобы он не запускался сразу после импорта другим скриптом.

Опять же, будут исключения, но обычная практика такова, что main() обычно не вызывается извне. Итак, у вас может возникнуть вопрос: если мы не вызываем main(), почему мы вообще вызываем сценарий? Это потому, что многие люди структурируют свои сценарии с помощью автономных функций, которые созданы для запуска независимо от остальной части кода в файле. Позже они вызываются в другом месте сценария. Что подводит меня к следующему:

Но код работает и без него

Да все верно. Эти отдельные функции можно вызвать из встроенного скрипта, который не содержится внутри main() функции. Если вы привыкли (как и я, на начальных этапах моего обучения программированию) создавать встроенные скрипты, которые делают именно то, что вам нужно, и вы попытаетесь понять это снова, если вам когда-нибудь понадобится эта операция снова ... Что ж, вы не привыкли к такой внутренней структуре вашего кода, потому что ее сложнее построить и ее не так интуитивно понятно читать.

Но этот сценарий, вероятно, не может иметь свои функции, вызываемые извне, потому что, если бы он это сделал, он немедленно начал бы вычислять и назначать переменные. И есть вероятность, что если вы пытаетесь повторно использовать функцию, ваш новый скрипт достаточно тесно связан со старым, что приведет к конфликту переменных.

При разделении независимых функций вы получаете возможность повторно использовать свою предыдущую работу, вызывая их в другой скрипт. Например, «example.py» может импортировать «xy.py» и вызывать x(), используя функцию «x» из «xy.py». (Возможно, это использование заглавной буквы третьего слова данной текстовой строки; создание массива NumPy из списка чисел и их возведение в квадрат; или устранение тренда трехмерной поверхности. Возможности безграничны.)

(Кстати, этот вопрос содержит ответ @kindall, который, наконец, помог мне поймите - почему, а не как. К сожалению, он был отмечен как дубликат этого, что я считаю ошибкой.)

Когда в нашем модуле (M.py) есть определенные операторы, которые мы хотим выполнить, когда он будет работать как основной (не импортированный), мы можем поместить эти операторы (тестовые примеры, операторы печати) в этот блок if.

По умолчанию (когда модуль работает как основной, а не импортированный) для переменной __name__ установлено значение "__main__", а когда она будет импортирована, переменная __name__ получит другое значение, скорее всего, имя модуля ('M'). Это полезно при одновременном запуске различных вариантов модулей и разделении их конкретных операторов ввода и вывода, а также при наличии каких-либо тестовых примеров.

Короче, используйте этот блок 'if __name__ == "main"', чтобы предотвратить запуск (определенного) кода при импорте модуля.

Проще говоря, __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 ++ вам придется разделить эти части в отдельный модуль, который затем включает файл. Представьте себе ситуацию ниже;

Стрелки - это ссылки для импорта. Для трех модулей, каждый из которых пытается включить код предыдущих модулей, есть шесть файлов (девять, считая файлы реализации) и пять ссылок. Это затрудняет включение другого кода в проект C, если он не скомпилирован специально как библиотека. Теперь представьте это для Python:

Вы пишете модуль, и если кто-то хочет использовать ваш код, они просто импортируют его, и переменная __name__ может помочь отделить исполняемую часть программы от библиотечной части.

Давайте посмотрим на ответ более абстрактно:

Предположим, у нас есть этот код в x.py:

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

Блоки A и B запускаются, когда мы запускаем x.py.

Но просто блок A (а не B) запускается, когда мы запускаем другой модуль, например y.py, в который импортируется x.py, а код запускается оттуда (например, когда функция в 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.py устанавливается равным имени его файла a
• когда a.py запускается напрямую с использованием python a.py, значение __name__ устанавливается в строку __main__

5. Знаете ли вы, как достичь точки 3, основываясь на механизме того, как python устанавливает переменную __name__ для каждого модуля? Ответ довольно прост, правда? Поместите условие if: if __name__ == "__main__": // do A

• тогда python a.py запустит часть // do A
• и import a пропустит часть // do A

6. Вы даже можете поставить if __name__ == "a" в зависимости от ваших функциональных потребностей, но редко

Важным моментом в том, что Python является особенным, является пункт 4! Остальное - всего лишь базовая логика.

Когда вы запускаете Python в интерактивном режиме, локальной переменной __name__ присваивается значение __main__. Аналогичным образом, когда вы выполняете модуль Python из командной строки, а не импортируете его в другой модуль, его атрибуту __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.

Рассмотреть возможность:

if __name__ == "__main__":
    main()

Он проверяет, равен ли атрибут __name__ скрипта Python "__main__". Другими словами, если выполняется сама программа, атрибут будет __main__, поэтому программа будет выполнена (в данном случае функция main()).

Однако, если ваш скрипт Python используется модулем, будет выполняться любой код за пределами оператора if, поэтому if \__name__ == "\__main__" используется только для проверки того, используется ли программа в качестве модуля или нет, и, следовательно, решает, запускать ли код.

Прежде чем что-либо объяснять о if __name__ == '__main__', важно понять, что такое __name__ и для чего он нужен.

Что такое __name__?

__name__ - это 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__ принимает имя файла. Путь к фактическому модулю или пакету не указан, но есть собственный DunderAlias ​​__file__, который позволяет это.

Вы должны увидеть, что где __name__, где это главный файл (или программа), всегда возвращает __main__, а если это модуль / пакет или что-либо, что выполняется каким-либо другим скриптом Python, вернет имя файла, из которого он был создан.

Практика:

Переменная означает, что ее значение может быть перезаписано («можно» не означает «следует»), перезапись значения __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 - это оператор управления потоком, содержащий блок кода. будет выполняться, если заданное значение истинно. Мы видели, что __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

Вы также можете использовать его для предоставления работоспособных справочных функций / утилит по пакетам и модулям без сложного использования библиотек.

Это также позволяет запускать модули из командной строки в качестве основных сценариев, что также может быть очень полезно.

Код под 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')

1-й вариант: импортировать 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.

2-й вариант: вызвать 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'

Для более полного объяснения вы можете прочитать Что делает if __name__ == '__main__' в Python .

Думаю, лучше всего разбить ответ подробно и простыми словами:

__name__: Каждый модуль в Python имеет специальный атрибут __name__. Это встроенная переменная, которая возвращает имя модуля.

__main__: Как и в других языках программирования, Python также имеет точку входа для выполнения, то есть main. '__main__' - это имя области, в которой выполняется код верхнего уровня. В основном у вас есть два способа использования модуля Python: запустить его напрямую как скрипт или импортировать. Когда модуль запускается как сценарий, его __name__ устанавливается в __main__.

Таким образом, значение атрибута __name__ устанавливается в __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 __" .

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