If name main не работает

Использование if __name__ == «__main__» в Python

В данном руководстве мы рассмотрим для чего используется условие if name == «__main__» в Python, и в каких случаях оно нам может пригодиться.

Введение

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

Это имеет значение для этих двух случаев использования:

• Мы запускаем его как основную программу с помощью python filename.py
• Импортируем файл в другой файл с помощью import filename

В последнем случае обычно мы хотим только импортировать модуль, а затем позже в коде выполнить некоторые функции или использовать класс из этого файла. Именно здесь вступает в игру оператор if __name__ == «main», который работает как защитник.

Давайте выясним, почему и как это работает.

Специальная переменная

Когда интерпретатор Python читает исходный файл, он делает две вещи:

• Во-первых, он устанавливает несколько специальных переменных, таких как __name__.
• Затем он выполняет весь код, который находит в файле.

Давайте посмотрим на следующий пример, где мы правильно используем оператор if __name__ == «main»:

Первый случай использования

Запустите его как основную программу с помощью python testa.py.

Интерпретатор Python присвоит переменной __name__ жестко закодированную строку «main», и таким образом код в операторе if будет выполнен:

Второй случай использования

Импортируйте testa в качестве модуля.

Интерпретатор присвоит «testa» переменной __name__ в модуле testa. Таким образом, код в операторе if не будет выполнен, и func_one не запустится.

Без if __name__ == «main» в testa.py вывод был бы следующим:

Обычно это не то, что нам нужно. Поэтому, если вы хотите запустить код в файле, хорошей практикой будет обернуть весь этот код в оператор if __name__ == «main».

Заключение

В этой статье мы рассмотрели различные способы использования инструкции if __name__ == «main». Научились применять их на практики и теперь знаем как использовать их у себя в проекте.

Источник

Используйте __main__.py

Зачем нужен __init__.py знает, наверное, любой питонист, но что насчёт __main__.py? Я видел немало проектов либо рабочих, либо на Github, которые не используют это магический файл, хотя могли бы сделать свою жизнь проще. На мой взгляд, __main__.py это лучший способ для взаимодействия с питоновскими модулями, состоящими из нескольких файлов.

Но давайте сначала разберёмся: как большинство людей запускают свои скрипты на Python?

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

Когда вы скармливаете скрипт интерпретатору, магическая глобальная переменная __name__ получает значение __main__. Таким образом мы узнаём, что это не импорт, а именно запуск. Например:

И это прекрасно работает для одиночного файла.

Проблема

Но если вы похожи на меня, вы не захотите, чтобы всё ваше приложение теснилось в единственном файле. Разбиение логики по разным файлам упрощает редактирование и поддержку. Например:

Но пользователю, который склонировал проект из репозитория будет непонятно — какой из этих файлов главный? Неужели run.py? А может client.py? Где же искать знакомую строку if __name__ == ‘__main__’? Вот здесь-то __main__.py и способен проявить себя.

__main__.py

Файл __main__.py вызывается при запуске проекта с флагом модуля — -m. И это весьма удобно, если код предназначен и для использования в качестве модуля, и для запуска из консоли. Думайте об этом файле, как о месте куда можно класть всё, что вы обычно кладёте внутрь if __name__ == ‘__main__’. Давайте изменим проект из примера выше соответственно:

И, вуаля! Теперь можно просто запускать проект как обычный модуль.

__main__.py будет выполняться автоматически. Это идеальное место для размещения интерфейса командной строки и обработки входных аргументов!

Источник

Что делает if __name__ == “__main__”?

Что происходит во время вызова if __name__ == «__main__»: ?

1 ответ 1

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

В случае с вашим сценарием, предположим, что код исполняется как основная функция, например:

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

Затем он прочтет инструкцию if , «поймёт», что __name__ эквивалентен «__main__» , и выполнит указанный блок.

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

Что означает «threading_example в данный момент импортируется из другого модуля»?

Источник

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

Учитывая следующий код, что делает if __name__ == «__main__»: ?

27 ответов

Каждый модуль в Python имеет атрибут с именем __name__ . Значение атрибута __name__ равно __main__ , когда модуль запускается напрямую, например, python my_module.py . В противном случае (например, когда вы говорите import my_module ), значение __name__ является именем модуля.

