Функции __name__ и __main__ в Python, запуск кода для начинающих
Предыдущий урок: Namedtuple
В различных руководствах по Python часто используется функция main()
. Но иногда это может быть и лишним.
Лаконичность — важный элемент программирования. И вполне логично задавать вопрос о том, зачем разработчику добавлять лишние строки в программу. Функция main()
требует дополнительных строк, но она служит определенной цели.
В этом материале речь пойдет о функции main()
, о том, какую пользу она приносит, а также о том, как правильно использовать ее в коде.
Что такое функция main()?
Main — это специальная функция, которая позволяет добавить больше логики в структуру программ. В Python можно вызвать функцию в нижней части программы, которая и будет запущена. Рассмотрим такой пример:
Копировать Скопировано Use a different Browser
def cookies():
print("Печенье вкусное!")print("Дайте печенье. ")
cookies()
Запустим этот код:
Дайте печенье. Печенье вкусное!
Можно увидеть, что выражение «Дайте печенье.» выводится до «Печенье вкусное!», потому что метод cookies()
не вызывается вплоть до последней строки, а именно в этой функции хранится предложение «Печенье вкусное!».
Такой код работает, но его довольно сложно читать. В таких языках программирования, как C++ и Java весь основной код программы хранится внутри основной функции. Это хороший способ для распределения всего кода программы. Те, кто только знакомится с Python, но уже работал, например, с C++ будут благодарны за использование функции
.
Как создать функцию main
Есть две части основной функции Python. Первая — сама функция main()
. В ней хранится код основной программы. Вызовем функцию cookies()
и выведем выражение «Дайте печенье.» из функции main()
:
Копировать Скопировано Use a different Browser
def cookies():
print("Печенье вкусное!")def main():
print("Дайте печенье. ")
cookies()
Теперь вызовем функцию в конце программы:
Копировать Скопировано Use a different Browser
main()
Можно запустить код:
Дайте печенье. Печенье вкусное!
Результат не поменялся. Но теперь сам код читать легче. Пусть в нем и больше строк (и одна дополнительная строка), вполне очевидно, что именно происходит:
Cookies()
— функция, которая выводит «Печенье вкусное!».- Когда программа запускается, определяются две функции:
cookies()
иmain()
. - Затем функция
main()
вызывается. - «Дайте печенье.» выводится в консоли.
- Затем вызывается функция
cookies()
, которая выводит в консоль «Печенье вкусное!».
Код не только чище, но и логичнее. Если вы пришли из другого языка, например, Java, но знаете, насколько это удобно.
Значение __name__
Прежде чем переходить к инструкциям __name__
и __main__
, которые часто используются вместе, нужно обсудить __name__
. __name__
хранит название программы.
Если запустить файл прямо, то значением __name__
будет __main__
. Предположим, что файл называется print_name.py
:
Копировать Скопировано Use a different Browser
print(__name__)
Этот код можно запустить следующим образом:
$ python print_name.py
Он вернет __main__
.
Предположим, что этот код был импортирован в качестве модуля в файл main.py
:
Копировать Скопировано Use a different Browser
import print_name
Запустим его:
$ python main.py
Код вернет:
print_name
Код внутри print_name.py
исполняется потому что он был импортирован в качестве модуля в основной программе. Файл print_name
выводит __name__
в консоль. Поскольку print_name
был импортирован в качестве модуля, то и значением __name__
является print_name
.
if __name__ == __main__ в Python
Вы наверняка встречали следующую конструкцию в программах на Python в функции main
:
Копировать Скопировано Use a different Browser
if __name__ == "__main__":
Что она значит? В Python любая переменная, начинающаяся с двух символов нижнего подчеркивания (__
), является специальной. Это зарезервированные значения, которые выполняют определенную роль в программе.
__main__
указывает на область видимости, где будет выполняться код. Если запустить Python-файл прямо, то значением __name__
будет __main__
. Если же его запустить в качестве модуля, то значением будет уже не __main__
, а название модуля.
Это значит, что строка выше вернет True
только в том случае, если программа будет запущена прямо.
Если же ссылаться на файл как на модуль, то содержимое конструкции if не будет выполнено. Рассмотрим на примере.
Как использовать __name__ и __main__
Создадим новый скрипт на Python под названием username.py.
В коде будем просить пользователя ввести его имя и проверять, не является ли его длина больше 5. Если символов не больше 5, то попросим ввести имя снова.
Начнем с определения глобальной переменной для хранения имени пользователя:
Копировать Скопировано Use a different Browser
username = ""
После этого определим две функции. Первая будет просить пользователя ввести имя пользователя и проверять, не больше ли 5 символов в нем. Вторая будет выводить значение в оболочке Python:
Копировать Скопировано Use a different Browser
def choose_username():
global username
username = input("Введите логин: ")
if len(username) > 5:
print("Ваш логин сохранен.")
else:
print("Пожалуйста, выберите имя пользователя длиной более пяти символов.")
choose_username()def print_username():
print(username)
В этом примере использовалось ключевое слово global
, чтобы содержимое, присвоенное в методе choose_username()
, было доступно глобально. После определения функций нужно создать
, которая и будет их вызывать:
Копировать Скопировано Use a different Browser
def main():
choose_username()
print_username()
После этого нужно добавить if __name__="__main__"
в инструкцию if
. Это значит, что при запуске файла прямо, интерпретатор Python исполнит две функции. Если же запустить код в качестве модуля, то содержимое внутри main()
исполнено не будет.
Копировать Скопировано Use a different Browser
if __name__ == "__main__":
main()
Запустим код:
$ python username.py
Он вернет следующее:
Введите логин: mylogin Ваш логин сохранен. mylogin
Этот код запускает функцию choose_username()
, а затем — print_username()
. Если указать имя длиной меньше 4 символов, то ответ будет таким:
Введите логин: Li Ваш логин сохранен. Пожалуйста, выберите имя пользователя длиной более пяти символов. Введите логин:
Будет предложено ввести другое имя. Если импортировать этот код в качестве модуля, то функция main()
не запустится.
Выводы
Функция main()
используется для разделения блоков кода в программе. Использование функции main()
обязательно в таких языках, как Java, потому что это упрощает понимание того, в каком порядке код запускается в программе. В Python функцию main()
писать необязательно, но это улучшает читаемость кода.
Далее: Функция zip()
Основная функция в Python и метод main(): описание с примерами
Главная » Основы
0
Что такое основная функция в Python?
Основная функция в Python – это точка входа в любую программу. Но интерпретатор последовательно выполняет код исходного файла и не вызывает никаких методов, если он не является частью кода. Но если это непосредственно часть кода, то она будет выполнена при импорте файла, как модуля.
Вот почему существует специальный метод определения основного метода в программе Python, чтобы он выполнялся только тогда, когда программа запускается напрямую, а не выполняется при импорте, как модуль. Давайте посмотрим, как определить основную функцию в простой программе.
print("Hello") print("__name__ value: ", __name__) def main(): print("python main function") if __name__ == '__main__': main()
- Когда программа python выполняется, интерпретатор начинает выполнять код внутри нее. Он также устанавливает несколько неявных значений переменных, одно из них __name__, значение которого установлено как __main__.
- Для основной функции мы должны определить функцию, а затем использовать условие if __name__ == ‘__main__’ для выполнения этой функции.
- Если исходный файл импортируется как модуль, интерпретатор python устанавливает значение __name__ для имени модуля, поэтому условие if вернет false и основной метод не будет выполняться.
- Python предоставляет нам гибкость, позволяющую сохранить любое имя для основного метода, однако лучше всего называть его методом main(). Код ниже вполне подходит, но не рекомендуется.
def main1(): print("python main function") if __name__ == '__main__': main1()
На изображении ниже показан результат, когда python_main_function.py выполняется как исходный файл.
Основная функция, как модуль
Теперь давайте используем указанный выше исходный файл Python в качестве модуля и импортируем его в другую программу python_import.py.
import python_main_function print("Done")
Теперь, когда выполняется вышеуказанная программа, производится вывод ниже.
Hello __name__ value: python_main_function Done
Обратите внимание, что первые две строки печатаются из исходного файла python_main_function.py. Обратите внимание, что значение __name__ отличается, и, следовательно, основной метод не выполняется.
Операторы программы python выполняются построчно, поэтому важно определить метод main() сначала перед условием if для выполнения основного метода. В противном случае вы получите ошибку, так как NameError: имя ‘main’ не определено.
Рейтинг
( 1 оценка, среднее 5 из 5 )
Васильев А.Н. / автор статьи
Помогаю в изучении Питона на примерах. Автор практических задач с детальным разбором их решений.
Загрузка . ..
Определение основных функций в Python — Real Python
Смотреть сейчас Это руководство содержит соответствующий видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание: Определение основных функций в Python
Многие языки программирования имеют специальную функцию, которая автоматически выполняется, когда операционная система запускает программу. Эта функция обычно называется
и должна иметь определенный тип возвращаемого значения и аргументы в соответствии со стандартом языка. С другой стороны, интерпретатор Python выполняет сценарии, начиная с верхней части файла, и Python не выполняет никаких определенных функций автоматически.
Тем не менее, наличие определенной начальной точки для выполнения программы полезно для понимания того, как она работает. Программисты Python придумали несколько соглашений для определения этой отправной точки.
К концу этой статьи вы поймете:
- Что такое специальная переменная
__name__
и как Python ее определяет - Почему вы хотите использовать
main()
в Python - Какие соглашения существуют для определения
main()
в Python - Каковы наилучшие методы для того, какой код поместить в ваш
main()
Базовый Python main()
В некоторых сценариях Python вы можете увидеть определение функции и условный оператор, похожий на пример ниже:
по умолчанию main(): print("Привет, мир!") если __name__ == "__main__": основной()
В этом коде есть функция с именем main()
, которая печатает фразу Hello World!
, когда его выполняет интерпретатор Python. Существует также условный (или , если
) оператор, который проверяет значение __name__
и сравнивает его со строкой "__main__"
. Когда оператор if
оценивается как True
, интерпретатор Python выполняет main()
. Вы можете узнать больше об условных операторах в Условных операторах в Python.
Этот шаблон кода довольно часто встречается в файлах Python, которые вы хотите изменить.0004 выполняется как скрипт , а импортируется в другой модуль . Чтобы понять, как будет выполняться этот код, вы должны сначала понять, как интерпретатор Python устанавливает __name__
в зависимости от того, как выполняется код.
Удалить рекламу
Режимы выполнения в Python
Существует два основных способа указать интерпретатору Python выполнить или использовать код:
- Вы можете выполнить файл Python как скрипт с помощью командной строки.
- Вы можете импортировать код из одного файла Python в другой файл или в интерактивный интерпретатор.
Подробнее об этих подходах можно прочитать в разделе Как запускать сценарии Python. Независимо от того, какой способ запуска вашего кода вы используете, Python определяет специальную переменную с именем __name__
, которая содержит строку, значение которой зависит от того, как используется код.
Мы будем использовать этот пример файла, сохраненный как execute_methods.py
, чтобы изучить, как поведение кода меняется в зависимости от контекста:
print("Это мой файл для тестирования методов выполнения Python.") print("Переменная __name__ сообщает мне, в каком контексте работает этот файл.") print("Значение __name__ равно:", repr(__name__))
В этом файле определены три вызова print()
. Первые два печатают вводные фразы. Третий print()
сначала напечатает фразу Значение __name__ равно
, а затем будет напечатано представление переменной __name__
с использованием встроенной функции Python repr()
.
В Python repr()
отображает печатное представление объекта. В этом примере используется repr()
, чтобы подчеркнуть, что значение __name__
является строкой. Вы можете прочитать больше о repr()
в документации Python.
Вы увидите слова файл , модуль и скрипт , используемый в этой статье. Практически особой разницы между ними нет. Однако есть небольшие различия в значении, которые подчеркивают назначение фрагмента кода:
.Файл: Как правило, файл Python — это любой файл, содержащий код. Большинство файлов Python имеют расширение
.py
.Сценарий: Сценарий Python — это файл, который вы собираетесь запускать из командной строки для выполнения задачи.
Модуль: Модуль Python — это файл, который вы собираетесь импортировать из другого модуля или скрипта или из интерактивного интерпретатора. Вы можете узнать больше о модулях в Python Modules and Packages — An Introduction.
Это различие также обсуждается в разделе Как запускать сценарии Python.
Выполнение из командной строки
В этом подходе вы хотите выполнить свой скрипт Python из командной строки.
При выполнении скрипта вы не сможете интерактивно определить код, который выполняет интерпретатор Python. Подробности того, как вы можете запускать Python из командной строки, не так важны для целей этой статьи, но вы можете развернуть поле ниже, чтобы узнать больше о различиях между командной строкой в Windows, Linux и macOS.
Способ, которым вы указываете компьютеру выполнять код из командной строки, немного отличается в зависимости от вашей операционной системы.
В Linux и macOS командная строка обычно выглядит так, как показано в примере ниже:
eleanor@realpython:~/Documents$
Часть перед знаком доллара ( $
) может выглядеть по-разному в зависимости от вашего имени пользователя и имени вашего компьютера. Команды, которые вы вводите, будут идти после $
. В Linux или macOS имя исполняемого файла Python 3 — python3
, поэтому вы должны запускать скрипты Python, набрав python3 script_name.py
после $
.
В Windows командная строка обычно выглядит так, как показано в примере ниже:
C:\Users\Eleanor\Documents>
Часть перед >
может выглядеть по-разному, в зависимости от вашего имени пользователя. Команды, которые вы вводите, будут идти после >
. В Windows имя исполняемого файла Python 3 обычно python
, поэтому вам следует запускать скрипты Python, введя python script_name.py
после >
.
Независимо от вашей операционной системы выходные данные сценариев Python, которые вы используете в этой статье, будут одинаковыми, поэтому в этой статье показан только стиль ввода для Linux и macOS, а строка ввода будет начинаться с $.
.
Теперь вы должны выполнить скрипт execute_methods.py
из командной строки, как показано ниже:
$ python3 execute_methods.py Это мой файл для проверки методов выполнения Python. Переменная __name__ сообщает мне, в каком контексте работает этот файл. Значение __name__: '__main__'
В этом примере вы можете видеть, что __name__
имеет значение '__main__'
, где символы кавычек ( '
) говорят вам, что значение имеет строковый тип.
Помните, что в Python нет разницы между строками, определенными в одинарных кавычках ( '
) и в двойных кавычках ( "
). Вы можете узнать больше об определении строк в Базовых типах данных в Python.
Вы получите идентичный результат, если включите в сценарий строку shebang и выполните ее напрямую ( ./execution_methods.py
), или используйте магию %run
в IPython или Jupyter Notebooks.
Вы также можете увидеть сценарии Python, выполняемые из пакетов, добавив в команду аргумент -m
. Чаще всего это рекомендуется при использовании pip
: python3 -m pip install package_name
.
Добавление аргумента -m
запускает код в модуле __main__.py
пакета. Вы можете найти больше информации о __main__.py
в разделе Как опубликовать пакет Python с открытым исходным кодом в PyPI.
Во всех трех случаях __name__
имеет одно и то же значение: строка '__main__'
.
Техническая деталь: Документация Python конкретно определяет, когда __name__
будет иметь значение '__main__'
:
__name__
модуля устанавливается равным'__main__'
при чтении из стандартного ввода, сценария или интерактивной подсказки. (Источник)
__name__
хранится в глобальном пространстве имен модуля вместе с __doc__
, __package__
и другими атрибутами. Подробнее об этих атрибутах можно прочитать в документации по модели данных Python и, особенно для модулей и пакетов, в документации по импорту Python.
Удаление рекламы
Импорт в модуль или интерактивный интерпретатор
Теперь давайте рассмотрим второй способ, которым интерпретатор Python будет выполнять ваш код: импорт. Когда вы разрабатываете модуль или сценарий, вы, скорее всего, захотите воспользоваться модулями, которые уже созданы кем-то другим, что вы можете сделать с помощью импорт ключевого слова
.
Во время процесса импорта Python выполняет операторы, определенные в указанном модуле (но только в первый раз, когда вы импортируете модуль). Чтобы продемонстрировать результаты импорта файла execute_methods.py
, запустите интерактивный интерпретатор Python, а затем импортируйте файл execute_methods.py
:
>>>
>>> импортировать методы выполнения Это мой файл для проверки методов выполнения Python. Переменная __name__ сообщает мне, в каком контексте работает этот файл. Значение __name__: 'execution_methods'
В этом выводе кода видно, что интерпретатор Python выполняет три вызова print()
. Первые две строки вывода точно такие же, как при выполнении файла как скрипта в командной строке, потому что ни в одной из первых двух строк нет переменных. Однако есть разница в выводе третьего print()
.
Когда интерпретатор Python импортирует код, значение __name__
устанавливается равным имени импортируемого модуля. Вы можете увидеть это в третьей строке вывода выше. __name__
имеет значение 'execution_methods'
, которое является именем файла .py
, из которого Python импортирует.
Обратите внимание, что если вы импортируете
модуль снова, не выходя из Python, вывода не будет.
Лучшие практики для основных функций Python
Теперь, когда вы видите различия в том, как Python обрабатывает различные режимы выполнения, вам будет полезно узнать о некоторых передовых практиках. Они будут применяться всякий раз, когда вы хотите написать код, который можно запускать как сценарий 9.0274 и импортируются в другой модуль или интерактивный сеанс.
Вы узнаете о четырех передовых методах, чтобы убедиться, что ваш код может служить двойной цели:
- Поместите большую часть кода в функцию или класс.
- Используйте
__name__
для управления выполнением вашего кода. - Создайте функцию с именем
main()
, содержащую код, который вы хотите запустить. - Вызов других функций из
main()
.
Поместите большую часть кода в функцию или класс
Помните, что интерпретатор Python выполняет весь код в модуле, когда он импортирует модуль. Иногда код, который вы пишете, будет иметь побочные эффекты, которые вы хотите, чтобы пользователь контролировал, например:
- Выполнение вычисления, которое занимает много времени
- Запись в файл на диск
- Печать информации, которая загромождает терминал пользователя
В этих случаях вы хотите, чтобы пользователь управлял запуском выполнения этого кода, а не позволял интерпретатору Python выполнять код при импорте вашего модуля.
Таким образом, наилучшей практикой является включение большей части кода внутри функции или класса . Это связано с тем, что когда интерпретатор Python встречает ключевые слова def
или class
, он только сохраняет эти определения для последующего использования и фактически не выполняет их, пока вы не сообщите ему об этом.
Сохраните приведенный ниже код в файл с именем best_practices.py
, чтобы продемонстрировать эту идею:
1из времени импорта сна 2 3print("Это мой файл для демонстрации лучших практик.") 4 5def process_data (данные): 6 print("Начало обработки данных...") 7 модифицированные_данные = данные + "которые были изменены" 8 сна(3) 9print("Обработка данных завершена.") 10 вернуть модифицированные_данные
В этом коде вы сначала импортируете sleep()
из модуля time
.
sleep()
приостанавливает интерпретатор на то количество секунд, которое вы укажете в качестве аргумента, и создаст функцию, выполнение которой занимает много времени для этого примера. Затем вы используете print()
для вывода предложения, описывающего цель этого кода.
Затем вы определяете функцию с именем process_data()
, который делает пять вещей:
- Выводит некоторый вывод, чтобы сообщить пользователю, что обработка данных начинается
- Изменяет входные данные
- Приостанавливает выполнение на три секунды, используя
sleep()
- Выводит некоторый вывод, чтобы сообщить пользователю, что обработка завершена
- Возвращает измененные данные
Выполнение файла рекомендаций в командной строке
Что произойдет, если вы запустите этот файл как скрипт в командной строке?
Интерпретатор Python выполнит строки from time import sleep
и print()
, которые находятся за пределами определения функции, затем создаст определение функции с именем process_data()
. Затем скрипт завершится, ничего не делая, потому что в скрипте нет кода, выполняющего process_data()
.
Блок кода ниже показывает результат запуска этого файла как скрипта:
$ python3 best_practices.py Это мой файл для демонстрации лучших практик.
Вывод, который мы видим здесь, является результатом первого print()
. Обратите внимание, что импорт из времени
и определение process_data()
не приводит к результату. В частности, выходные данные вызовов print()
, которые находятся внутри определения process_data()
, не печатаются!
Импорт файла рекомендаций в другой модуль или интерактивный интерпретатор
Когда вы импортируете этот файл в интерактивный сеанс (или другой модуль), интерпретатор Python выполнит точно такие же шаги, как и при выполнении файла как скрипта.
После того, как интерпретатор Python импортирует файл, вы можете использовать любые переменные, классы или функции, определенные в импортированном вами модуле. Чтобы продемонстрировать это, мы будем использовать интерактивный интерпретатор Python. Запустите интерактивный интерпретатор и введите import best_practices
:
>>>
>>> импортировать лучшие_практики Это мой файл для демонстрации лучших практик.
Единственный результат импорта best_practices.py
файл из первого вызова print()
, определенного вне process_data()
. Импорт из времени
и определение process_data()
не приводит к выводу, как и при выполнении кода из командной строки.
Удалить рекламу
Использовать
, если __name__ == "__main__"
для управления выполнением вашего кода Что делать, если вы хотите, чтобы process_data()
выполнялся при запуске сценария из командной строки, но не при импорте файла интерпретатором Python?
Вы можете использовать идиому if __name__ == "__main__"
для определения контекста выполнения и условно запускать process_data()
только тогда, когда __name__
равно "__main__"
. Добавьте приведенный ниже код в конец файла best_practices.py
:
11if __name__ == "__main__": 12 data = "Мои данные считаны из Интернета" 13 печать (данные) 14 модифицированные_данные = данные_процесса(данные) 15 печать (модифицированные_данные)
В этом коде вы добавили условный оператор, который проверяет значение __name__
. Это условное выражение будет оцениваться как True
, когда __name__
равно строке "__main__"
. Помните, что специальное значение "__main__"
для переменной __name__
означает, что интерпретатор Python выполняет ваш скрипт, а не импортирует его.
Внутри условного блока вы добавили четыре строки кода (строки 12, 13, 14 и 15):
- Строки 12 и 13: Вы создаете переменную
data
, которая хранит данные, полученные из Интернета, и распечатываете их. - Строка 14: Вы обрабатываете данные.
- Строка 15: Вы печатаете измененные данные.
Теперь запустите сценарий best_practices.py
из командной строки, чтобы посмотреть, как изменится вывод:
$ python3 best_practices.py Это мой файл для демонстрации лучших практик. Мои данные считываются из Интернета Начало обработки данных... Обработка данных завершена. Мои данные, прочитанные из Интернета, которые были изменены
Во-первых, выходные данные показывают результат вызова print()
за пределами process_data()
.
После этого печатается значение data
. Это произошло из-за того, что переменная __name__
имеет значение "__main__"
, когда интерпретатор Python выполняет файл как скрипт, поэтому условное выражение оценивается как True
.
Затем ваш скрипт вызвал process_data()
и передал data
в для модификации. Когда выполняется process_data()
, он выводит на выход некоторые сообщения о состоянии. Наконец, печатается значение modified_data
.
Теперь вы должны проверить, что происходит, когда вы импортируете файл best_practices.py
из интерактивного интерпретатора (или другого модуля). Пример ниже демонстрирует эту ситуацию:
>>>
>>> импортировать лучшие_практики Это мой файл для демонстрации лучших практик.
Обратите внимание, что вы получаете то же поведение, что и до добавления условного оператора в конец файла! Это связано с тем, что переменная __name__
имела значение "best_practices"
, поэтому Python не выполнял код внутри блока, включая process_data()
, поскольку условный оператор оценен как False
.
Создайте функцию с именем main(), содержащую код, который вы хотите запустить
Теперь вы можете писать код Python, который можно запускать из командной строки в виде скрипта и импортировать без нежелательных побочных эффектов. Далее вы узнаете, как писать свой код, чтобы другим программистам Python было легко понять, что вы имеете в виду.
Многие языки, такие как C, C++, Java и некоторые другие, определяют специальную функцию, которая должна вызываться main()
и которую операционная система автоматически вызывает при выполнении скомпилированной программы. Эту функцию часто называют точкой входа , потому что именно здесь выполнение входит в программу.
Напротив, в Python нет специальной функции, которая служит точкой входа в сценарий. На самом деле вы можете дать функции точки входа в скрипте Python любое имя!
Хотя Python не придает никакого значения функции с именем main()
, в любом случае лучше всего назвать функцию точки входа main()
. Таким образом, любые другие программисты, прочитавшие ваш сценарий, сразу узнают, что эта функция является отправной точкой кода, выполняющего основную задачу сценария.
Кроме того, main()
должен содержать любой код, который вы хотите запустить, когда интерпретатор Python выполняет файл. Это лучше, чем помещать код непосредственно в условный блок, потому что пользователь может повторно использовать main()
, если они импортируют ваш модуль.
Измените файл best_practices.py
, чтобы он выглядел так, как показано ниже:
1из времени импорта сна 2 3print("Это мой файл для демонстрации лучших практик.") 4 5def process_data (данные): 6 print("Начало обработки данных...") 7 модифицированные_данные = данные + "которые были изменены" 8 сна(3) 9 print("Обработка данных завершена.") 10 вернуть модифицированные_данные 11 12def основной(): 13 data = "Мои данные считаны из Интернета" 14 печать (данные) 15 модифицированные_данные = данные_процесса(данные) 16 печать (модифицированные_данные) 17 18if __name__ == "__main__": 19основной()
В этом примере вы добавили определение main()
, которое включает код, ранее находившийся внутри условного блока. Затем вы изменили условный блок, чтобы он выполнял main()
. Если вы запустите этот код как скрипт или импортируете его, вы получите тот же результат, что и в предыдущем разделе.
Удалить рекламу
Вызов других функций из main()
Еще одна распространенная практика в Python: иметь main()
выполнять другие функции вместо включения кода выполнения задачи в main()
. Это особенно полезно, когда вы можете составить свою общую задачу из нескольких небольших подзадач, которые могут выполняться независимо.
Например, у вас может быть сценарий, который делает следующее:
- Считывает файл данных из источника, которым может быть база данных, файл на диске или веб-API
- Обрабатывает данные
- Записывает обработанные данные в другое место
Если вы реализуете каждую из этих подзадач в отдельных функциях, то вам (или другому пользователю) будет легко повторно использовать несколько шагов и игнорировать те, которые вам не нужны. Затем вы можете создать рабочий процесс по умолчанию в main()
и получить лучшее из обоих миров.
Решение о том, следует ли применять эту практику к вашему коду, зависит от вас. Разделение работы на несколько функций упрощает повторное использование, но увеличивает трудности для кого-то другого, пытающегося интерпретировать ваш код, поскольку им приходится следовать нескольким переходам в потоке программы.
Измените файл best_practices.py
, чтобы он выглядел так, как показано ниже:
1из времени импорта сна 2 3print("Это мой файл для демонстрации лучших практик.") 4 5def process_data (данные): 6 print("Начало обработки данных...") 7 модифицированные_данные = данные + "которые были изменены" 8 сна(3) 9 print("Обработка данных завершена.") 10 вернуть модифицированные_данные 11 12def read_data_from_web(): 13 print("Чтение данных из Интернета") 14 data = "Данные из Интернета" 15 возврат данных 16 17def write_data_to_database(данные): 18 print("Запись данных в базу данных") 19печать (данные) 20 21def основная(): 22 данные = read_data_from_web() 23 модифицированные_данные = данные_процесса(данные) 24 write_data_to_database(измененные_данные) 25 26if __name__ == "__main__": 27 основной()
В этом примере кода первые 10 строк файла имеют то же содержимое, что и раньше. Второе определение функции в строке 12 создает и возвращает некоторые образцы данных, а третье определение функции в строке 17 имитирует запись измененных данных в базу данных.
На линии 21, main()
определен. В этом примере вы изменили main()
так, чтобы он по очереди вызывал функции чтения, обработки и записи данных.
Во-первых, данные
создаются из read_data_from_web()
. Эти данные
передаются в process_data()
, который возвращает modified_data
. Наконец, modified_data
передается в write_data_to_database()
.
Последние две строки скрипта — условный блок, проверяющий __name__
и запускает main()
если оператор if
равен True
.
Теперь вы можете запустить весь конвейер обработки из командной строки, как показано ниже:
$ python3 best_practices.py Это мой файл для демонстрации лучших практик. Чтение данных из Интернета Начало обработки данных... Обработка данных завершена. Запись обработанных данных в базу данных Данные из Интернета, которые были изменены
В выводе этого выполнения вы можете видеть, что интерпретатор Python выполнил main()
, который выполнил read_data_from_web()
, process_data()
и write_data_to_database()
. Однако вы также можете импортировать файл best_practices.py
и повторно использовать process_data()
для другого источника входных данных, как показано ниже:
>>>
>>> импортировать best_practices как bp Это мой файл для демонстрации лучших практик. >>> data = "Данные из файла" >>> модифицированные_данные = bp.process_data(данные) Начало обработки данных... Обработка данных завершена. >>> bp.write_data_to_database(modified_data) Запись обработанных данных в базу данных Данные из файла, который был изменен
В этом примере вы импортировали best_practices
и сократили имя до bp
для этого кода.
В процессе импорта интерпретатор Python выполнил все строки кода в файле best_practices.py
, поэтому в выходных данных отображается строка, объясняющая назначение файла.
Затем вы сохранили данные из файла в данных
вместо чтения данных из Интернета. Затем вы повторно использовали process_data()
и write_data_to_database()
из файла best_practices.py
. В этом случае вы воспользовались преимуществом повторного использования кода вместо определения всей логики в main()
.
Сводка рекомендаций по основным функциям Python
Вот четыре ключевых передовых метода работы с main()
в Python, которые вы только что видели:
Поместите код, выполнение которого занимает много времени или оказывает другое влияние на компьютер, в функцию или класс, чтобы вы могли точно контролировать, когда этот код выполняется.
Используйте различные значения
__name__
, чтобы определить контекст и изменить поведение вашего кода с помощью условного оператора.Вы должны назвать функцию точки входа
main()
, чтобы сообщить о назначении функции, даже несмотря на то, что Python не придает особого значения функции с именемmain()
.Если вы хотите повторно использовать функциональность из своего кода, определите логику в функциях вне
main()
и вызывать эти функции в пределахmain()
.
Удалить рекламу
Заключение
Поздравляем! Теперь вы знаете, как создавать функции Python main()
.
Вы узнали следующее:
Знание значения переменной
__name__
важно для написания кода, который выполняет двойную функцию исполняемого скрипта и импортируемого модуля.__имя__
принимает разные значения в зависимости от того, как вы выполнили файл Python.__name__
будет равно:-
"__main__"
, когда файл выполняется из командной строки или с помощьюpython -m
(для выполнения файла пакета__main__. py
) - Имя модуля, если модуль импортируется
-
- Программисты Python разработали набор передовых практик, которые можно использовать, когда вы хотите разработать повторно используемый код.
Теперь вы готовы приступить к написанию потрясающего кода функции Python main()
!
Смотреть сейчас Это руководство содержит связанный с ним видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание: Определение основных функций в Python
Основная функция и метод Python Пример: понять def Main()
АвторSteve Campbell
ЧасовОбновлено
Что такое основная функция Python?
Основная функция Python является отправной точкой любой программы. Когда программа запускается, интерпретатор Python последовательно запускает код. Основная функция выполняется только тогда, когда она запускается как программа Python. Он не будет запускать основную функцию, если он импортирован как модуль.
Что такое функция def main() в Python? Чтобы понять это, рассмотрим следующий пример кода
def main() Пример 1
def main(): печать («Привет, мир!») печать ("Гуру99")
Здесь у нас есть две части вывода — одна определена в основной функции «Hello World!» а другой независимый, это «Guru99». При запуске функции def main():
- Только «Guru99» выводит
- , а не код «Hello World!»
Это потому, что мы не объявили вызов функции «if__name__== «__main__».
Важно, чтобы после определения основной функции вы вызывали код по if__name__== «__main__» и затем запускали код, только тогда вы получите вывод «hello world!» в консоли программирования. Рассмотрим следующий код
def main() Пример 2
def main(): print("Привет, мир!") если __name__ == "__main__": основной() печать("Гуру99")
Guru99 печатается в этом случае.
Вот объяснение,
- Когда интерпретатор Python читает исходный файл, он выполняет весь найденный в нем код.
- Когда Python запускает «исходный файл» в качестве основной программы, он устанавливает для специальной переменной (__name__) значение («__main__»).
- Когда вы выполняете основную функцию в python, она затем читает оператор «if» и проверяет, действительно ли __name__ равно __main__.
- В Python «if__name__== «__main__» позволяет запускать файлы Python либо как повторно используемые модули , либо как автономные программы.
Переменная __name__ и модуль Python
Чтобы понять важность переменной __name__ в методе основной функции Python, рассмотрим следующий код:
def main(): print("Привет, мир!") если __name__ == "__main__": основной() печать("Гуру99") print("Значение имени встроенной переменной: ",__name__)
Теперь рассмотрим, код импортируется как модуль
import MainFunction распечатать("сделано")
Вот расшифровка кода:
Как и C, Python использует == для сравнения, а = для присваивания.