Что делать, если __name__ == "__main__": делать?

Что делает 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))
4240
задан Devoted 07 янв. '09 в 7:11
источник поделиться

28 ответов

Когда интерпретатор Python читает исходный файл, он выполняет весь найденный в нем код.

Перед выполнением кода он определит несколько специальных переменных. Например, если интерпретатор Python запускает этот модуль (исходный файл) в качестве основной программы, он устанавливает специальную переменную __name__ для значения "__main__". Если этот файл импортируется из другого модуля, то __name__ будет присвоено имя модуля.

В случае с вашим сценарием позвольте предположить, что он выполняет главную функцию, например, вы сказали что-то вроде

python threading_example.py

в командной строке. После настройки специальных переменных он выполнит оператор import и загрузит эти модули. Затем он будет оценивать блок def, создавая объект функции и создавая переменную myfunction которая указывает на объект функции. Затем он прочитает инструкцию if и увидит, что __name__ равно "__main__", поэтому он выполнит показанный там блок.

Одной из причин этого является то, что иногда вы пишете модуль (файл .py), где он может быть выполнен напрямую. Кроме того, его можно также импортировать и использовать в другом модуле. Выполняя основную проверку, вы можете использовать этот код только в том случае, если хотите запустить модуль как программу и не выполнять его, когда кто-то просто хочет импортировать ваш модуль и вызывать свои функции самостоятельно.

Дополнительную информацию см. на этой странице.

4526
ответ дан Mr Fooz 07 янв. '09 в 7:26
источник поделиться

Когда ваш 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__".

1452
ответ дан Adam Rosenfield 07 янв. '09 в 7:28
источник поделиться

Простейшим объяснением для переменной __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__'] в этом модуле имя модуля.

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

Как вы можете видеть, когда файл выполняется, Python устанавливает globals()['__name__'] в этом файле на "__main__".

568
ответ дан pi. 07 янв. '09 в 14:35
источник поделиться

Что делает 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()
417
ответ дан Aaron Hall 23 нояб. '13 в 7:38
источник поделиться

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

93
ответ дан Harley Holcombe 07 янв. '09 в 7:14
источник поделиться

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

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

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

python mycode.py

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

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

if __name__ == '__main__':
    main()
  • в конце mycode.py script,
  • когда он является основным модулем начальной точки, который запускается процессом Python,

приведет к выполнению уникальной функции main script.

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

import mycode
# ... any amount of other code
mycode.main()
59
ответ дан Aaron Hall 14 окт. '14 в 23:22
источник поделиться

Здесь есть много разных соображений по механике рассматриваемого кода, "Как", но для меня это не имело смысла, пока я не понял "Почему". Это должно быть особенно полезно для новых программистов.

Возьмите файл "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 - блоки не делают ничего сами по себе, пока не будут вызваны. Что может сказать интерпретатор, если пробормотал себе:

  • Откройте файл xy.py как "домашний" файл; назовите его "__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, который, наконец, помог мне понять - почему, а не как. К сожалению, это было отмечено как дубликат этого, что я считаю ошибкой.)

50
ответ дан joechoj 29 сент. '16 в 7:33
источник поделиться

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

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

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

40
ответ дан Nabeel Ahmed 03 апр. '13 в 17:09
источник поделиться

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

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

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

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

Но только блок A (а не B) запускается, когда мы запускаем другой модуль, например "y.py", в котором xy импортируется и код запускается оттуда (например, когда функция в "x". py "вызывается из y.py).

33
ответ дан Alisa 20 янв. '15 в 20:48
источник поделиться

При запуске 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.
31
ответ дан Zain 11 дек. '13 в 14:23
источник поделиться

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

Complicated importing in C

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

Elegant importing in Python

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

30
ответ дан redbandit 15 окт. '16 в 12:07
источник поделиться

Рассматривать:

if __name__ == "__main__":
    main()

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

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

25
ответ дан Larry 22 авг. '17 в 21:53
источник поделиться

Существует ряд переменных, которые система (интерпретатор 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" в этом конкретном экземпляре.

Надеюсь, что это поможет.

18
ответ дан codewizard 25 нояб. '15 в 15:26
источник поделиться

Это особенность, когда из командной строки вызывается файл Python. Обычно это используется для вызова функции "main()" или для запуска другого соответствующего кода запуска, например, для обработки аргументов командной строки.

Его можно было бы написать несколькими способами. Другой:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

Я не говорю, что вы должны использовать это в производственном коде, но это служит для иллюстрации того, что нет ничего "волшебного" в if __name__ == '__main__'. Это хорошее соглашение для вызова основной функции в файлах Python.

17
ответ дан Prof. Falken 24 янв. '13 в 16:48
источник поделиться

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

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

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

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

17
ответ дан Inconnu 30 нояб. '16 в 9:47
источник поделиться

Прежде чем объяснять что-либо о 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

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

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

16
ответ дан Simon 03 апр. '18 в 22:32
источник поделиться

if __name__ == "__main__": это в основном среда сценария верхнего уровня, и он указывает интерпретатор, который ("Я выполняю первый приоритет первым").

'__main__' - это имя области, в которой выполняется код верхнего уровня. Модули __name__ устанавливаются равными '__main__' при чтении со стандартного ввода, сценария или из интерактивного приглашения.

if __name__ == "__main__":
    # Execute only if run as a script
    main()
16
ответ дан The Gr8 Adakron 24 апр. '16 в 11:23
источник поделиться

Причина для

if __name__ == "__main__":
    main()

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

Побочным эффектом является то, что вы автоматически включаетесь в методологию, которая поддерживает несколько точек входа. Вы можете запустить свою программу, используя main() в качестве точки входа, но вам этого не нужно. Хотя setup.py ожидает main(), другие инструменты используют альтернативные точки входа. Например, чтобы запустить файл как процесс gunicorn, вы определяете функцию app() вместо main(). Как и в случае с setup.py, gunicorn импортирует ваш код, поэтому вы не хотите, чтобы он делал что-либо во время его импорта (из-за проблемы с блокировкой импорта).

12
ответ дан personal_cloud 22 сент. '17 в 21:32
источник поделиться

Вы можете сделать файл полезным как 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]))