Небольшой пример, чтобы объяснить вкратце.

Мы можем выполнить это непосредственно как

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

Когда вы выполните это

Таким образом, вышесказанное говорит само за себя, что при вызове test из другого скрипта цикл if __name__ в test.py не будет выполнен.

Создайте файл a.py :

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

Создайте другой файл b.py в том же каталоге:

Запустить его. Он напечатает a , то есть имя файла, который импортирован .

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

Проще говоря, это точка входа для запуска файла, как и функция main в языке программирования C .

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

Чтобы быть кратким, вам нужно знать несколько моментов:

import a действие фактически запускает все, что может быть запущено в «а»

Из-за пункта 1 вы можете не захотеть, чтобы все выполнялось в «а» при импорте

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

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

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

Важной особенностью Python является точка 4! Остальное — просто базовая логика.

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

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

Результат выполнения script1:

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

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

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

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

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

Код внутри if __name__ == ‘__main__’: будет выполняться только в том случае, если модуль вызывается как скрипт .

В качестве примера рассмотрим следующий модуль my_test_module.py :

1-я возможность: импортировать my_test_module.py в другой модуль

Теперь, если вы вызываете main.py :

Обратите внимание, что выполняется только print() оператор верхнего уровня в my_test_module .

2-я возможность: вызывать my_test_module.py как скрипт

Теперь, если вы запустите my_test_module.py как скрипт Python, будут выполнены оба оператора print() :

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

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

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

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

Выход для вышеупомянутого — __main__ .

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

Этот ответ для Java-программистов, изучающих Python. Каждый файл Java обычно содержит один открытый класс. Вы можете использовать этот класс двумя способами:

Вызовите класс из других файлов. Вы просто должны импортировать его в вызывающую программу.

Запустите класс самостоятельно, в целях тестирования.

В последнем случае класс должен содержать открытый статический метод void main (). В Python этой цели служит глобально определенная метка ‘__main__’ .

Простейшее объяснение переменной __name__ (imho) заключается в следующем:

Создайте следующие файлы.

Запустив их, вы получите такой вывод:

Как вы можете видеть, когда модуль импортируется, Python устанавливает globals()[‘__name__’] в этом модуле на имя модуля. Также при импорте запускается весь код в модуле. Поскольку оператор if оценивается как False , эта часть не выполняется.

Как вы можете видеть, когда файл выполняется, Python устанавливает globals()[‘__name__’] в этом файле на «__main__» . На этот раз оператор if оценивается как True и выполняется.

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

If name == ‘ main ‘:

Мы видим, __name__ == ‘__main__’: довольно часто.

Он проверяет, импортируется ли модуль или нет.

Другими словами, код в блоке if будет выполняться только тогда, когда код выполняется напрямую. Здесь directly означает not imported .

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

Если мы запустим код напрямую через python test.py , имя модуля будет __main__ :

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

Предположим, что у вас есть два файла Python, a.py и b.py. Теперь a.py импортирует b.py. Мы запускаем файл a.py, где сначала выполняется код import b.py. Перед запуском остальной части кода a.py код в файле b.py должен выполняться полностью.

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

Вот что проверяет эта строка кода. Если это основной файл (т.е. b.py), на котором выполняется код, а в данном случае это не так (a.py — основной файл, на котором выполняется), то выполняется только код.

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

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

Прежде чем интерпретатор выполнит файл исходного кода, он определит несколько специальных переменных для этого файла; __name __ — это одна из тех специальных переменных, которые Python автоматически определяет для каждого файла исходного кода.

Если Python загружает этот файл исходного кода в качестве основной программы (т. Е. Файла, который вы запускаете), он устанавливает специальную переменную __name __ , чтобы этот файл имел значение «__ main __» .

Если это импортируется из другого модуля, __name __ будет установлено на имя этого модуля.

Итак, в вашем примере частично:

Означает, что блок кода:

Будет выполняться только при непосредственном запуске модуля; блок кода не будет выполняться, если другой модуль вызывает / импортирует его, потому что значение __name __ не будет равно main в данном конкретном случае.

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

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

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

Если интерпретатор Python работает с определенным модулем, то __name__ глобальная переменная будет иметь значение «__main__»

Когда вы запускаете этот скрипт печатает вы можете видеть меня

Если вы импортируете этот файл, скажем, A, в файл B и запустите файл B, то if __name__ == «__main__» в файле A станет ложным, поэтому он напечатает Вы меня не видите

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

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

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

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

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

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

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

При интерактивном запуске Python локальной переменной __name__ присваивается значение __main__ . Аналогично, когда вы запускаете модуль Python из командной строки, а не импортируете его в другой модуль, его атрибуту __name__ присваивается значение __main__ , а не фактическое имя модуля. Таким образом, модули могут смотреть на свое собственное значение __name__ , чтобы определить для себя, как они используются, как поддержка другой программы или как основное приложение, выполняемое из командной строки. Таким образом, следующая идиома довольно распространена в модулях Python:

Когда ваш скрипт запускается путем передачи его в качестве команды интерпретатору Python,

Весь код на уровне отступа 0 выполняется. Определенные функции и классы, ну, в общем, определены, но ни один из их кода не запускается. В отличие от других языков, нет функции main() , которая запускается автоматически — функция main() неявно представляет собой весь код верхнего уровня.

В этом случае код верхнего уровня является блоком if . __name__ — это встроенная переменная, которая соответствует имени текущего модуля. Однако, если модуль запускается напрямую (как в myscript.py выше), тогда вместо __name__ задается строка «__main__» . Таким образом, вы можете проверить, выполняется ли ваш скрипт напрямую или импортируется чем-то другим, проверяя

Если ваш скрипт импортируется в другой модуль, его различные функции и определения классов будут импортированы, и будет выполнен его код верхнего уровня, но код в теле then условия if выше не получит запустить как условие не выполнено. В качестве основного примера рассмотрим следующие два сценария:

Теперь, если вы вызываете переводчик как

Если вы запустите two.py вместо:

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

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

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

__main__ : Как и другие языки программирования, Python также имеет точку входа для выполнения, то есть main. ‘__main__’ — это имя области, в которой выполняется код верхнего уровня . По сути, у вас есть два способа использования модуля Python: запустить его непосредственно как скрипт или импортировать его. Когда модуль запускается как скрипт, его __name__ устанавливается на __main__ .

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

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

fibo.py (модуль с именем fibo )

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

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

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

Читайте также:  Как отремонтировать шов бассейна

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

Что такое __name__ ?

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

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

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

В результате __main__

Модуль или пакет:

В результате somefile

Обратите внимание, что при использовании в пакете или модуле __name__ принимает имя файла. Путь к фактическому модулю или пути пакета не указан, но имеет свой собственный DunderAlias __file__ , который учитывает это.

Вы должны увидеть, что __name__ , где это основной файл (или программа), всегда вернет __main__ , и если это модуль / пакет, или что-то, что запускается из другого скрипта Python, вернет имя файла, из которого он возник.

Если переменная означает, что ее значение можно перезаписать («может» не означает «следует»), перезапись значения __name__ приведет к недостаточной читаемости. Так что не делай этого ни по какой причине. Если вам нужна переменная, определите новую переменную.

Всегда предполагается, что значение __name__ равно __main__ или имя файла. Повторное изменение этого значения по умолчанию вызовет еще большую путаницу в том, что оно пойдет на пользу, и вызовет проблемы в дальнейшем.

В целом считается хорошей практикой включать if __name__ == ‘__main__’ в сценарии.

Теперь ответим if __name__ == ‘__main__’ :

Теперь мы знаем, что поведение __name__ вещей становится понятнее:

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

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

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

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

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

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

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

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

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

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

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

Чтобы изложить основы:

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

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

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

Зачем нам это нужно?

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

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

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

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

Проблема

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

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

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

Лучший путь

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

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

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

Так что если вы проверите перед выполнением:

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

Еще лучший путь

Тем не менее, есть Pythonic способ улучшить это.

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

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

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

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

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

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

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

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

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

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

• в конце вашего скрипта mycode.py,
• когда это основной модуль точки входа, который запускается процессом Python,

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

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

Источник