Что делает 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'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
, вычеркнет .py
и присвоит эту строку переменной __name__
вашего модуля, т.е.
# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__name__ = "foo"
После того как специальные переменные установлены, интерпретатор выполняет весь код модуля, по одному утверждению за раз. Возможно, вы захотите открыть другое окно на стороне с примером кода, чтобы вы могли следить за этим объяснением. Всегда.
"перед импортом"
(без кавычек).math
и присваивает его переменной math
. Это эквивалентно замене import math
на следующее (обратите внимание, что __import__
- это низкоуровневая функция в Python, которая принимает строку и запускает фактический импорт):# Найти и загрузить модуль по его строковому имени "math",
# затем присваиваем его локальной переменной math.
math = __import__("math")
"перед функциейА"
.def
, создается объект функции, затем этот объект функции присваивается переменной functionA
."перед функциейВ"
.def
, создающий другой объект функции, затем присваивающий его переменной functionB
."before __name__ guard"
.
Только когда ваш модуль является основной программой.__name__
действительно установлен в "__main__"
и вызовет две функции, печатая строки "Функция A"
и "Функция B 10.0"
.
Онли, когда ваш модуль импортируется другим__name__
будет "foo"
, а не "__main__"
, и он'пропустит тело оператора if
.
Всегда."после __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', подобные вашему скрипту, и запуская специальные тестовые функции. Вы не хотите, чтобы он пытался запустить скрипт только потому, что он импортирует модуль.
Вопрос: Можно ли иметь несколько блоков проверки __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")
__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")
Когда ваш сценарий выполняется, передавая его в качестве команды интерпретатору Python,
python myscript.py
выполняется весь код, который находится на уровне отступа 0. Функции и классы, которые определены, являются определенными, но ни один их код не выполняется. В отличие от других языков, здесь нет функции main()
, которая запускается автоматически - функция main()
неявно является всем кодом на верхнем уровне.
В данном случае код верхнего уровня - это блок if
. __name__
- это встроенная переменная, которая оценивается как имя текущего модуля. Однако, если модуль запускается напрямую (как в myscript.py
выше), то вместо __name__
устанавливается строка "__main__"
. Таким образом, вы можете проверить, запускается ли ваш скрипт напрямую или импортируется чем-то другим, проверив следующее
if __name__ == "__main__":
...
Если ваш скрипт импортируется в другой модуль, его различные определения функций и классов будут импортированы и его код верхнего уровня будет выполнен, но код в теле 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__
(имхо) заключается в следующем:
Создайте следующие файлы.
# 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
будет работать только если модуль является точкой входа в вашу программу.
Это позволяет коду в модуле должны быть импортированы другими модулями, без выполнения блока кода под на импорт.
Зачем нам это надо?
Говорят, что вы'повторного написания скрипта Python предназначен для использования в качестве модуля:
def do_important():
"""This function does something very important"""
Вы можете проверки модуля путем добавления этого вызов функции до дна:
do_important()
и работает он (в командной строке) что-то вроде:
~$ python important.py
Проблема ## В
Однако, если вы хотите импортировать модуль в другой скрипт:
import important
На импорт, функция do_important
будет называться, так что вы'd и, наверное, закомментировать код вызова функции do_important()
, в самом низу.
# do_important() # I must remember to uncomment to execute this!
И тогда вы'll должны помнить, является ли или не вы'вэ закомментирована функция тестового звонка. А это лишние сложности будет означать, что вы'повторно, вероятно, забыли, что делает процесс разработки более хлопотно.
От __название__
переменной точки пространства, где интерпретатор Python, случается в данный момент.
Внутри импортированного модуля, он'ы название этого модуля.
Но внутри основного модуля (или интерактивной сессии питона, т. е. переводчик's для чтения, Ивал, цикл печати, или REPL) работают все, начиная от его " по - __основное__ - то"
.
Так что если вы проверьте перед выполнением:
if __name__ == "__main__":
do_important()
С выше, ваш код будет выполняться только тогда, когда вы'вновь запустив его в качестве основного модуля (или намеренно вызвать его из другого скрипта).
Там'ы типичный для Python способ улучшить на этом, хотя.
Что, если мы хотим запустить этот бизнес-процесс из-за модуля?
Если мы поместим код, мы хотим работать так, как мы разработать и протестировать функции такой, а потом делать проверку на `'главный' сразу после:
def main():
"""business logic for when running this module as the primary one!"""
setup()
foo = do_important()
bar = do_even_more_important(foo)
for baz in bar:
do_super_important(baz)
teardown()
# Here's our payoff idiom!
if __name__ == '__main__':
main()
Теперь у нас есть окончательное функции к концу наш модуль, который будет работать, если мы запускаем модуль в качестве основного модуля.
Это позволит модулю и его функции и классы, которые должны быть импортированы в другие скрипты без главной
функции, а также позволят модуля (и его функций и классов), которые будут вызываться при выполнении из разных '__главный__'
модуль, т. е.
import important
important.main()
Эта идиома также можно найти в документации по Python в объяснение модуля _главный___
. этот текст гласит:
этот модуль представляет собой (в противном случае анонимный) области, в которой основная программа выполняет переводчика — команды чтения из стандартный ввод из файла сценария или из интерактивных запросов. Это это среда, в которой идиоматических “условный сценарий” стансы вызывает скрипт для запуска:
если имя == 'основной': основной()
if __name__ == "__main__"
- это часть, которая выполняется, когда скрипт запускается (скажем) из командной строки с помощью команды типа python myscript.py
.
что значит
если __имя__ == " от__главный__" и:
делать?
__имя__ - это глобальная переменная (в Python, глобальный на самом деле означает, на [модуля][1]), что существует во всех пространствах имен. Как правило, модуль's имя (в
ул` тип).
Как только особый случай, в том, что питон процесс запуска, как в mycode.py:
python mycode.py
в противном случае анонимные глобальное пространство имен присваивается значение '__главный__'
его __имя__
.
Таким образом, в том числе последние строки
if __name__ == '__main__':
main()
вызовет ваш скрипт's уникально определены функции main
, чтобы запустить.
Еще одно преимущество использования этой конструкции: вы также можете импортировать ваш код как модуль в другой скрипт, а потом запустить основную функцию если и когда ваша программа решает:
import mycode
# ... any amount of other code
mycode.main()
Есть много разных дублей, на механике кода в вопрос, "как", но для меня никакого смысла, пока я не понял "Почему-то". Это должно быть особенно полезно для начинающих программистов. Взять файл "АБ.пы и":
def a():
print('A function in ab file');
a()
И второй файл "Ху.пы и":
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 работает модуль сразу на импорт, такаб
'операции с выполнится до концаху
'ов. Как только закончите сАБ
, продолжается вху
. Переводчик следит за тем, какие скрипты выполняются симя. При запуске сценария - неважно, что вы'вэ-имени это - переводчик называет это" по - __главный__"
В, что делает его хозяин или 'дома' скрипт, который возвращается после выполнения внешнего скрипта. Любой другой сценарий, который's посетило от этого в"__Главный__"
в скрипт присваивается его имя как__имя__
(например,__имя__ = = и"АБ.пы"
в). Следовательно, в строкеесли __имя__ == " от__главный__" и:
переводчик's тест, чтобы определить, если это's для интерпретации/анализа 'домой' сценарий, который изначально был выполнен, или, если это'ы временно выглядывал в другой (внешний) сценарий. Это дает программисту гибкость, чтобы скрипт ведут себя по-разному, если она'ы выполняются напрямую и внешнем вызове. Позвольте's шаг через код, приведенный выше, чтобы понять, что'ы происходит, сосредоточиться на линии unindented а также порядок их появления в скриптах. Помните, что функция - илидефа
- блоков Дон'т сделать что-нибудь сами по себе, пока они'вновь позвонил. Как переводчик могу сказать, если пробормотал себе:
- Открытые xy.py как 'домой' файл; это называют
" и главное я____&;
в__имя__
переменной.- Импорт и откройте файл с
__Имя__ = = и"АБ.пы"
в.- О, функция. Я'будете помнить, что.
- ОК, функция
а()
; я только что узнал, что. Печати 'функция в АБ файл'.- Конец файла; обратно в
"__основной__"
в!- О, функция. Я'будете помнить, что.
- Еще один.
- Функция
х()
; ОК, печатание 'периферийные задач: могут быть полезны в других проектах'.- Что's это?
Если
заявление. Ну, условие выполнено (переменная__имя__
имеет значението"__Главный__"
В), поэтому я'll вписывает в основной()функция и печати '*главная функция: это где действие*'. Две нижние линии означает: "Если это в
"Главный" ну или 'дома' скрипт, выполните функцию с именем main () в". Что's, почему вы'll увидеть
деф главная():блок сверху, в котором содержится основной поток сценария'с функциональность. зачем это сделали? Помните, что я сказал ранее об импорте отчетности? Когда вы импортируете модуль, это вовсе'т 'признают' его и ждать дальнейших указаний - это на самом деле работает все выполняемые операции, содержащиеся в сценарии. Поэтому, положив мясо из вашего скрипта в основной()
функция эффективно изолирует его, поставив его в изоляции, так что он выиграл'т бежать сразу при импорте на другой скрипт. Опять же, будут исключения, но общая практика такова, что основной()Не'т, как правило, вызываются извне. Так что вам может быть интересно еще одно: если мы'повторно не называя основной()
, а почему мы называем этот скрипт вообще? Это's, потому что многие люди структурируют свои скрипты с автономными функциями, которые построены, чтобы быть запущен независимо от остального кода в файле. Они'заново позже назвали еще где-то в теле скрипта. Что подводит меня к следующему: но код работает без него Да, что's вправо. Эти отдельные функции может быть вызван в он-лайн скрипт, который's не содержится внутри основной()функция. Если вы'вновь привыкли (как и я, в моих ранних этапах обучения программированию) в здании в соответствии скрипты, которые делают в точности то, что вам нужно, и вы'будете пытаться выяснить это снова, если вы когда-нибудь понадобится, то операцию снова ... Ну, вы'вновь не привыкли к такого рода внутренней структуры кода, потому что это's более сложным, чтобы построить, и это's не как понятный для чтения. Но, что'сек скрипта, который, вероятно, может'т иметь его функции внешнего вызова, потому что иначе оно было бы сразу начать расчет и назначение переменных. И скорее всего, если вы'вновь пытается повторно использовать функции, новый сценарий связан тесно достаточно старый, что не будет конфликтующие переменные. При разделении независимых функций, вы получаете возможность повторно использовать вашу предыдущую работу путем вызова их в другой скрипт. Например, "в пример.пы" и можете импортировать на "Ху.РУ" и называть
х()`, использование 'х' функция от "Ху.пы-то". (Может быть, это'с опорой третье слово из заданной текстовой строки; создание массива numpy из списка чисел и возведения в квадрат, или тренда, 3D-поверхности. Возможности безграничны.) (Как в стороне, этот вопрос содержится ответ на @kindall, который, наконец, помог мне понять - почему, а не как. К сожалению, это'был отмечен как дубликат этот, который я думаю, является ошибкой.)
Когда есть определенные высказывания в наш модуль (М. П.
) Мы хотим быть выполнена, когда он'll быть запущен в качестве основного (не импортированные), то можете разместить эти заявления (тест-кейсов, печать выписок) при этом если
блок.
Как по умолчанию (когда модуль работает в качестве основного, не импортируются) __имя__
переменная имеет значение то"__Главный__"
В, и когда он'll быть импортирован __имя__
переменная получит новое значение, скорее всего, имя модуля ('м'
).
Это полезно в управлении различных вариантов модулей вместе, а разделив их конкретный вклад &ампер; выходное заявления, а также, если есть какие-то тест-кейсы.
Короче используйте это 'Если __имя__ = = на "Главное"
' заблокировать, чтобы предотвратить (некоторые) код выполняется, когда модуль импортируется.
Проще говоря, `имя - это переменная, определенная для каждого сценария, который определяет, будет ли запущен скрипт, в качестве основного модуля или он выполняется как импортированном модуле.
Так что если у нас есть два скрипта;
#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__
Как вы можете видеть, __имя__
говорит нам, что код-это 'главная' модуль.
Это здорово, потому что можно просто писать код и не придется беспокоиться о структурной проблемы, как в C/C++, где, если файл не реализует 'главная' функция то он не может быть скомпилирован в исполняемый файл и если это так, он не может быть использован в качестве библиотеки.
Скажи, что ты написать скрипт на Python, который делает что-то великое и реализовать кучу функций, которые пригодятся для других целей. Если я хочу их использовать, я могу просто импортировать скрипт и использовать их без выполнения вашей программы (учитывая, что код выполняется только в случае, если имя = = и"Главный" и:` контекст). В то время как в C/C++ вы бы к части из этих частей в отдельный модуль, который затем включает в себя файл. Представьте ситуацию ниже;
Стрелки импорт ссылок. Для трех модулей, каждый старается включить предыдущий код модулей есть шесть файлов (девять, считая внедрения файлов) и пять ссылки. Это делает его трудно, чтобы включить другой код в проект С, если она скомпилирована специально под библиотеку. Сейчас картина для Python:
Вы пишете модуль, и если кто-то хочет использовать ваш код, они просто импортировать его и переменная __имя__
может помочь отделить исполняемой части программы из библиотеки части.
Позвольте's взглянуть на ответ в более абстрактном виде:
Предположим, у нас есть этот код в X.пы:
...
<Block A>
if __name__ == '__main__':
<Block B>
...
Блоки A и B выполняются, когда мы бежим на "Х.пы-то".
Но просто блокировать (а не б) выполняется, когда мы запускаем еще один модуль, "В Г.пы" и например, в которых X.г импортирован и код запускать оттуда (например, когда функция в "Х.пы" это называется из г.пы).
Когда вы запустите Python в интерактивном режиме переменной местного __имя__
присвоено значение _главный___
. Аналогичным образом, когда вы выполняете модуль питона, из командной строки, а не импортировать его в другом модуле, ееимяатрибуту присваивается значение
главный, а не фактическое имя модуля. Таким образом, модули можно посмотреть значение своей
имя`, чтобы определить для себя, как они используются, будь то в качестве поддержки для другой программы или в качестве основного приложения, выполняемого из командной строки. Таким образом, следующая идиома является довольно распространенной в модули 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()
Он проверяет, если значение атрибута __имя__ скрипте Python-это в
" главного quot как__&;. Другими словами, если сама программа выполнена, атрибут будет
главный, так что программа будет выполнена (в этом случае функция основной ()
).
Однако, если ваш скрипт Python используется модуль, любой код за пределами если
заявление будет исполнен, так что если \__имя__ == " и\__главный__"
в используется просто, чтобы проверить, если программа используется как модуль или нет, и поэтому решает, следует ли выполнять код.
Прежде чем объяснять что-то, если имя == 'основной'важно понимать, что__имя__
и что он делает.
что такое
__имя__
?
__имя__
- это DunderAlias - можно рассматривать как глобальную переменную (можно из модули) и работает аналогично глобальный
.
Он является строкой (глобальная как уже говорилось выше), как указано тип(имя)(уступая в
<класс 'ул.'>`), и представляет собой встроенный стандартный для питон 3 и питон 2 версии.
где:
Она может быть использована не только в сценарии, но также могут быть найдены в переводчик и модули/пакеты.
Переводчик:
>>> print(__name__)
__main__
>>>
Автор сценария:
test_file.py:
print(__name__)
В результате _основной ___
Модуля или пакета:
somefile.py:
def somefunction():
print(__name__)
test_file.py:
import somefile
somefile.somefunction()
В результате в некий-файл`
Обратите внимание, что при использовании в пакет или модуль __имя__
принимает имя файла. Путь фактического модуля или путь пакета не дали, но имеет свои DunderAlias __файл__
, что позволяет за это.
Вы должны увидеть, что, где __имя__, где основной файл (или программу) будет *всегда* возвращение
главный`, а если это модуль/пакет, или то, что работает у другой Python скрипт будет возвращать имя файла, где он возник от.
практики:
Будучи переменной означает, что она's стоимостью может быть перезаписаны ("могут" не означает "не должны", у), заменив значение __имя__
приведет к потере читаемости. Так что не делайте этого, по какой-либо причине. Если вам нужна переменная определить новую переменную.
Всегда предполагается, что значение __имя__
к __главный__
или имя файла. В очередной раз изменив это значение по умолчанию, приведет к путанице, что это принесет пользу, вызывая дальнейшие проблемы.
пример:
>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>
Считается хорошей практикой в целом, чтобы включить если __имя__ == '__основной__'
в сценарии.
теперь ответ-если имя == 'главная'`:
Теперь мы знаем, что поведение __имя__
вещи становятся яснее:
Это "если" - это оператор управления потоком, содержащее блок кода будет выполняться, если значение дана верная. Мы видели, что __имя__
может принимать либо
__главный__
или имя файла было импортировано из.
Это означает, что еслиимяравен
главный`, то файл должен быть основной файл и должен на самом деле быть запущена (или переводчика), а не модуль или пакет импортировать в скрипт.
Если действительно __имя__
принимает значение __главный__
то, что находится в этом блоке кода будет выполняться.
Это говорит нам, что если исполняемый файл является главным файлом (или вы работаете с переводчиком напрямую), то это условие должно выполняться. Если это пакет, то он не должен, и значение не будет _основной___
.
модули:
__имя__
также может быть использована в модулях для того чтобы определить имя модуля
варианты:
Это также можно сделать другие, менее распространенные, но полезные вещи с __имя__
, некоторые я покажу здесь:
Выполняется только если файл модуля или пакета:
if __name__ != '__main__':
# Do some useful things
Выполняется одно условие, если файл является основным, а другое, если это не так:
if __name__ == '__main__':
# Execute something
else:
# Do some useful things
Вы также можете использовать его, чтобы обеспечить выполняемых функций и утилит, пакетов и модулей без продуманной использования библиотек.
Это также позволяет модули быть запущен из командной строки в качестве основных сценариев, которые могут быть также очень полезными.
Я думаю, что это'ы лучше разорвать ответ в глубине и в простых словах:
__имя__
: каждый модуль в Python есть специальный атрибут, называемыйимя`.
Это встроенная переменная, которая возвращает имя модуля.
_основной___
: как и другие языки программирования, в Python тоже есть запись исполнения, т. е. главный. '__главный__'
- имя области, в которой топ-уровня выполняется код. В основном у вас есть два способа использования модуль Python: запустить его прямо как сценарий, или импортировать его. Когда модуль работает как скрипт, егоимя установлен _основной___`.
Таким образом, значение атрибута __имя__
имеет значение __главный__
при выполнении модуля в качестве основной программы. В противном случае значение __имя__
может содержать имя модуля.
Это специально для когда файл python вызывается из командной строки. Это обычно используется, чтобы вызвать "в функции main()" по функции или выполнять другие соответствующие код запуска, как аргументы командной строки обращения к примеру.
Она могла быть написана несколькими способами. Другое:
def some_function_for_instance_main():
dosomething()
__name__ == '__main__' and some_function_for_instance_main()
Я не говорю, что вы должны использовать это в рабочий код, но он иллюстрирует, что нет ничего, что "волшебные" около Если __имя__ == '__основной__'
. Это хорошая конвенция для вызова основной функции в Python файлов.
Существует целый ряд переменных, система (интерпретатора Python) предоставляет исходные файлы (модули). Вы можете получить их значения в любое время вы хотите, так что давайте сосредоточимся на имя атрибут переменной/:
Когда Python загружает файл с исходным кодом, он выполняет все код нашли в нем. (Отметим, что это не't вызовов всех методов и функций, заданных в файле, но это не определяет их.)
Прежде чем переводчик хоть и выполняет файл с исходным кодом, он определяет несколько специальных переменных для этого файла; имя является одним из этих специальных переменных, что Python автоматически определяет для каждого файла исходного кода.
Если питон загружает этот файл с исходным кодом в качестве основной программы (т. е. файл запуска), то он устанавливает специальные имя переменная для этого файла имеет значение " по - главный" по.
Если это импортируется из другого модуля, имя будет установлено, что модуль's имя.
Так, в вашем примере в части:
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))
будет выполняться только при запуске модуля напрямую; блок кода не будет выполняться, если в другом модуле-это призвание/импорта, потому что стоимость имя не равны, чтобы "Главный" в данном конкретном случае.
Надеюсь, это поможет.
если __имя__ == " от__главный__" и:
в основном на верхнем уровне сценария среды, и указывает, что переводчик ('меня высокий приоритет выполняться в первую очередь').
'__главный__'
- название области, в которой топ-уровне кода. Модуля __имя__
установлено равным '__главный__'
Когда читать из стандартного ввода, скрипт, или интерактивную командную строку.
if __name__ == "__main__":
# Execute only if run as a script
main()
Я'вэ начиталась столько всего ответы на этой странице. Я бы сказал, Если вы знаете, что вы будете понять эти ответы, в противном случае, вы все еще не знаете.
Чтобы быть кратким, вам нужно знать несколько пунктов:
импортировать
действие на самом деле выполняется все, что можно бежали в "А"
Из-за пункта 1, Вы не хотите, чтобы все было работать в "А" при импорте его
Чтобы решить проблему в точке 2, питон позволяет поставить условие проверки
__имя__
- это неявная переменная во всех .модули пы; когда.пы импортируется, значение __имя__ от.модуль пы устанавливается в имени файла "А"; когда.пы выполняется непосредственно с помощью "в питоне.пы", который означает.ру-это точка входа, то значение
имя от.модуль пы задано строковое значение _основной ___
На основе механизма, как питон устанавливает переменную __имя__ для каждого модуля, вы знаете, как достичь точки 3? Ответ довольно прост, верно? Если поставить условие:
если имя == " по - основное - то": ...; Вы можете даже положить если__имя__ == "А"
в зависимости от функциональной необходимости
Главное, что Python-это в точку 4! Остальное-просто элементарная логика.
Причина
if __name__ == "__main__":
main()
в первую очередь, чтобы избежать заблокировать импорт проблемами, которые могут возникнуть из имея код напрямую импортированы. Вы хотите, основной (), чтобы работать, если ваш файл был напрямую вызван (что'ы
имя = = и"Главный"` в случае), но если код был импортирован, то импортер должен ввести код от истинного главного модуля, чтобы избежать импортных замка проблемы.
Побочный эффект заключается в том, что вы автоматически входить в методологию, которая поддерживает несколько точек входа. Вы можете запустить вашу программу, используя основной()в качестве точки входа, _but вы Дон'т иметь то_. А главное setup.py
ожидает()
, другие инструменты использовать альтернативные точки входа. Например, чтобы запустить файл как процесс gunicorn
, вы определяете для себя приложение (функция) вместо основной(). Как и в случае с
setup.py,
gunicorn` импортирует ваш код, так что вы Дон'т хотите, это ничего, пока он'ы импортируется (из-за проблема блокировки импорта).
Рассмотрим:
print __name__
Вывод Для выше _главный___
.
if __name__ == "__main__":
print "direct method"
Вышеуказанное заявление является истинной и гравюры на"прямой метод и". Предположим, если они импортированы этого класса в другом классе, он не'т печати на"прямой метод" и так, при импорте, это будет набор __имя__ равны, чтобы "первая модель именем"
.