Ссылка: https://docs.python.org/3.5/tutorial/modules.html

8
ответ дан sam 14 марта '17 в 0:44
источник поделиться

Рассматривать:

print __name__

Вывод для выше - __main__.

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

Вышеприведенное утверждение верно и печатает "прямой метод". Предположим, если они импортировали этот класс в другой класс, он не печатает "прямой метод", потому что, импортируя, он будет устанавливать __name__ equal to "firstmodel name".

8
ответ дан Janarthanan Ramu 22 июня '16 в 13:47
источник поделиться

Создайте файл, 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
2
ответ дан TheVishal 08 янв. '18 в 18:24
источник поделиться

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

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

2
ответ дан preetika mondal 04 мая '18 в 11:25
источник поделиться

Если этот.py файл импортируется другими.py файлами, код под "оператором if" не будет выполнен.

Если этот.py запущен python this_py.py под оболочкой или дважды щелкнут в Windows. будет выполнен код под "оператором if".

Обычно он предназначен для тестирования.

1
ответ дан pah8J 19 июня '18 в 14:44
источник поделиться

если имя == ' main ':

Мы видим, что __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__
1
ответ дан Ali Hallaji 04 апр. '18 в 17:32
источник поделиться

Я читал так много ответов на этой странице. Я бы сказал, если вы знаете это, вы наверняка поймете эти ответы, иначе вы все еще смущены.

Короче говоря, вам нужно знать несколько моментов:

  1. import a действия фактически запускает все, что можно запустить в "a"

  2. Из-за пункта 1 вам может не потребоваться, чтобы все было запущено в "a" при импорте

  3. Чтобы решить проблему в пункте 2, python позволяет вам поставить проверку состояния

  4. __name__ - неявная переменная во всех.py-модулях; когда a.py импортируется, значение __name__ модуля a.py устанавливается в его имя файла "a"; когда a.py запускается напрямую с помощью "python a.py", что означает, что a.py является точкой входа, тогда значение __name__ модуля a.py устанавливается в строку __main__

  5. На основе механизма, как питон устанавливает переменную __name__ для каждого модуля, знаете ли вы, как достичь точки 3? Ответ довольно прост, не так ли? Положите условие if: if __name__ == "__main__":...; вы можете даже поставить if __name__ == "a" зависимости от вашей функциональной потребности

Важной вещью, что питон особенным в точке 4! Остальное - просто базовая логика.

1
ответ дан jack 24 июня '18 в 18:48
источник поделиться

_ name _ == _ main _ будет убедиться, что код/​​операторы, присутствующие внутри этого блока, будут выполняться только при непосредственном выполнении этого файла, вместо этого, если мы импортируем это как модуль в другой файл python, тогда мы можем вызвать функцию, определенную в нем а также блок, который присутствует внутри _ name == main _, не будет выполнен.

-1
ответ дан Ravichandran K 28 июня '18 в 13:19
источник поделиться

Что означает имя if: " main ": do?

Контур:

1, как исполняемый скрипт, работать для себя как самостоятельно занятый: он выполняет коды в модуле, если он запускается непосредственно как "python foo.py",
2, как импортированный модуль для работы для других:
Его коды могут быть повторно использованы безопасно, если они импортированы в другой модуль как "import foo",

-1
ответ дан JawSaw 20 авг. '18 в 3:49
источник поделиться

Если интерпретатор python запускает этот модуль (исходный файл) в качестве основной программы, он устанавливает для переменной специального имени значение " main ".

Если этот файл импортируется из другого модуля, имя будет установлено на имя модуля. Название модулей доступен в качестве значения назвать глобальной переменной.

-1
ответ дан Kiran Sk 11 авг. '18 в 8:21
источник поделиться

Другие вопросы по меткам