Что делать, если __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))
 
вопрос задан 7.01.2009
Devoted
31395 репутация

27 ответов


  • 4593 рейтинг

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

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

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

     python threading_example.py
     

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

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

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

    ответ дан Mr Fooz, с репутацией 63165, 7.01.2009
  • 1475 рейтинг

    Когда ваш скрипт запускается, передавая его как команду интерпретатору 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__" .

    ответ дан Adam Rosenfield, с репутацией 297597, 7.01.2009
  • 577 рейтинг

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

    ответ дан pi., с репутацией 12902, 7.01.2009
  • 420 рейтинг

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

    Чтобы описать основы:

    • Глобальная переменная, __name__ , в модуле, которая является точкой входа в вашу программу, равна '__main__' . В противном случае это имя, в которое вы импортируете модуль.

    • Таким образом, код под блоком if будет выполняться только в том случае, если модуль является точкой входа в вашу программу.

    • Он позволяет импортировать код в модуле другими модулями, не выполняя блок кода под импортом.


    Зачем нам это надо?

    Разработка и тестирование вашего кода

    Предположим, вы пишете скрипт Python, предназначенный для использования в качестве модуля:

     def do_important():
        """This function does something very important"""
     

    Вы можете протестировать модуль, добавив этот вызов функции в нижнюю часть:

     do_important()
     

    и запускать его (в командной строке) с чем-то вроде:

     ~$ python important.py
     

    Проблема

    Однако, если вы хотите импортировать модуль в другой скрипт:

     import important
     

    При импорте будет вызываться функция do_important , поэтому вы, вероятно, прокомментируете свой вызов функции, do_important() , внизу.

     # do_important() # I must remember to uncomment to execute this!
     

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

    Лучший способ

    Переменная __name__ указывает на пространство имен где бы ни находился интерпретатор Python.

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

    Но внутри первичного модуля (или интерактивного сеанса Python, т. Е. Read, Eval, Print Loop или REPL) интерпретатора вы все запускаете из своих "__main__" .

    Поэтому, если вы проверяете перед выполнением:

     if __name__ == "__main__":
        do_important()
     

    С приведенным выше кодом ваш код будет выполняться только в том случае, если вы используете его в качестве основного модуля (или намеренно вызываете его из другого сценария).

    Еще лучший способ

    Тем не менее, есть возможность использовать Pythonic для улучшения этого.

    Что делать, если мы хотим запустить этот бизнес-процесс извне модуля?

    Если мы поместим код, который хотим реализовать, когда мы разрабатываем и тестируем в такой функции, а затем делаем наш чек на '__main__' сразу после:

     def main():
        """business logic for when running this module as the primary one!"""
        setup()
        foo = do_important()
        bar = do_even_more_important(foo)
        for baz in bar:
            do_super_important(baz)
        teardown()
    
    # Here's our payoff idiom!
    if __name__ == '__main__':
        main()
     

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

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

     import important
    important.main()
     

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

    Этот модуль представляет собой (в противном случае анонимную) область, в которой выполняется основная программа интерпретатора - команды, считываемые либо из стандартного ввода, либо из файла сценария, либо из интерактивного приглашения. Именно эта среда, в которой идиоматическая сцена «условный сценарий» заставляет сценарий запускаться:

     if __name__ == '__main__':
        main()
     
    ответ дан Aaron Hall, с репутацией 153756, 23.11.2013
  • 94 рейтинг

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

    ответ дан Harley Holcombe, с репутацией 105065, 7.01.2009
  • 59 рейтинг

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

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

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

     python mycode.py
     

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

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

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

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

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

     import mycode
    # ... any amount of other code
    mycode.main()
     
    ответ дан Aaron Hall, с репутацией 153756, 14.10.2014
  • 51 рейтинг

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

    Возьмите файл «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__" или« домашний », выполните функцию main() ". Вот почему вы увидите def main(): блоков вверх, которые содержат основной поток функций скрипта.

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

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

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

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

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

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

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

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

    ответ дан joechoj, с репутацией 661, 29.09.2016
  • 41 рейтинг

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

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

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

    ответ дан Nabeel Ahmed, с репутацией 7221, 3.04.2013
  • 33 рейтинг

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

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

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

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

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

    ответ дан Alisa, с репутацией 1349, 20.01.2015
  • 31 рейтинг

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

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

     #script1.py
    print "Script 1's name: {}".format(__name__)
     

    а также

     #script2.py
    import script1
    print "Script 2's name: {}".format(__name__)
     

    Результатом выполнения скрипта 1 является

     Script 1's name: __main__
     

    И результат выполнения скрипта2:

     Script1's name is script1
    Script 2's name: __main__
     

    Как вы можете видеть, __name__ говорит нам, какой код является «основным» модулем. Это здорово, потому что вы можете просто написать код и не беспокоиться о структурных проблемах, как в C /C ++, где, если файл не реализует «главную» функцию, он не может быть скомпилирован как исполняемый файл, и если это так, он не может быть использован в качестве библиотеки.

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

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

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

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

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

    ответ дан redbandit, с репутацией 1166, 15.10.2016
  • 31 рейтинг

    При интерактивном запуске 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.
     
    ответ дан Zain, с репутацией 877, 11.12.2013
  • 26 рейтинг

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

     if __name__ == "__main__":
        main()
     

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

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

    ответ дан Larry, с репутацией 595, 22.08.2017
  • 18 рейтинг

    Существует ряд переменных, которые система (интерпретатор Python) предоставляет исходные файлы (модули). Вы можете получить их значения в любое время, поэтому, давайте сосредоточимся на переменной __name__ variable /attribute:

    Когда 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 » в этом конкретном экземпляре.

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

    ответ дан codewizard, с репутацией 266, 25.11.2015
  • 18 рейтинг

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

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

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

    ответ дан Simon, с репутацией 4923, 3.04.2018
  • 17 рейтинг

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

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

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

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

    ответ дан Inconnu, с репутацией 3347, 30.11.2016
  • 17 рейтинг

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

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

     def some_function_for_instance_main():
        dosomething()
    
    
    __name__ == '__main__' and some_function_for_instance_main()
     

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

    ответ дан Prof. Falken, с репутацией 16238, 24.01.2013
  • 16 рейтинг

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

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

     if __name__ == "__main__":
        # Execute only if run as a script
        main()
     
    ответ дан The Gr8 Adakron, с репутацией 518, 24.04.2016
  • 12 рейтинг

    Причина для

     if __name__ == "__main__":
        main()
     

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

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

    ответ дан personal_cloud, с репутацией 656, 22.09.2017
  • 8 рейтинг

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

     print __name__
     

    Выходной сигнал для выше - __main__ .

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

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

    ответ дан Janarthanan Ramu, с репутацией 671, 22.06.2016
  • 8 рейтинг

    Вы можете сделать файл полезным как скрипт, так и импортируемый модуль .

    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

    ответ дан sam, с репутацией 3117, 13.03.2017
  • 6 рейтинг

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

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

    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__": ... ; вы можете даже положить, если __name__ == "a" зависимости от вашей функциональной потребности

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

    ответ дан jack, с репутацией 88, 24.06.2018
  • 2 рейтинг

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

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

    ответ дан preetika mondal, с репутацией 62, 4.05.2018
  • 2 рейтинг

    Создайте файл, 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
     
    ответ дан TheVishal, с репутацией 105, 8.01.2018
  • 1 рейтинг

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

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

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

    ответ дан pah8J, с репутацией 383, 19.06.2018
  • 1 рейтинг

    если имя == ' 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__
     
    ответ дан Ali Hallaji, с репутацией 330, 4.04.2018
  • -1 рейтинг

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

    Контур:

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

    ответ дан JawSaw, с репутацией 3060, 20.08.2018
  • -1 рейтинг

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

    ответ дан Ravichandran K, с репутацией 173, 28.06.2018