означает, что когда мы вызываем файл .py, он только создает данные и не обрабатывает другие функции класса; другие функции класса (загрузка данных) могут быть импортированы из других классов.
Что делать, если name = = «main»: do?
Когда интерпретатор Python прочитает исходный файл, он выполнит весь содержащийся в нем код.
Перед выполнением кода он устанавливает некоторые специальные переменные. Например, когда интерпретатор Python выполняет этот раздел (исходный файл) в качестве основной программы, он устанавливает специальную переменную __name__ в значение «__main__». Когда этот файл импортируется из другого модуля, __name__ устанавливается на имя модуля.
В случае с вашим скриптом предположим, что он выполняется как главная функция, например, вы сказали что-то вроде
в командной строке. После того как вы определили специальные переменные, выполняется оператор импорта и загружаются модули. Затем он оценивает блок def, создает объект функции и создает переменную myfunction, которая указывает на объект функции. Затем он читает команду if и видит, что __name__ равно «__main__», поэтому он выполняет блок, показанный там.
Одна из причин этого заключается в том, что иногда вы пишете модуль (файл .py), который может быть выполнен напрямую. В качестве альтернативы его можно импортировать и использовать в другом модуле. Проверка Basic позволяет запускать этот код, только если вы хотите запустить модуль как программу, а не если кто-то просто хочет импортировать ваш модуль и вызвать ваши функции.
Более подробную информацию см. на этой странице.
Когда ваш сценарий выполняется, вы передаете его как команду интерпретатору Python,
он выполняет весь код, который находится в углублении уровня 0. Определенные функции и классы хорошо определены, но ни один их код не выполняется. В отличие от других языков, здесь нет функции main(), которая выполняется автоматически — функция main() молча выполняет весь код верхнего уровня.
В данном случае код верхнего уровня представляет собой блок if. __name__ — это встроенная переменная, которая возвращает имя текущего модуля. Однако, если модуль выполняется напрямую (как в myscript.py выше), то __name__ будет «__main__» вместо строки «__name__» Поэтому вы можете проверить, выполняется ли ваш скрипт напрямую или импортируется из другой программы, попробовав следующее
Если ваш скрипт импортирован в другой модуль, различные функции и определения классов будут импортированы и код верхнего уровня будет выполнен, но код в теле оператора if выше не будет выполнен, поскольку условие не выполнено. В качестве основного примера можно привести следующие два сценария:
Если теперь вы запустите интерпретатор как
если вместо этого вы выполните файл two.py
чтобы при загрузке модуля one его __name__ был равен «one», а не «__main__».
Самое простое объяснение переменной __name__ (имхо) следующее:
создайте следующие файлы.
При их выполнении вы получите следующий результат:
Как вы можете видеть, когда Python импортирует модуль, он устанавливает globals()’__name__’ в этом модуле на имя модуля.
Как вы можете видеть, когда Python выполняет globals()’__name__’ в этом файле, он устанавливает его на «__main__». .
что значит if __name__ == «__main__»: делать?
Глобальной переменной __name__ в модуле, который является точкой входа в вашу программу, является «__main__». В противном случае это имя, под которым вы вводите модуль.
Поэтому код в блоке if работает только в том случае, если модуль является точкой входа в вашу программу.
позволяет импортировать код одного модуля другими модулями без выполнения базового блока кода при импорте.
Зачем нам это нужно?
Лучше
Переменная __name__ указывает на пространство имен, в котором в данный момент находится интерпретатор Python.
В импортированном модуле это имя модуля.
но внутри главного модуля (или интерактивной сессии Python, т.е. интерпретатора чтения, Eval, цикла печати или REPL) начинайте все с «__main__» .
Так что если вы проверите перед выполнением:
ваш код будет выполняться, только если вы запустите его как основной модуль (или намеренно вызовете его из другого скрипта).
Вероятно, в какой-то момент своей карьеры в Python вы будете обсуждать использование идиомы name-main. Это длинное выражение, когда вы пишете его, и еще более длинное, когда вы произносите его вслух, поэтому вы можете найти хороший способ поговорить об этом.
Python Modules Explained
Файлы Python называются модулями и обозначаются расширением .py. Модуль может определять функции, классы и переменные.
Поэтому, когда интерпретатор выполняет модуль, переменная __name__ устанавливается в __main__, если выполняемый модуль является основной программой.
Однако, если код импортирует модуль из другого модуля, переменная __name__ устанавливается в имя этого модуля.
Давайте рассмотрим пример. Создайте модуль Python под названием file_one.py и поместите в него этот код верхнего уровня:
Когда вы запустите этот файл, вы увидите именно то, о чем мы говорили. Переменная __name__ для этого модуля установлена в __main__:
Теперь добавьте еще один файл с именем file_two.py и вставьте в него этот код:
Также измените код в файле file_one.py, чтобы вставить модуль file_two следующим образом:
Если вы снова запустите код file_one, вы увидите, что переменная __name__ в file_one не изменилась и по-прежнему установлена в __main__. Но теперь переменная __name__ в file_two установлена как имя модуля, поэтому file_two .
Результат должен выглядеть следующим образом:
Но запустите file_two напрямую, и вы увидите, что его имя установлено на __main__:
Переменной __name__ для выполняемого файла/модуля всегда является __main__. Но переменная __name__ для всех других импортируемых модулей устанавливается на имя их модуля.
Python File Naming Conventions
Обычный способ использования __name__ и __main__ выглядит следующим образом:
Давайте рассмотрим, как это работает в реальной жизни и как на самом деле использовать эти переменные.
Измените переменные file_one и file_two так, чтобы они выглядели следующим образом:
Когда вы запустите file_one, вы увидите, что программа определила, какой из двух модулей является __main__, и выполнила код в соответствии с нашими первыми утверждениями if else.
Результат должен выглядеть следующим образом:
Теперь выполните file_two и вы увидите, что переменная __name__ установлена в __main__:
Когда такие модули вставляются и выполняются, вставляются их функции и выполняется код верхнего уровня.
Чтобы увидеть этот процесс в действии, измените свои файлы так, чтобы они выглядели следующим образом:
Теперь функции загружаются, но не выполняются.
Чтобы запустить одну из этих функций, измените часть if __name__ == «__main__» в file_one следующим образом:
Когда вы запустите file_one, вы увидите, что он должен выглядеть следующим образом:
Вы также можете запускать функции из импортированных файлов. Для этого измените секцию if __name__ == «__main__» в file_one так, чтобы она выглядела следующим образом:
И вы можете рассчитывать на такой результат:
Предположим, что раздел file_two очень большой и содержит много функций (в нашем случае две), не все из которых вы хотите импортировать. Измените файл_two так, чтобы он выглядел следующим образом:
А чтобы импортировать конкретные функции из модуля, используйте блок from import в файле_one:
Conclusion
Для переменной __name__ есть очень хороший вариант использования: нужен ли вам файл, который может быть выполнен как основная программа или импортирован другими модулями. Мы можем использовать блок if __name__ == «__main__», чтобы разрешить или запретить выполнение части кода при импорте модулей.
Когда интерпретатор Python читает файл, переменная __name__ устанавливается в __main__, если выполняется модуль, или в имя модуля, если он вставлен. При чтении файла выполняется весь код верхнего уровня, но не функции и классы (поскольку только они импортируются).
Bra gjort!
Вы можете найти больше подобных статей в моем профиле на freeCodeCamp, в моем профиле на Medium и в других интересных материалах, которые я делаю на моей странице на GitHub.
Запускается ли он только при непосредственном запуске модуля? Блок кода не выполнится, если другой модуль вызовет/импортирует его, потому что значение __name__ не равно » main.
if __name__ == «__main__» in Action
Мы используем оператор if для выполнения фрагментов кода только тогда, когда наша программа является основной выполняемой программой. Это позволяет нашей программе быть независимо исполняемой, но также поддерживать другие модули Python, которые хотят внедрить некоторые функции без необходимости запуска кода.
Рассмотрим следующие программы на языке Python:
α) Script3.py содержит функцию add(), которая вызывается только главным кадром.
Вот вывод при вызове script3.py:
Free eBook: Git Essentials
Прочитайте наше практическое руководство по изучению Git, содержащее лучшие практики, признанные отраслевые стандарты и шпаргалку. Перестаньте гуглить команды Git и действительно изучите его!
Поскольку сценарий выполняется напрямую, ключевое слово __name__ сопоставляется с ключевым словом __main__, и блок кода выполняется при условии if __name__ == «__main__».
b) Вот как это выглядит, когда этот фрагмент импортируется из script4.py:
Блок с условием if __name__ == «__main__» из script3.py не был выполнен, как ожидалось. Это произошло потому, что ключевому слову __name__ теперь присвоено имя сценария: script3. Это можно проверить с помощью указанной команды print, которая выводит присвоенное значение для ключевого слова __name__.
How Does __name__ == «__main__» Help in Development?
Вот несколько примеров использования этой команды if при создании сценария.
- Тестирование — это хорошая практика, которая не только помогает найти ошибки, но и гарантирует, что ваш код ведет себя так, как нужно. В тестовые файлы следует включать функцию или объект. В таких случаях мы обычно не хотим, чтобы скрипт выполнялся как основной модуль.
- Вы создаете библиотеку, но хотите включить в нее демо-версию или другие специальные случаи выполнения для пользователей. Когда вы используете эту команду if, модули Python, использующие ваш код в качестве библиотеки, не затрагиваются.
Однако для удобства чтения часто лучше поместить оператор импорта в начало, без второй идиомы name-main. Однако идиома «второе имя-главное» может быть полезна, если вы работаете в среде с ограниченными ресурсами.
If name main python что это
- Статус книги «Проектирование тестов»: Читайте книгу с редактором!
- Протоколы в корпоративных системах (DUMP 2022).
- Js скрипты на selenium и python.
- Мои 12 недель в году. Часть 20 (ООО, кинотеатры)
- 9 сентября — День тестировщиков!
- «Лаборатория качества»: концентрация и распределение в одном месте.
- Пример открытости, которой недостаточно для наших компаний
- Состояние книги «Тестовый дизайн»: Редактирование начато!
- Tester’s BAG — Таблица для принятия решений
- Заметки о коленях: о тестировании (Основы для разработчиков)
Что пишут в блогах (EN)
- Мы предлагаем открытый курс холистического дистанционного тестирования с 5 по 9 декабря!
- Для меня новые идеи от Targeting Quality 2022!
- Что нового в редакторе: больше инструментов для рисования, улучшенные списки, более удобное переключение между блоками
- NIMA Мастер-курс Agile Marketing Transformation
- Как уменьшить количество тестов во время тестирования
- Как уменьшить количество тестовых случаев, чтобы уменьшить количество тестовых случаев
- Присоединяйтесь к виртуальному «Бережливому кофе» AST (21 сентября 2022 года).
- Подходы к контрактному тестированию
- Политика календарных разрывов
- Отчет о наборе персонала TestBash — 2022
Оригинал статьи Энди Найта
В этой статье рассказывается о том, как лучше всего использовать «самые важные» функции Python.
Python — это язык сценариев: все строки в «модуле» Python (файл .py) выполняются каждый раз при запуске этого файла. Модули не нуждаются в главной функции. Предположим, у нас есть модуль stuff.py с таким кодом:
Вот результат после запуска:
Функция print_ stuff была вызвана как обычная строка кода, а не в функции. Когда модуль был запущен, строка была выполнена.
Однако это вызывает проблему при импорте материала из другого модуля. Предположим, у нас есть второй модуль more_stuff.py :
На первый взгляд, вы ожидаете получить две строки вывода. Однако, когда вы запускаете more_stuff, выдается три строки:
Почему предложение «Что-то случилось!» напечатано дважды? Когда вызывалась команда «import stuff», загружался модуль stuff. Когда модуль загружен, выполняется весь его код. Функция print_ stuff была вызвана в строке 4 модуля stuff. Затем он был вызван снова в строке 3 модуля more_ stuff.
Как можно избежать этой проблемы? Просто: Проверьте __name__ модуля. Переменная __name__ .(произносится как «имя дандера») динамически устанавливается как имя модуля. Если модуль является основной точкой входа, то __name__. устанавливается как «__main__». В противном случае, если модуль только импортируется, он устанавливается как имя файла модуля без расширения .py.
Давайте перепишем наши модули. Вот материал:
Если __name__ == ‘__main__’:
А вот еще_вещи:
Если __name__ == ‘__main__’:
Если мы перезапустим more_ stuff, строка «stuff happened!» появится только один раз:
Хорошая практика при программировании модулей Python: они не должны содержать непосредственно вызываемых буквенно-цифровых символов. Они должны содержать только функции, классы и инициализационные переменные. Все, что выполняется как тело «main», должно выполняться после проверки на «if __name__ == ‘__main__'». В этом случае не возникнет посторонних вызовов, если модуль импортируется из другого модуля. Условная проверка на __name__ также делает тело «main» более понятным для читателя.
Некоторые люди любят иметь функцию «main» в любом случае. Хорошо, сделайте это так:
Другие объектно-ориентированные языки определяют функцию main() как точку входа в программу. В этом случае интерпретатор неявно вызывает функцию main(), без которой ваша программа не будет работать.
Лучший путь
Переменная __name__ задает пространство имен, в котором находится интерпретатор Python.
Внутри импортированного модуля находится имя модуля.
Но внутри главного модуля (или интерактивной сессии Python, т.е. read, Eval, Print Loop или интерпретатора REPL) вы запускаете все из «__main__» .
Поэтому если вы проверите перед выполнением:
Исходя из вышесказанного, ваш код будет выполняться, только если вы запустите его как основной модуль (или если вы намеренно вызовете его из другого скрипта).
Еще лучший путь
Однако есть способ улучшить это с помощью Python.
Что если мы хотим запустить этот бизнес-процесс извне модуля?
Если мы поместим код, который мы хотим использовать для разработки и тестирования, в функцию, подобную этой, а затем сразу после этого выполним проверку для ‘__main__’:
Теперь у нас есть заключительная функция для конца нашего модуля, которая работает, когда мы запускаем модуль в качестве основного модуля.
Это позволяет нам вставлять модуль и его функции и классы в другие скрипты без выполнения главной функции, и мы можем вызывать модуль (и его функции и классы), когда он выполняется другим скриптом <
Этот модуль представляет (иначе анонимную) среду, в которой работает основная программа интерпретатора — команды, считываемые либо со стандартного ввода, либо из файла сценария, либо из интерактивного приглашения. В этой среде идиоматический модуль «Условный сценарий» запускает сценарий:
Что делает if __name__ == «__main__»: ?
__name__ — это глобальная переменная (в Python глобальная переменная фактически означает на уровне модуля), которая существует во всех пространствах имен и обычно является именем модуля (типа str ).
Как одноразовый специальный случай в любом запущенном процессе Python, например, в mycode.py:
В противном случае анонимное глобальное пространство имен принимает значение «__main__» в __name__.
Итак, включая последние строки
- в конце сценария mycode.py,
- если это основной модуль входа, выполняемый процессом Python,
Это выполнит единственную главную функцию вашего скрипта.
Еще одно преимущество этой конструкции: вы можете вставить свой код в качестве модуля в другой сценарий, а затем выполнить главную функцию, если этого захочет ваша программа:
