Что делает 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))
Всякий раз, когда интерпретатор 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 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, foo.py .py и присвоит эту строку переменной вашего модуля __name__, т.е.
# It as if the interpreter inserts this at the top
# of your module when it imported from another module.
__name__ = "foo"
После того, как специальные переменные установлены, интерпретатор выполняет весь код в модуле, по одному выражению за раз. Вы можете открыть другое окно сбоку с примером кода, чтобы вы могли следовать этому объяснению.
Всегда
Он печатает строку "before import" (без кавычек).
Он загружает 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")
Он печатает строку "before functionA".
Он выполняет блок def, создавая функциональный объект, затем назначая этот функциональный объект переменной, называемой functionA.
Он печатает строку "before functionB".
Он выполняет второй блок def, создавая другой функциональный объект, а затем присваивая его переменной с именем functionB.
Он печатает строку "before __name__ guard".
Только когда ваш модуль является основной программой
__name__ действительно был установлен на "__main__" и он вызывает две функции, печатая строки "Function A" и "Function B 10.0".Только когда ваш модуль импортируется другим
__name__ будет "foo", а не "__main__", и пропустит тело оператора if.Всегда
"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.
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__ в foo3.py:# Suppose this is foo3.py.
def functionA():
print("a1")
from foo3 import functionB
print("a2")
functionB()
print("a3")
def functionB():
print("b")
print("t1")
print("m1")
functionA()
print("m2")
print("t2")
# Suppose this is in foo4.py
__name__ = "__main__"
def bar():
print("bar")
print("before __name__ guard")
if __name__ == "__main__":
bar()
print("after __name__ guard")
Когда ваш script запускается, передавая его как команду интерпретатору Python,
python myscript.py
выполняется весь код, который находится на уровне отступа 0. Определенные функции и классы определены, но не определены, но ни один из их кодов не запускается. В отличие от других языков нет функции main(), которая запускается автоматически - функция main() неявно содержит весь код на верхнем уровне.
В этом случае код верхнего уровня представляет собой блок if. __name__ - встроенная переменная, которая оценивает имя текущего модуля. Однако, если модуль запускается напрямую (как в myscript.py выше), то вместо __name__ устанавливается строка "__main__". Таким образом, вы можете проверить, выполняется ли ваш script напрямую или импортируется чем-то другим, тестируя
if __name__ == "__main__":
...
Если ваш script импортируется в другой модуль, его различные определения функций и классов будут импортированы, а его код верхнего уровня будет выполнен, но код в том же тесте выше if выше выиграл 'get get, поскольку условие не выполняется. В качестве базового примера рассмотрим следующие два сценария:
# 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 script, предназначенный для использования в качестве модуля:
def do_important():
"""This function does something very important"""
Вы можете протестировать модуль, добавив этот вызов функции в нижнюю часть:
do_important()
и запустив его (в командной строке) с чем-то вроде:
~$ python important.py
Однако, если вы хотите импортировать модуль в другой script:
import important
При импорте будет вызываться функция do_important, поэтому вы, вероятно, прокомментируете свой вызов функции do_important() внизу.
# do_important() # I must remember to uncomment to execute this!
И тогда вам нужно будет вспомнить, не закомментировал ли вы вызов тестовой функции. И эта дополнительная сложность будет означать, что вы, вероятно, забудете, что сделает ваш процесс разработки более трудным.
Переменная __name__ указывает на пространство имен везде, где в настоящий момент интерпретатор Python находится.
Внутри импортированного модуля это имя этого модуля.
Но внутри первичного модуля (или интерактивного сеанса Python, т.е. интерпретатора Read, Eval, Loop печати или REPL) вы запускаете все, начиная с "__main__".
Итак, если вы проверите перед выполнением:
if __name__ == "__main__":
do_important()
При вышесказанном ваш код будет выполняться только в том случае, если вы используете его в качестве основного модуля (или намеренно вызываете его из другого script).
Там есть питоновский способ улучшить это.
Что делать, если мы хотим запустить этот бизнес-процесс извне модуля?
Если мы поместим код, который хотим реализовать, когда мы разрабатываем и тестируем в такой функции, а затем делаем нашу проверку для '__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 our payoff idiom!
if __name__ == '__main__':
main()
Теперь у нас есть окончательная функция для конца нашего модуля, которая будет работать, если мы запустим модуль как первичный модуль.
Это позволит модулю и его функциям и классам импортироваться в другие сценарии без запуска функции main, а также позволяет вызывать модуль (и его функции и классы) при работе из другого '__main__', т.е.
import important
important.main()
Эта идиома также может быть найдена в документации Python в объяснении модуля __main__. В этом тексте указано:
Этот модуль представляет (в противном случае анонимную) область, в которой основная программа интерпретаторов - команды, читаемые либо из стандартный ввод, из файла script или из интерактивной подсказки. Это это среда, в которой идиоматическая "условная script" строфа вызывает запуск script:
if __name__ == '__main__': main()
if __name__ == "__main__" - это часть, которая выполняется, когда script запускается из (скажем) командной строки с помощью команды типа python myscript.py.
Что делает
if __name__ == "__main__":?
__name__ - глобальная переменная (в Python глобальная на самом деле означает на уровне уровень модуля), который существует во всех пространствах имен. Обычно это имя модуля (как тип str).
Как единственный частный случай, однако, в любом запущенном процессе Python, как в mycode.py:
python mycode.py
иначе анонимному глобальному пространству имен присваивается значение '__main__' его __name__.
Таким образом, включая окончательные строки
if __name__ == '__main__':
main()
приведет к выполнению уникальной функции main script.
Еще одно преимущество использования этой конструкции: вы также можете импортировать свой код в качестве модуля в другой script, а затем запустить основную функцию, если и когда ваша программа решит:
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. Оператор import запускает модуль сразу при импорте, поэтому операции ab выполняются до остальной части xy. Закончив с ab, он продолжит с xy.
Интерпретатор отслеживает, какие сценарии работают с __name__. Когда вы запускаете скрипт - независимо от того, что вы его назвали, интерпретатор называет его "__main__", что делает его мастером или "домашним" скриптом, который возвращается после запуска внешнего скрипта.
Любой другой скрипт, вызываемый из этого сценария "__main__" присваивает его имя файла как его __name__ (например, __name__ == "ab.py"). Следовательно, строка, if __name__ == "__main__": это тест-интерпретатор, чтобы определить, интерпретирует ли он/обрабатывает сценарий "home", который был первоначально выполнен, или если он временно заглядывает в другой (внешний) скрипт. Это дает гибкость программисту, чтобы сценарий вел себя по-другому, если он выполнялся напрямую или вызывался извне.
Позвольте пройти через вышеприведенный код, чтобы понять, что происходит, сосредоточившись сначала на незаметных строках и порядке, которые они отображают в сценариях. Помните, что функции - или def - блоки не делают ничего сами по себе, пока не будут вызваны. Что может сказать интерпретатор, если пробормотал себе:
"__main__" в переменной __name__.__name__ == "ab.py".a(); Я только что узнал об этом. Печать "Функция в ab файле"."__main__" !x(); ok, печать "периферийная задача: может быть полезна в других проектах".if. Ну, условие выполнено (переменная __name__ установлена на "__main__"), поэтому я буду вводить функцию main() и печатать "главную функцию: это то, где действие". Нижние две строки означают: "Если это сценарий "__main__" или" home ", выполните функцию main() ". Вот почему вы увидите def main(): block up top, который содержит основной поток функций скрипта.
Зачем это реализовать?
Помните, что я сказал ранее о заявках на импорт? При импорте модуля он не просто "распознает" его и ждет дальнейших инструкций - он фактически выполняет все исполняемые операции, содержащиеся в скрипте. Таким образом, добавление мяса вашего скрипта в функцию main() эффективно помещает его в карантин, изолируя его, чтобы он не сразу запускался при импорте с помощью другого скрипта.
Опять же, будут исключения, но обычной практикой является то, что main() обычно не называется вызываемым извне. Поэтому вам может быть интересно еще одно: если мы не вызываем main(), почему мы вообще вызываем сценарий? Это потому, что многие люди строят свои скрипты с автономными функциями, которые создаются для запуска независимо от остальной части кода в файле. Затем их позже называют в другом месте в тексте сценария. Это подводит меня к этому:
Но код работает без него
Да, это правильно. Эти отдельные функции можно вызывать из встроенного скрипта, который не содержится внутри функции main(). Если вы привыкли (как и я, на ранних этапах программирования) к созданию встроенных сценариев, которые делают именно то, что вам нужно, и вы попытаетесь выяснить это снова, если вам понадобится эта операция снова. ну, вы не привыкли к такой внутренней структуре вашего кода, потому что это сложнее построить, и это не так просто интуитивно понятно.
Но это сценарий, который, вероятно, не может иметь свои функции, вызванные извне, потому что если бы он это сделал, он немедленно начал бы вычислять и присваивать переменные. И, скорее всего, если вы пытаетесь повторно использовать функцию, ваш новый сценарий тесно связан с старым, что будут конфликтующие переменные.
Разделяя независимые функции, вы получаете возможность повторно использовать свою предыдущую работу, вызвав их в другой скрипт. Например, "example.py" может импортировать "xy.py" и вызвать x(), используя функцию "x" из "xy.py". (Возможно, он заглаживает третье слово данной текстовой строки, создает массив NumPy из списка чисел и возводит в квадрат их или дешифрует трехмерную поверхность. Возможности безграничны).
(В стороне этот вопрос содержит ответ от @kindall, который, наконец, помог мне понять - почему, а не как. К сожалению, это было отмечено как дубликат этого, что я считаю ошибкой.)
Когда в нашем модуле (M.py) есть определенные утверждения, M.py мы хотим выполнить, когда он будет запущен как основной (не импортированный), мы можем разместить эти операторы (тестовые примеры, операторы печати) в этом блоке if.
По умолчанию (когда модуль работает как основной, а не импортирован) переменная __name__ установлена на "__main__", и когда она будет импортирована, переменная __name__ получит другое значение, скорее всего, имя модуля ('M'). Это полезно при совместном использовании разных вариантов модулей и разделении их конкретных инструкций ввода и вывода, а также при наличии тестовых примеров.
Короче говоря, используйте этот " if __name__ == "main" блок для предотвращения (определенного) кода при запуске, когда модуль импортируется.
Проще говоря, __name__ - это переменная, определенная для каждого скрипта, которая определяет, выполняется ли сценарий в качестве основного модуля или запускается как импортированный модуль.
Итак, если у нас есть два сценария;
#script1.py
print "Script 1 name: {}".format(__name__)
а также
#script2.py
import script1
print "Script 2 name: {}".format(__name__)
Результатом выполнения скрипта 1 является
Script 1 name: __main__
И результат выполнения скрипта2:
Script1 name is script1
Script 2 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", в котором xy импортируется и код запускается оттуда (например, когда функция в "x". py "вызывается из y.py).
При запуске 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, вернет имя файла откуда оно возникло.
Практика:
Как переменная означает, что ее значение может быть перезаписано ("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 это оператор управления потоком, содержащий блок кода, будет выполняться, если заданное значение истинно. Мы видели, что __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
Вы также можете использовать его для предоставления исполняемых справочных функций/утилит на пакетах и модулях без детального использования библиотек.
Он также позволяет запускать модули из командной строки в качестве основных сценариев, что также может быть очень полезно.
Я думаю, что лучше всего разбить ответ вслух и простыми словами:
__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__" .
Если это импортируется из другого модуля, __ 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()
Причина для
if __name__ == "__main__":
main()
прежде всего, чтобы избежать проблем с блокировкой импорта, которые возникли бы из- за прямого импорта кода. Вы хотите, чтобы main() запускался, если ваш файл был вызван напрямую (это случай __name__ == "__main__"), но если ваш код был импортирован, импортер должен ввести ваш код из основного модуля, чтобы избежать проблем с блокировкой импорта.
Побочным эффектом является то, что вы автоматически включаетесь в методологию, которая поддерживает несколько точек входа. Вы можете запустить свою программу, используя main() в качестве точки входа, но вам этого не нужно. Хотя setup.py ожидает main(), другие инструменты используют альтернативные точки входа. Например, чтобы запустить файл как процесс gunicorn, вы определяете функцию app() вместо main(). Как и в случае с setup.py, gunicorn импортирует ваш код, поэтому вы не хотите, чтобы он делал что-либо во время его импорта (из-за проблемы с блокировкой импорта).
Я читал так много ответов на этой странице. Я бы сказал, если вы знаете это, вы наверняка поймете эти ответы, иначе вы все еще смущены.
Короче говоря, вам нужно знать несколько моментов:
import a действия фактически запускает все, что можно запустить в "a"
Из-за пункта 1 вам может не потребоваться, чтобы все было запущено в "a" при импорте
Чтобы решить проблему в пункте 2, python позволяет вам поставить проверку состояния
__name__ - неявная переменная во всех.py-модулях; когда a.py импортируется, значение __name__ модуля a.py устанавливается в его имя файла "a"; когда a.py запускается напрямую с помощью "python a.py", что означает, что a.py является точкой входа, тогда значение __name__ модуля a.py устанавливается в строку __main__
На основе механизма, как питон устанавливает переменную __name__ для каждого модуля, знаете ли вы, как достичь точки 3? Ответ довольно прост, не так ли? Положите условие if: if __name__ == "__main__":...; вы можете даже поставить if __name__ == "a" зависимости от вашей функциональной потребности
Важной вещью, что питон особенным в точке 4! Остальное - просто базовая логика.
Рассматривать:
print __name__
Выход для вышеупомянутого - __main__.
if __name__ == "__main__":
print "direct method"
Вышеприведенное утверждение верно и печатает "прямой метод". Предположим, что если они импортировали этот класс в другой класс, он не печатает "прямой метод", потому что при импорте он установит __name__ equal to "first model name".
Вы можете сделать файл полезным как script, а также импортируемый модуль.
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]))
Этот ответ предназначен для Java-программистов, изучающих Python. Каждый файл Java обычно содержит один открытый класс. Вы можете использовать этот класс двумя способами:
Вызовите класс из других файлов. Вам просто нужно импортировать его в вызывающую программу.
Запустите класс отдельно для тестирования.
В последнем случае класс должен содержать общедоступный метод static void main(). В Python этой цели служит глобально определенная метка '__main__'.
Если этот.py файл импортируется другими.py файлами, код под "оператором if" не будет выполнен.
Если этот.py запущен python this_py.py под оболочкой или дважды щелкнут в Windows. будет выполнен код под "оператором if".
Обычно он предназначен для тестирования.
Создайте файл, 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
Мы видим, что __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__
Все ответы в значительной степени объясняют функциональность. Но я приведу один пример его использования, который может помочь в дальнейшем очистить концепцию.
Предположим, что у вас есть два файла Python, a.py и b.py. Теперь, a.py импортирует b.py. Мы запускаем файл a.py, где сначала выполняется код "import b.py". Перед тем как остальная часть кода a.py запускается, код в файле b.py должен выполняться полностью.
В коде b.py есть некоторый код, который является исключительным для этого файла b.py, и мы не хотим, чтобы какой-либо другой файл (кроме файла b.py), который импортировал файл b.py, запускал его.
Так вот эта строка проверки кода. Если это основной файл (т.е. B.py), запускающий код, который в этом случае не является (a.py является основным файлом), тогда выполняется только код.
Каждый модуль в Python имеет атрибут, который называется как имя. Значение атрибута name равно ' main ', когда модуль запускается напрямую. В противном случае значение 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 не будет выполнено.
Просто это точка входа для запуска файла как main функция в языке программирования C.
Если интерпретатор Python работает с определенным модулем, то глобальная переменная __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()
Когда вы запускаете этот скрипт печатает вы можете видеть меня
Если вы импортируете этот файл, скажем, A, в файл B и запустите файл B, тогда if __name__ == "__main__" в файле A станет ложным, поэтому он напечатает Вы меня не видите
б
Недавно я столкнулся с этим, создав класс в python (глубокое обучение) и, насколько мне известно, и в соответствии с вышеприведенными пояснениями выше, я разработаю
__name__=="__main__"
Поскольку иногда мы строим класс в.py файле и определяем много функций внутри этого класса. но мы не хотим обрабатывать все эти функции класса для одной цели. например, для создания класса и определения некоторых функций для создания данных (файлы.npy), а некоторые для загрузки данных. поэтому, если мы определим
__name__=="__main__"ххх = имя_класса()
xxx.create_data()
Значит, если мы будем называть.py файл, тогда он будет создавать только данные и не будет обрабатывать другие функции класса. другие функции класса (загрузка данных) также могут быть импортированы другими классами.