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

22 ответов

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

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

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

python threading_example.py

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

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

Подробнее см. эту страницу.

4041
ответ дан 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__".

1264
ответ дан 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__".

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

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

86
ответ дан 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()
52
ответ дан Aaron Hall 14 окт. '14 в 23:22
источник поделиться

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

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

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

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

Возьмите файл "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__. Когда вы запускаете script - независимо от того, что вы его назвали, интерпретатор называет его "__main__", делая его хозяином или "домашним" script, который возвращается после запуска внешнего script. Любые другие script, вызываемые из этого "__main__" script, назначаются своим именем файла как __name__ (например, __name__ == "ab.py"). Следовательно, строка if __name__ == "__main__": является интерпретаторным тестом, чтобы определить, интерпретировало ли он/ "исходный" script, который был изначально выполнен, или временно заглянул в другой (внешний) script. Это дает гибкость программисту, чтобы script вел себя по-другому, если он выполнялся напрямую или вызывался извне.

Позвольте пройти через вышеприведенный код, чтобы понять, что происходит, сосредоточившись сначала на незашифрованных строках и порядке, которые они отображают в сценариях. Помните, что функции - или def - блоки ничего не делают сами по себе, пока не будут вызваны. Что может сказать интерпретатор, если пробормотал себе:

  • Откройте файл xy.py как "домашний" файл; назовите его "__main__" в переменной __name__.
  • Импортировать и открыть файл с помощью __name__ == "ab.py".
  • О, функция. Я запомню это.
  • Хорошо, функция a(); Я только что узнал об этом. Печать "Функция в файле ab".
  • Конец файла; вернуться к "__main__"!
  • О, функция. Я запомню это.
  • Другой.
  • Функция x(); ok, печать "периферийная задача: может быть полезна в других проектах".
  • Что это? Оператор if. Ну, условие выполнено (переменная __name__ установлена ​​на "__main__"), поэтому я введу функцию main() и печатаю 'main: это где действие есть.

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

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

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

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

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

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

Разделяя независимые функции, вы получаете возможность повторно использовать свою предыдущую работу, вызывая их в другой script. Например, "example.py" может импортировать "xy.py" и вызвать x(), используя функцию "x" из "xy.py" . (Возможно, он заглаживает третье слово данной текстовой строки, создает массив numpy из списка чисел и возводит в квадрат их или дешифрует трехмерную поверхность. Возможности безграничны.)

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

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

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

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

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

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

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

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

Put Simply __name__ - это переменная, определенная для каждого script, которая определяет, выполняется ли script в качестве основного модуля или запускается как импортированный модуль.

Итак, если у нас есть два сценария;

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

Скажем, вы пишите python script, который делает что-то отличное, и вы реализуете лодку функций, полезных для других целей, если я хочу их использовать, я могу просто импортировать ваш script и использовать их без выполнения вашей программы (учитывая, что ваш код выполняется только в контексте if __name__ == "__main__":). Если в C/С++ вам придется разделить эти фрагменты на отдельный модуль, который затем включает файл. Представьте ситуацию ниже;

сложный импорт в C

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

элегантный импорт в Python

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

24
ответ дан redbandit 15 окт. '16 в 12:07
источник поделиться
if __name__ == "__main__":
    main()

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

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

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

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

Он может быть написан несколькими способами, а другой -

def main():
    dosomething()


__name__ == '__main__' and main()

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

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

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

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

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

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

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

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

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

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

if __name__ == "__main__": - это в основном среда верхнего уровня script, она указывает интерпретатор, который ( "У меня есть наивысший приоритет, который нужно выполнить первым" ).

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

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

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

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

для вышеприведенного значения __main__

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

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

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

Причина

if __name__ == "__main__":
    main()

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

Побочным эффектом является то, что вы автоматически подписываетесь на методологию, которая поддерживает несколько точек входа.

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

создать файл a.py

print(__name__) #it will print out __main__

__name__ всегда равно __main__, когда этот файл выполняется напрямую, показывая, что это основной файл.

создайте еще один файл b.py в том же каталоге

import a   #prints a

запустите его. он будет печатать a i.e имя файла, который импортирован.

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

# code to be run when imported into another python file

if __name__ == '__main__':
    #code to be run only when run directly
1
ответ дан TheVishal 08 янв. '18 в 18:24
источник поделиться

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

Что такое __name__?

__name__ является DunderAlias ​​- можно рассматривать как глобальную переменную (доступную из модулей) и работает аналогично global.

Это строка (глобальная, как упоминалось выше), как указано type(__name__) (дает <class 'str'>), и является встроенным стандартом для Python 3 и версии Python 2..

Где:

Его можно использовать не только в скриптах, но также можно найти как в интерпретаторе, так и в модулях/пакетах.

Интерпретатор:

>>> print(__name__)
__main__
>>>

Script:

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 script, вернет имя файла, из которого он произошел.

Практика:

Быть переменной означает, что ее значение может быть перезаписано ( "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__ становится понятным:

An if - это оператор управления потоком, который содержит блок кода, будет выполняться, если заданное значение истинно. Мы видели, что __name__ может принимать либо __main__ или имя файла, из которого он был импортирован.

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

Если действительно __name__ принимает значение __main__, то все, что находится в этом блоке кода, будет выполняться.

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

Модули:

__name__ также может использоваться в модулях для определения имени модуля

Варианты:

Также можно использовать другие, менее распространенные, но полезные вещи с помощью __name__, некоторые из которых я покажу здесь:

Выполнение только в том случае, если файл является модулем или пакетом:

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

Запуск одного условия, если файл является основным, а другой, если это не так:

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

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

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

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

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

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