Разное

Main python: Что такое функция main Python, и как она работает: примеры кода

Содержание

Что такое функция main Python, и как она работает: примеры кода

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

Рассмотрим следующий код:

def main():
print «hello world!»
print «Guru99»

def main():

     print «hello world!»

print «Guru99»

Здесь у нас есть два фрагмента на вывод, один из которых определен в функции main — «Hello World», а другой — «Guru99». Когда вы запускаете функцию def main():

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

Выводится только «Guru99″

а не код «Hello World».

Это потому, что мы не объявили функцию вызова «if__name __ ==» __main__».

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

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

Когда вы выполняете функцию main, она читает оператор «if» и проверяет, действительно ли __name__ равно __main__.

В Python «if__name __ ==« __main__ » позволяет запускать файлы Python как многократно используемые модули или как отдельные программы.

Как и C, Python использует == для сравнения, а = для назначения. Интерпретатор Python использует функцию main двумя способами:

импорт: __name __ = имя файла модуля — если оператор == false, скрипт в __main__ не будет выполнен

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

прямой запуск: __ name __ = __ main__ — если Statement == True, скрипт в _main_ будет выполнен

поэтому, когда код выполняется, он проверяет имя модуля с помощью «if».

Важно, чтобы после определения функции main вы вызывали код с помощью if__name __ == «__main__», а затем запускали код, только тогда вы получите вывод «hello world!» в консоли программирования, как показано ниже.

Примечание. Убедитесь, что после определения функции main вы задали некоторый отступ и не объявляете код прямо под функцией def main(): в противном случае она выдаст ошибку отступа.

def main():
print(«Hello World!»)

if __name__== «__main__»:
main()

print(«Guru99»)

def main():

  print(«Hello World!»)

  

if __name__== «__main__»:

  main()

 

print(«Guru99»)

Выше приведены примеры кода Python 3, если вы хотите использовать Python 2, пожалуйста, рассмотрите следующий код:

def main():
print «Hello World!»

if __name__== «__main__»:
main()

print «Guru99»

def main():

  print «Hello World!»

  

if __name__== «__main__»:

  main()

 

print «Guru99»

В Python 3 вам не нужно использовать if__name. Следующий код также работает:

def main():
print(«Hello World!»)

main()
print(«Guru99»)

def main():

  print(«Hello World!»)

  

main()

print(«Guru99»)

Источник: //www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

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

Получить курс

Функции __name__ и __main__ в Python, запуск кода для начинающих

Предыдущий урок: Namedtuple

В различных руководствах по Python часто используется функция main(). Но иногда это может быть и лишним.

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

В этом материале речь пойдет о функции main(), о том, какую пользу она приносит, а также о том, как правильно использовать ее в коде.

Что такое функция main()?

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


def cookies():
print("Печенье вкусное!")

print("Дайте печенье.")
cookies()

Запустим этот код:

Дайте печенье.
Печенье вкусное!

Можно увидеть, что выражение «Дайте печенье.» выводится до «Печенье вкусное!», потому что метод cookies() не вызывается вплоть до последней строки, а именно в этой функции хранится предложение «Печенье вкусное!».

Такой код работает, но его довольно сложно читать. В таких языках программирования, как C++ и Java весь основной код программы хранится внутри основной функции. Это хороший способ для распределения всего кода программы. Те, кто только знакомится с Python, но уже работал, например, с C++ будут благодарны за использование функции main().

Как создать функцию main

Есть две части основной функции Python. Первая — сама функция main(). В ней хранится код основной программы. Вызовем функцию cookies() и выведем выражение «Дайте печенье.» из функции main():


def cookies():
print("Печенье вкусное!")

def main():
print("Дайте печенье.")
cookies()

Теперь вызовем функцию в конце программы:

Можно запустить код:

Дайте печенье.
Печенье вкусное!

Результат не поменялся. Но теперь сам код читать легче. Пусть в нем и больше строк (и одна дополнительная строка), вполне очевидно, что именно происходит:

  • Cookies() — функция, которая выводит «Печенье вкусное!».
  • Когда программа запускается, определяются две функции: cookies() и main().
  • Затем функция main() вызывается.
  • «Дайте печенье.» выводится в консоли.
  • Затем вызывается функция cookies(), которая выводит в консоль «Печенье вкусное!».

Код не только чище, но и логичнее. Если вы пришли из другого языка, например, Java, но знаете, насколько это удобно.

Значение __name__

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

Если запустить файл прямо, то значением __name__ будет __main__. Предположим, что файл называется print_name.py:

Этот код можно запустить следующим образом:

$ python print_name.py

Он вернет __main__.

Предположим, что этот код был импортирован в качестве модуля в файл main. py:

Запустим его:

$ python main.py

Код вернет:

print_name

Код внутри print_name.py исполняется потому что он был импортирован в качестве модуля в основной программе. Файл print_name выводит __name__ в консоль. Поскольку print_name был импортирован в качестве модуля, то и значением __name__ является print_name.

if __name__ == __main__ в Python

Вы наверняка встречали следующую конструкцию в программах на Python в функции main:


if __name__ == "__main__":

Что она значит? В Python любая переменная, начинающаяся с двух символов нижнего подчеркивания (__), является специальной. Это зарезервированные значения, которые выполняют определенную роль в программе.

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

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

Если же ссылаться на файл как на модуль, то содержимое конструкции if не будет выполнено. Рассмотрим на примере.

Как использовать __name__ и __main__

Создадим новый скрипт на Python под названием username.py. В коде будем просить пользователя ввести его имя и проверять, не является ли его длина больше 5. Если символов не больше 5, то попросим ввести имя снова.

Начнем с определения глобальной переменной для хранения имени пользователя:

После этого определим две функции. Первая будет просить пользователя ввести имя пользователя и проверять, не больше ли 5 символов в нем. Вторая будет выводить значение в оболочке Python:


def choose_username():
global username
username = input("Введите логин: ")
if len(username) > 5:
print("Ваш логин сохранен. ")
else:
print("Пожалуйста, выберите имя пользователя длиной более пяти символов.")
choose_username()

def print_username():
print(username)

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


def main():
choose_username()
print_username()

После этого нужно добавить if __name__="__main__" в инструкцию if. Это значит, что при запуске файла прямо, интерпретатор Python исполнит две функции. Если же запустить код в качестве модуля, то содержимое внутри main() исполнено не будет.


if __name__ == "__main__":
main()

Запустим код:

$ python username. py

Он вернет следующее:

Введите логин: mylogin
Ваш логин сохранен.
mylogin

Этот код запускает функцию choose_username(), а затем — print_username(). Если указать имя длиной меньше 4 символов, то ответ будет таким:

Введите логин: Li
Ваш логин сохранен.
Пожалуйста, выберите имя пользователя длиной более пяти символов.
Введите логин:

Будет предложено ввести другое имя. Если импортировать этот код в качестве модуля, то функция main() не запустится.

Выводы

Функция main() используется для разделения блоков кода в программе. Использование функции main() обязательно в таких языках, как Java, потому что это упрощает понимание того, в каком порядке код запускается в программе. В Python функцию main() писать необязательно, но это улучшает читаемость кода.

Далее: Функция zip()

if __name__ == «__main__» — Документация Python для сетевых инженеров 3.

0

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

В предыдущем примере было два скрипта: check_ip_function.py и get_correct_ip.py.
И при запуске get_correct_ip.py, отображались print из check_ip_function.py.

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

Переменная __name__ — это специальная переменная, которая будет
равна "__main__", только если файл запускается как основная программа, и
выставляется равной имени модуля при импорте модуля.
То есть, условие if __name__ == '__main__' проверяет, был ли
файл запущен напрямую.

Как правило, в блок if __name__ == '__main__' заносят все вызовы функций
и вывод информации на стандартный поток вывода.
То есть, в скрипте check_ip_function.py в этом блоке будет все, кроме импорта
и функции return_correct_ip:

import ipaddress


def check_ip(ip):
    try:
        ipaddress.ip_address(ip)
        return True
    except ValueError as err:
        return False


if __name__ == '__main__':
    ip1 = '10.1.1.1'
    ip2 = '10.1.1'

    print('Проверка IP...')
    print(ip1, check_ip(ip1))
    print(ip2, check_ip(ip2))

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

$ python check_ip_function.py
Проверка IP...
10.1.1.1 True
10.1.1 False

При запуске скрипта check_ip_function.py напрямую, выполняются все строки,
так как переменная __name__ в этом случае равна '__main__'.

Скрипт get_correct_ip.py остается без изменений

from check_ip_function import check_ip


def return_correct_ip(ip_addresses):
    correct = []
    for ip in ip_addresses:
        if check_ip(ip):
            correct.append(ip)
    return correct


print('Проверка списка IP-адресов')
ip_list = ['10. 1.1.1', '8.8.8.8', '2.2.2']
correct = return_correct_ip(ip_list)
print(correct)

Выполнение скрипта get_correct_ip.py выглядит таким образом:

$ python get_correct_ip.py
Проверка списка IP-адресов
['10.1.1.1', '8.8.8.8']

Теперь вывод содержит только информацию из скрипта get_correct_ip.py.

В целом, лучше привыкнуть писать весь код, который вызывает функции и
выводит что-то на стандартный поток вывода, внутри блока
if __name__ == '__main__'.

Предупреждение

Начиная с 9 раздела, для заданий есть программные тесты,
с помощью которых можно проверить правильность выполнения заданий.
Для корректной работы с тестами, надо всегда писать вызов функции
в файле задания внутри блока if __name__ == '__main__'.
Отсутствие этого блока будет вызывать ошибки, не во всех заданиях,
однако это все равно позволит избежать проблем.

Функция «main» в Python

Автор: Энди Найт (Andy Knight)
Оригинал статьи
Перевод: Ольга Алифанова

Эта статья покажет вам наилучший способ обращения с Python-функциями «main».

Python похож на скриптовый язык: все строки в «модуле» Python (файле .py) выполняются всегда, когда этот файл запускается. Модулям не нужна функция main. Допустим, у нас есть модуль по имени stuff.py вот с каким кодом:


1

2

3

4

def print_stuff():

print(«stuff happened!»)


print_stuff()

Вот ее результат после запуска:


$ python stuff.py

stuff happened!

Функция print_stuff была вызвана как обычная строчка кода, а не в функции. Когда модуль был запущен, строчка была исполнена.

Однако это вызовет проблему, если stuff импортируется другим модулем. Допустим, у нас есть второй модуль по имени more_stuff.py:


1

2

3

4

import stuff


stuff.print_stuff()

print(«more stuff!»)

На первый взгляд мы ожидаем двух выведенных строк. Однако запуск more_stuff на самом деле выведет три строки:


$ python more_stuff.py

stuff happened!

stuff happened!

more stuff!

Почему строка “stuff happened!” выведена дважды? При вызове “import stuff” модуль stuff был загружен. Когда модуль загружается, выполняется весь его код. Функция print_stuff была вызвана в 4 строчке модуля stuff. Затем она была вызвана вновь в третьей строчке модуля more_stuff.

Как избежать этой проблемы? Легко: проверьте __name__ модуля. Переменная __name__.(произносится как «dunder name») динамически устанавливается как имя модуля. Если модуль – основная точка входа, то __name__. Будет задана как “__main__”. В прочих случаях, если модуль просто импортируется, она будет задана как имя файла модуля без расширения .py.

Давайте перепишем наши модули. Вот stuff:


1

2

3

4

5

def print_stuff():

print(«stuff happened!»)


if __name__ == ‘__main__’:

print_stuff()

А вот more_stuff:


1

2

3

4

5

import stuff


if __name__ == ‘__main__’:

stuff. print_stuff()

print(«more stuff!»)

Если мы перезапустим more_stuff, то строчка “stuff happened!” будет выведена только один раз:


$ python more_stuff.py

stuff happened!

more stuff!

Хорошая практика программирования модулей Python: они не должны содержать напрямую вызываемых строк. Они должны содержать только функции, классы, и инициализацию переменных. Все выполняемое как тело «main» должно выполняться после проверки на “if __name__ == ‘__main__’”. В этом случае при импортировании модуля другим модулем никаких инородных вызовов не произойдет. Условная проверка на __name__ также делает тело «main» понятнее для читателя.

Некоторым все равно нравится иметь функцию «main». Ну ок. Делайте это так:


1

2

3

4

5

6

7

8

import stuff


def main():

stuff. print_stuff()

print(«more stuff!»)


if __name__ == ‘__main__’:

main()

Чтобы узнать больше, прочитайте эту статью на Stack Overflow: What does if __name__ == “__main__”: do?

Обсудить в форуме

Зачем использовать def main ()? Ru Python

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

Все остальные уже ответили на это, но я думаю, что мне еще есть что добавить.

Причины иметь это утверждение if вызывающее main() (в определенном порядке):

  • Другие языки (например, C и Java) имеют функцию main() которая вызывается при выполнении программы. Используя это, if мы можем заставить Python вести себя так, как они, что кажется более знакомым для многих людей.

  • Код будет чище , легче читать и лучше организован. (да, я знаю, что это субъективно)

  • Можно будет import этот код python в виде модуля без неприятных побочных эффектов.

    • Это означает, что можно будет запускать тесты против этого кода.

    • Это означает, что мы можем импортировать этот код в интерактивную оболочку python и тестировать / отлаживать / запускать его.

  • Переменные внутри def main являются локальными , а внешние – глобальными . Это может привести к нескольким ошибкам и неожиданному поведению.

Но вам не требуется писать функцию main() и вызывать ее внутри оператора if .

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

Даже если вы помещаете код внутри основной функции, вам не нужно писать его точно так же. Оптимальным вариантом может быть:

 import sys def main(argv): # My code here pass if __name__ == "__main__": main(sys.argv) 

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

В объектно-ориентированном приложении, которое я написал, код выглядел так:

 class MyApplication(something): # My code here if __name__ == "__main__": app = MyApplication() app.run() 

Поэтому не стесняйтесь писать код, который вам больше подходит. 🙂

если содержание foo.py

 print __name__ if __name__ == '__main__': print 'XXXX' 

Файл foo. py можно использовать двумя способами.

  • импортировано в другой файл: import foo

В этом случае __name__ является foo , секция кода не выполняется и не печатает XXXX .

  • выполняется непосредственно: python foo.py

Когда он выполняется непосредственно, __name__ совпадает с __main__ и код в этом разделе выполняется и печатает XXXX

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

« Что делать, if __name__==“__main__”: do? » Уже был дан ответ.

Наличие функции main() позволяет вам вызывать ее функциональность, если вы import модуль. Основная (не предназначенная для каламбур) польза от этого (ИМХО) заключается в том, что вы можете его протестировать.

Python: __name__ == «__main__»

Вы видите это везде.

Если вы некоторое время программировали на Python или просто просматривали репозитории Python Github, вы, вероятно, натолкнулись на этот фрагмент кода.

if __name__ == '__main__':
  # do something

 

Он вездесущий.

Фактически, именно столько раз этот фрагмент кода появляется в Github!

18 миллионов + раз!

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

 

Что такое __name__?

__name__ – это просто встроенная переменная в Python, которая оценивает имя текущего модуля.

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

 

Пример 1

Давайте создадим простой скрипт Python в файле с именем test.py

# test.py
print("__name__ в test.py имеет значение " + __name__)

 

Эта строка будет выводить переменную __name__ на экране, чтобы мы могли ее изучить.

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

$ python test.py

 

Вот вывод, который вы увидите на экране.

$ python3 test.py
__name__ в test.py имеет значение __main__

 

Из этого можно сделать вывод, что в этом примере переменной __name__ было присвоено строковое значение __main__

Теперь давайте посмотрим на немного другой пример.

 

Пример 2

Давайте создадим новый файл test2.py  в том же каталоге, что и test.py

В этом новом файле давайте импортируем test, чтобы мы могли проверить переменную __name__ в test.py, а также напечатаем переменную __name__ в test2.py

# test2.py
import test

print("__name__ in test2.py имеет значение " + __name__)

 

Если вы запустите скрипт test2.py из терминала, это то, что вы увидите на своем экране.

$ python3 test2.py
__name__ in test.py имеет значение test
__name__ in test2. py имеет значение __main__

 

Хм, интересно, так что же происходит?

По сути, происходит то, что  __name__   устанавливается на уровне модуля.

Устанавливается на  имя  модуля. Другими словами, для каждого модуля в вашем коде, __name__ будет установлен на это имя модуля.

А для точки входа выполнения, основного сценария Python, переменная __name__будет установлена ​​в __main__

Это круто и все, но как эта специальная переменная используется на практике?

 

Как __name__ используется в реальных приложениях?

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

Например, давайте создадим фиктивный модуль hello.py, который другие смогут импортировать в свои собственные сценарии или могут напрямую выполнить его, если захотят.

Вот что должен делать этот модуль.

Если вы выполняете модуль напрямую, он должен напечатать Привет, AndreyEx на экране.

Но если вы вместо этого импортируете его, он может предоставить вам функцию hello(), где вы можете контролировать, кого приветствовать.

# hello.py
def hello(name):
  print(f"Привет, {name}!")

if __name__ == '__main__':
  hello('AndreyEx')

 

Теперь давайте создадим основной скрипт main.py, который будет импортировать модуль hello.

# main.py
from hello import hello

hello('Destroyer')

 

Как вы думаете, что произойдет, если мы напрямую запустим hello.py ?

Мы просто получаем Привет, AndreyEx! на экране, так как условие if внутри модуля hello будет выполнено!

$ python3 hello.py
Привет, AndreyEx!

 

Как насчет того, чтобы вместо этого мы выполним main.py?

Теперь мы получим только Привет, AndreyEx! напечатано на экране.

$ python3 main.py
Привет, Destroyer!

 

Но что, если мы не включили условие if __name__ == ‘main’ в модуль hello ?

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

$ python3 main.py
Привет, AndreyEx!
Привет, Destroyer!

 

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Python Developer. Basic | OTUS

В настоящий момент занимает должность Backend-разработчика на Python 3.6 в компании AdCombo. Стек используемых технологией включает Flask, SQLAlchemy, PostgreSQL, Redis, Docker и многое другое.

Начинал свою карьеру системным администратором в «АНТИвор», занимался оптимизацией рабочих процессов, сбором статистики и визуализацией аналитики. Затем перешел на должность Full Stack-программиста на Python и разрабатывал инструменты внутреннего пользования и web-интерфейсы для продукции компании.

Руководитель программы

Работает в одной из крупнейших телекоммуникационных компаний в Азербайджане.
Больше года опыта как инструктор, в том числе по Python для разных возрастных групп.
Технический ментор проекта развития для начинающих программистов в Google Developers Group.

Профессиональный опыт в разработке на Java, Spring Boot, Javascript, Python, HTML, CSS, React и многих окружающих их технологий, в том числе RabbitMQ, SQL с использованием таких СУБД, как Oracle, MySQL, PostgreSQL, MongoDB, SQLite, MS SQL.

На данный момент занимается разработкой микросервисов и изучает DevOps.

Интересы: алгоритмы, математика, машинное обучение.

Девиз по жизни: Наши возможности ограничены только нашей мотивацией и законами физики.

Преподаватель

Окончил МТУСИ — факультет «Информационные технологии», АМИ «Юридический факультет», ПКС «Радиоаппаратостроение»
Работает в GOST Group ведущим разработчиком Python
Интересуется IoT
Что касается проектов: Подсистема сбора данных для ДИТ Москвы (департамент информационных технологий),
Recommendme (recommendme.online) — система анализа и конечных рекомендаций google ads.
Система рекомендаций микро-кредитов MiSolvencia (misolvencia.es).

Преподаватель

Главный разработчик zval. ru.
Продолжает работать удаленно и заниматься собственными проектами на Python и Django.

Выпускник кафедры информационных технологий физического факультета ПГНИУ.
Начал карьеру в крупной международной компании Prognoz, создавал проекты для правительства РФ в течение 2 лет.

Работал программистом биллинга на oracle pl/sql в компании «Эр-Телеком Холдинг».

С 2014 года стал преподавателем направления python-разработки.

Преподаватель

Начинал в школе с паяльником в руках. Потом был ZX Spectrum. В университет пошел на техническую специальность. В механике много интересного, но в 2008 интерес к ИТ взял верх: компьютерные сети -> Delphi -> PHP -> Python.
Были эксперименты с другими языками, но хочется писать именно на нем. Участвовал в проектах по автоматизации бизнес-процессов при помощи нейросетей (сервис заказа такси «Максим»), разработке информационных систем в медицине. Работал с GIS-системами и процессингом изображений при помощи Python.
В преподавании позиция: «Если кто-то не может объяснить сложное простыми словами, — значит он в этом еще не очень хорошо разбирается».

Образование: Курганский университет, кафедра «Безопасность информационных и автоматизированных систем», к.т.н.
В 2002 окончил Курганский государственный университет по специальности «Многоцелевые гусеничные и колесные машины».
В 2005 защитил диссертацию по бесступенчатым передачам. С тех пор официально трудоустроен в университете (КГУ).

Преподаватель

Разрабатывает Machine Reasoning Engine в Cisco Systems.
C 2017 года работает в Кремниевой долине.
Преподавал курс по Decentralized Applications (CS359B) в Стэнфорде.
Побеждал на хакатоне SpaceHack и всероссийском конкурсе проектов «IT-Прорыв».
Участвовал в чемпионате мира по программированию ACM ICPC.

Закончил МГТУ им. Баумана с отличием.
Занимался legal tech, блокчейн-проектами, HL/HA проектами, разработкой беттинг-платформы, сбором и аналитикой персональных данных из социальных сетей, внедрением CI/CD.

Преподаватель

Определение основных функций в Python — Real Python

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

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

Базовый Python main ()

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

  def main ():
    print («Привет, мир!»)

если __name__ == "__main__":
    основной()
  

В этом коде есть функция main () , которая печатает фразу Hello World! , когда его выполняет интерпретатор Python.Также существует условный оператор (или , если ), который проверяет значение __name__ и сравнивает его со строкой «__main__» . Когда оператор if оценивается как True , интерпретатор Python выполняет main () . Вы можете узнать больше об условных операторах в разделе «Условные операторы в Python».

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

Режимы выполнения в Python

Есть два основных способа указать интерпретатору Python выполнять или использовать код:

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

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

Мы будем использовать этот пример файла, сохраненный как execution_methods.py , чтобы исследовать, как поведение кода изменяется в зависимости от контекста:

  print ("Это мой файл для тестирования методов выполнения Python.")
print («Переменная __name__ сообщает мне, в каком контексте запущен этот файл.»)
print ("Значение __name__:", repr (__ name__))
  

В этом файле определены три вызова print () . Первые два печатают вводные фразы. Третья функция print () сначала напечатает фразу Значение __name__ равно , а затем напечатает представление переменной __name__ с использованием встроенного Python repr () .

В Python repr () отображает печатное представление объекта.В этом примере используется repr () , чтобы подчеркнуть, что значение __name__ является строкой. Вы можете узнать больше о repr () в документации Python.

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

  1. Файл: Обычно файл Python — это любой файл, содержащий код.Большинство файлов Python имеют расширение .py .

  2. Сценарий: Сценарий Python — это файл, который вы собираетесь запустить из командной строки для выполнения задачи.

  3. Модуль: Модуль 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, а строка ввода будет начинаться с $ . .

Теперь вы должны выполнить сценарий execution_methods.py из командной строки, как показано ниже:

  $ python3 Execution_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 имя_пакета .

Добавление аргумента -m запускает код в модуле __main__.py пакета. Вы можете найти дополнительную информацию о __main__.py в статье Как опубликовать пакет Python с открытым исходным кодом в PyPI.

Во всех трех случаях __name__ имеет одно и то же значение: строка '__main__' .

Технические детали: В документации Python конкретно указано, когда __name__ будет иметь значение '__main__' :

__name__ модуля устанавливается равным '__main__' при чтении из стандартного ввода, сценария или из интерактивной подсказки.(Источник)

__name__ хранится в глобальном пространстве имен модуля вместе с __doc__ , __package__ и другими атрибутами. Вы можете узнать больше об этих атрибутах в документации модели данных Python и, особенно для модулей и пакетов, в документации по импорту Python.

Импорт в модуль или интерактивный интерпретатор

Теперь давайте посмотрим на второй способ, которым интерпретатор Python будет выполнять ваш код: импорт.Когда вы разрабатываете модуль или сценарий, вы, скорее всего, захотите воспользоваться преимуществами модулей, которые уже созданы кем-то другим, что вы можете сделать с помощью ключевого слова import .

Во время процесса импорта Python выполняет операторы, определенные в указанном модуле (но только первый раз, когда вы импортируете модуль ). Чтобы продемонстрировать результаты импорта файла Execution_methods.py , запустите интерактивный интерпретатор Python и затем импортируйте свои Execution_methods.py файл:

>>>

  >>> импорт методов_исполнения
Это мой файл для тестирования методов выполнения Python.
Переменная __name__ сообщает мне, в каком контексте выполняется этот файл.
Значение __name__: 'execution_methods'
  

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

Когда интерпретатор Python импортирует код, значение __name__ устанавливается таким же, как имя импортируемого модуля. Вы можете увидеть это в третьей строке вывода выше. __name__ имеет значение 'execution_methods' , которое является именем файла .py , из которого Python импортирует.

Обратите внимание, что если вы снова импортируете модуль без выхода из Python, выход не будет.

Лучшие практики для основных функций Python

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

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

  1. Поместите большую часть кода в функцию или класс.
  2. Используйте __name__ для управления выполнением вашего кода.
  3. Создайте функцию с именем main () , содержащую код, который вы хотите запустить.
  4. Вызов других функций из main () .

Поместите большую часть кода в функцию или класс

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

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

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

Следовательно, лучше всего включать большую часть кода в функцию или класс . Это связано с тем, что, когда интерпретатор Python встречает ключевые слова def или class , он сохраняет эти определения только для последующего использования и фактически не выполняет их, пока вы ему не скажете.

Сохраните приведенный ниже код в файл с именем best_practices.py , чтобы продемонстрировать эту идею:

  1 из времени импорта сна
 2
 3print ("Это мой файл, демонстрирующий передовой опыт.")
 4
 5def process_data (данные):
 6 print («Начало обработки данных ...»)
 7 modified_data = data + "что было изменено"
 8 спальных мест (3)
 9 print («Обработка данных завершена.»)
10 вернуть Modified_data
  

В этом коде вы сначала импортируете sleep () из модуля time .

sleep () приостанавливает интерпретатор на количество секунд, которое вы указываете в качестве аргумента, и создает функцию, выполнение которой для этого примера занимает много времени. Затем вы используете print () , чтобы напечатать предложение, описывающее цель этого кода.

Затем вы определяете функцию с именем process_data () , которая выполняет пять функций:

  1. Распечатывает некоторый вывод, чтобы сообщить пользователю, что обработка данных начинается
  2. Изменяет входные данные
  3. Приостанавливает выполнение на три секунды, используя sleep ()
  4. Распечатывает некоторые выходные данные, чтобы сообщить пользователю, что обработка завершена.
  5. Возвращает измененные данные

Выполнить файл рекомендаций из командной строки

Что произойдет, если вы выполните этот файл как сценарий в командной строке?

Интерпретатор 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 :

>>>

  >>> 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 () .

После этого печатается значение данных . Это произошло потому, что переменная __name__ имеет значение «__main__» , когда интерпретатор Python выполняет файл как сценарий, поэтому условный оператор оценивается как True .

Затем ваш сценарий вызвал process_data () и передал данных для модификации. Когда выполняется process_data () , он выводит на выход некоторые сообщения о состоянии. Наконец, печатается значение modified_data .

Теперь вы должны проверить, что происходит при импорте файла best_practices.py из интерактивного интерпретатора (или другого модуля). Пример ниже демонстрирует эту ситуацию:

>>>

  >>> import best_practices
Это мой файл для демонстрации передового опыта.
  

Обратите внимание, что вы получаете то же поведение, что и до добавления условного оператора в конец файла! Это связано с тем, что переменная __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 modified_data = data + "что было изменено"
 8 спальных мест (3)
 9 print («Обработка данных завершена.»)
10 вернуть Modified_data
11
12def main ():
13 data = "Мои данные прочитаны из Интернета"
14 печать (данные)
15 измененные_данные = данные_процесса (данные)
16 печать (измененные_данные)
17
18if __name__ == "__main__":
19 основной ()
  

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

Вызов других функций из main ()

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

Например, у вас может быть сценарий, который выполняет следующие действия:

  1. Считывает файл данных из источника, которым может быть база данных, файл на диске или веб-API.
  2. Обрабатывает данные
  3. Записывает обработанные данные в другое место

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

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

Измените файл best_practices.py так, чтобы он выглядел, как показано ниже:

  1 из времени импорта сна
 2
 3print ("Это мой файл, демонстрирующий передовой опыт.")
 4
 5def process_data (данные):
 6 print («Начало обработки данных ...»)
 7 modified_data = data + "что было изменено"
 8 спальных мест (3)
 9 print («Обработка данных завершена.»)
10 вернуть Modified_data
11
12def read_data_from_web ():
13 print («Чтение данных из Интернета»)
14 data = "Данные из Интернета"
15 возврат данных
16
17def write_data_to_database (данные):
18 print («Запись данных в базу данных»)
19 печать (данные)
20
21def main ():
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 = "Данные из файла"
>>> modified_data = bp.process_data (данные)
Начало обработки данных ...
Обработка данных завершена.
>>> bp.write_data_to_database (измененные_данные)
Запись обработанных данных в базу данных
Данные из файла, который был изменен
  

В этом примере вы импортировали best_practices и сократили имя до bp для этого кода.

В процессе импорта интерпретатор Python выполнил все строки кода из best_practices.py , поэтому на выходе отображается строка, объясняющая назначение файла.

Затем вы сохранили данные из файла в data вместо того, чтобы читать данные из Интернета. Затем вы повторно использовали process_data () и write_data_to_database () из файла best_practices.py . В этом случае вы воспользовались преимуществом повторного использования вашего кода вместо определения всей логики в main () .

Сводка передовых методов работы с основными функциями Python

Вот четыре ключевых передовых метода работы с main () в Python, которые вы только что видели:

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

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

  3. Вы должны назвать свою точку входа function main () , чтобы передать назначение функции, даже если Python не придает особого значения функции с именем main () .

  4. Если вы хотите повторно использовать функциональные возможности своего кода, определите логику в функциях вне main () и вызовите эти функции в main () .

Заключение

Поздравляем! Теперь вы знаете, как создавать функции Python main () .

Вы узнали следующее:

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

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

    • "__main__" , когда файл выполняется из командной строки или с python -m (для выполнения пакета __main__.py файл)
    • Имя модуля, если модуль импортируется
  • Программисты

  • Python разработали набор передовых методов, которые можно использовать при разработке повторно используемого кода.

Теперь вы готовы написать отличный код функции Python main () !

Пример основной функции и метода Python: понимание __main__

Что такое основная функция Python?

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

Что такое функция def main () в Python? Чтобы понять это, рассмотрим следующий пример кода

.
def main ():
     print ("привет, мир!")
print ("Guru99")
 

Здесь у нас есть две части print — одна определена в основной функции, которая называется «Hello World», а другая независима, то есть «Guru99».Когда вы запускаете функцию def main ():

  • Только «Guru99» выводит
  • , а не код «Hello World».

Это потому, что мы не объявили вызов функции «if__name __ ==« __main__ ».

. Важно, чтобы после определения основной функции вы вызывали код с помощью if__name __ ==« __main__ », а затем запускали кода, только тогда вы получите вывод «hello world!» в консоли программирования. Рассмотрим следующий код

 def main ():
    print ("привет, мир!")

если __name__ == "__main__":
    основной()

print ("Guru99")
 

Guru99 печатается в этом случае.

Вот объяснение,

  • Когда интерпретатор Python читает исходный файл, он выполняет весь код, найденный в нем.
  • Когда Python запускает «исходный файл» в качестве основной программы, он устанавливает для специальной переменной (__name__) значение («__main__»).
  • Когда вы выполняете основную функцию в python, он затем читает оператор «if» и проверяет, совпадает ли __name__ с __main__.
  • В Python «if__name __ ==» __main__ « позволяет запускать файлы Python либо как повторно используемые модули , либо как отдельные программы.

Переменная __name__ и модуль Python

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

 def main ():
    print ("привет, мир!")

если __name__ == "__main__":
    основной()

print ("Guru99")

print ("Значение в имени встроенной переменной:", __ name__)
 

Теперь рассмотрим, код импортируется как модуль

 import MainFunction

печать ("готово")
 

Вот объяснение кода:

Как и C, Python использует == для сравнения, а = для присваивания.Интерпретатор Python использует основную функцию двумя способами.

прямой запуск:

  • __name __ = __ main__
  • if statement == True, и скрипт в _main_ будет выполнен

import as a module

  • __name__ = имя файла модуля
  • if statement == false, и сценарий в __main__ не будет выполнен

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

Приведенные выше примеры представляют собой коды Python 3, если вы хотите использовать Python 2, обратите внимание на следующий код

def main ():
  печать "Hello World!"
  
если __name __ == "__main__":
  основной()

печать "Guru99"
 

В Python 3 вам не нужно использовать if__name. Следующий код также работает

def main ():
  print («Привет, мир!»)
  
основной()
print ("Guru99")
 

Примечание: Убедитесь, что после определения основной функции вы оставляете некоторый отступ и не объявляете код прямо под функцией def main (): в противном случае будет выдана ошибка отступа.

О Кришне Рунгта

Кришна имеет более 15 лет профессионального опыта разработки и тестирования программного обеспечения в качестве индивидуального сотрудника, технического руководителя, а сегодня является генеральным директором Guru99.

Основная функция Python — GeeksforGeeks

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

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

Пример:

печать ( «Hello» )

печать ( «привет, там» )

если __name__ = 000 __ 0003 = 000 __ основной ()

Выход:

Привет
Привет
 

При выполнении указанной выше программы интерпретатор объявляет начальное значение имени как «main».Когда интерпретатор достигает оператора if, он проверяет значение имени, а когда значение if истинно, он запускает основную функцию, иначе основная функция не выполняется.

Основная функция как модуль

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

Пример: Предположим, есть два файла (File1.py и File2.py). File1 выглядит следующим образом.

печать ( "File1 __name__ =% s" % __name__)

if 000

000 000 __ «__main__» :

печать ( «Файл 1 запускается напрямую» )

еще :

Файл 1 импортируется » )

Вывод:

File1 __name__ = __main__
File1 запускается напрямую
 

Теперь, когда файл File1.py импортируется в File2.py, значение __name__ изменяется.

импорт File1

print ( "File2 __name__ =% s" 000

__ если __name__ = = «__main__» :

печать ( «Файл 2 запускается напрямую» ) )

печать ( «Файл 2 импортируется» )

Вывод:

Файл1 __name__ = Файл1
File1 импортируется
File2 __name__ = __main__
File2 запускается напрямую
 

Как видно выше, когда File1.py запускается напрямую, интерпретатор устанавливает переменную __name__ как __main__ , и когда она запускается через File2.py путем импорта, переменная __name__ устанавливается как имя скрипта python, то есть File1. Таким образом, можно сказать, что if __name__ == «__main__» - это часть программы, которая запускается, когда сценарий запускается из командной строки с помощью такой команды, как Python File1.py.

Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS . И чтобы начать свое путешествие по машинному обучению, присоединяйтесь к Машинное обучение - курс базового уровня

Основная функция Python

Что такое функция main () в Python?

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

Python предлагает другие соглашения для определения точки выполнения. Один из них использует функцию main () и свойство __name__ файла python.


Что такое __name__ в Python?

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

Он имеет разные значения в зависимости от того, где мы запускаем файл Python. Давайте посмотрим на пример.


Запуск файла Python как скрипта

Предположим, у нас есть файл Python с именем helloworld.py со следующим содержанием:

  печать (__ имя__)
  

Если мы запустим helloworld.py из командной строки, то он будет работать как сценарий Python. Мы можем запустить программу Python, используя следующую команду:

  $  Python helloworld.py 

Когда мы запускаем программу как сценарий, значение переменной __name__ устанавливается на __main__ . Таким образом, вывод следующей программы будет:

  __main__
  

Запуск файла Python как модуля

Мы также можем запустить файл Python как модуль.Для этого мы должны импортировать этот файл в другую программу Python. Давайте посмотрим на пример.

Предположим, у нас есть файл Python с именем main.py в том же каталоге, что и файл heloworld.py. Он имеет следующее содержание:

  импорт helloworld
  

Когда мы запустим этот файл, мы получим следующий результат:

  helloworld
  

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

Но мы видим, что вместо отображения __main__ программа отображает имя модуля, то есть helloworld .

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


Использование условного if с __name__

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

Рассмотрим пример.

Предположим, мы изменили содержимое файла helloworld.py на следующее:

  def main ():
    print ("Привет, мир")

если __name __ == "__ main__":
    основной()
  

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

  Привет, мир
  

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

Здесь мы создали специальную функцию main () в файле helloworld.py . Он выполняется только тогда, когда программа запускается как отдельный сценарий, а не как импортированный модуль.

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

Python, если __name__ == __main__ объяснено с примерами кода

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

Одна из этих переменных называется __name__ .

Если вы будете следовать этой статье шаг за шагом и читать ее фрагменты кода, вы узнаете, как использовать , если __name__ == "__main__" , и почему это так важно.

Объяснение модулей

Python

Файлы

Python называются модулями и идентифицируются по расширению файла .py . Модуль может определять функции, классы и переменные.

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

Но если код импортирует модуль из другого модуля, тогда в переменной __name__ будет установлено имя этого модуля.

Рассмотрим пример. Создайте модуль Python с именем file_one.py и вставьте этот код верхнего уровня внутрь:

  # Python file one module

print ("Первый файл __name__ установлен в: {}" .format (__ name__))  

file_one.py

Запустив этот файл, вы точно увидите, о чем мы говорили. Переменная __name__ для этого модуля установлена ​​на __main__ :

  Файл 1 __name__ установлен на: __main__  

Теперь добавьте еще один файл с именем file_two.py и вставьте этот код внутрь:

  # Модуль Python для импорта

print ("Файл два __name__ установлен на: {}" .format (__ name__))
  

file_two.py

Также измените код в file_one.py следующим образом, чтобы мы импортировали модуль file_two :

  # модуль Python для выполнения
import file_two

print ("Первый файл __name__ установлен на: {}" .format (__ name__))
  

file_one.py

Повторный запуск нашего кода file_one покажет, что переменная __name__ в file_one не изменилась и по-прежнему остается равной __main__ .Но теперь в качестве имени модуля установлена ​​переменная __name__ в file_two , следовательно, file_two .

Результат должен выглядеть так:

  Файл 2 __name__ установлен на: file_two
Первый файл __name__ имеет значение: __main__
  

Но запустите file_two напрямую, и вы увидите, что его имя установлено на __main__ :

  Файл два __name__ установлен на: __main__

  

Переменная __name__ для запускаемого файла / модуля всегда будет __main__ .Но переменная __name__ для всех других импортируемых модулей будет установлена ​​на имя их модуля.

Соглашения об именах файлов Python

Обычный способ использования __name__ и __main__ выглядит так:

  if __name__ == "__main__":
   Сделай что-нибудь здесь

  

Давайте посмотрим, как это работает в реальной жизни и как на самом деле использовать эти переменные.

Измените file_one и file_two , чтобы они выглядели так:

file_one :

  # Модуль Python для выполнения
import file_two

print ("Первый файл __name__ установлен на: {}".формат (__ имя__))

если __name__ == "__main__":
   print ("Первый файл выполняется при прямом запуске")
еще:
   print ("Первый файл выполняется при импорте")
  

file_one.py

file_two :

  # Модуль Python для импорта

print ("Файл два __name__ установлен на: {}" .format (__ name__))

если __name__ == "__main__":
   print ("Второй файл выполняется при прямом запуске")
еще:
   print ("Второй файл выполняется при импорте")
  

file_two.py

Опять же, при запуске file_one вы увидите, что программа распознала, какой из этих двух модулей является __main__ , и выполнила код в соответствии с нашими первыми if else операторами.

Результат должен выглядеть так:

  Файл 2 __name__ установлен на: file_two
Второй файл выполняется при импорте
Первый файл __name__ имеет значение: __main__
Первый файл выполняется при прямом запуске
  

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

  Файл 2 __name__ установлен на: __main__
Второй файл выполняется при прямом запуске
  

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

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

file_one :

  # Модуль Python для выполнения
import file_two

print ("Первый файл __name__ установлен на: {}" .format (__ name__))

def function_one ():
   print («Выполняется первая функция»)

def function_two ():
   print («Выполняется вторая функция»)

если __name__ == "__main__":
   print ("Первый файл выполняется при прямом запуске")
еще:
   print ("Первый файл выполняется при импорте")
  

file_one.py

file_two :

  # Модуль Python для импорта

print ("Файл два __name__ установлен на: {}" .format (__ name__))

def function_three ():
   print («Выполняется третья функция»)

если __name__ == "__main__":
   print ("Второй файл выполняется при прямом запуске")
еще:
   print ("Второй файл выполняется при импорте")
  

Теперь функции загружаются, но не запускаются.

Для запуска одной из этих функций измените if __name__ == "__main__" часть file_one , чтобы она выглядела следующим образом:

  if __name__ == "__main__":
   print ("Первый файл выполняется при прямом запуске")
   function_two ()
еще:
   print ("Первый файл выполняется при импорте")
  

При запуске file_one вы должны увидеть следующее:

  File two __name__ имеет значение: file_two
Второй файл выполняется при импорте
Первый файл __name__ имеет значение: __main__
Первый файл выполняется при прямом запуске
Выполняется вторая функция
  

Также вы можете запускать функции из импортированных файлов.Для этого измените часть if __name__ == «__main__» из file_one так:

  if __name__ == "__main__":
   print ("Первый файл выполняется при прямом запуске")
   function_two ()
   file_two.function_three ()
еще:
   print ("Первый файл выполняется при импорте")
  

И вы можете ожидать такой результат:

  Файл 2 __name__ установлен на: file_two
Второй файл выполняется при импорте
Первый файл __name__ имеет значение: __main__
Первый файл выполняется при прямом запуске
Выполняется вторая функция
Выполняется третья функция
  

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

  # Модуль Python для импорта

print ("Файл два __name__ установлен на: {}" .format (__ name__))

def function_three ():
   print («Выполняется третья функция»)

def function_four ():
   print («Выполняется функция четыре»)

если __name__ == "__main__":
   print ("Второй файл выполняется при прямом запуске")
еще:
   print ("Второй файл выполняется при импорте")
  

file_two.py

А чтобы импортировать определенные функции из модуля, используйте блок импорта из в file_one file:

  # Модуль Python для выполнения
from file_two import function_three

print ("Первый файл __name__ установлен на: {}".формат (__ имя__))

def function_one ():
   print («Выполняется первая функция»)

def function_two ():
   print («Выполняется вторая функция»)

если __name__ == "__main__":
   print ("Первый файл выполняется при прямом запуске")
   function_two ()
   function_three ()
еще:
   print («Первый файл выполняется при импортировании»)  

file_one.py

Заключение

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

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

Бюстгальтер гьорт! (Это означает «Молодец» по-шведски!)

Ознакомьтесь с другими подобными статьями в моем профиле freeCodeCamp, в среднем профиле и других забавных материалах, которые я создаю на своей странице GitHub.

Что такое основная функция в Python и как ее использовать

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

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

Давайте начнем.

Что такое функции Python?

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

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

Итак, давайте разберемся, что именно является основной функцией в Python.

Что такое основная функция в Python

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

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

A Basic Python main ()

В большинстве программ / скриптов Python вы можете увидеть определение функции, за которым следует условный оператор, который выглядит как в примере, показанном ниже:

 def main ():
    print ("Привет, мир!")
    если __name __ == "__main__":
main () 

Нужна ли Python основная функция?

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

И при выполнении выводит «Hello, World!».

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

Давайте разберемся, как выполняется этот код. Перед этим очень необходимо понять, что интерпретатор Python устанавливает __name__ в зависимости от способа выполнения кода.Итак, давайте узнаем о режимах выполнения в Python

Режимы выполнения Python

Есть два основных способа, которыми вы можете указать интерпретатору Python выполнить код:

  • Самый распространенный способ - выполнить файл как скрипт Python.
  • Путем импорта необходимого кода из одного файла Python в другой.

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

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

Чтобы помочь в этом, Python имеет специальную встроенную переменную, которая называется __name__ . Этой переменной присваивается строка « __main__ » в зависимости от того, как вы запускаете или выполняете сценарий.

Что такое __main__ в Python?

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

Итак, если вы запускаете сценарий напрямую, Python назначит « __main__ » на __name__ , то есть __name__ = «__main__».(Это происходит в фоновом режиме).

В результате вы пишете условный оператор if следующим образом:

 if __name__ == "__main__":
Логические операторы 

Следовательно, если условный оператор оценивается как True, это означает, что файл .py (сценарий Python) запускается или выполняется напрямую.

Важно понимать, что если вы запускаете что-то непосредственно в оболочке Python или терминале, этот условный оператор по умолчанию оказывается True.

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

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

Есть несколько вещей, которые вы должны помнить при написании программ, которые будут выполнять функцию main. Я перечислил их в четыре простых шага. Вы можете рассматривать это как хорошую номенклатуру, которой нужно следовать при написании программ Python, в которых есть основная функция.

  • По возможности используйте функции и классы.

Мы давно изучаем концепции объектно-ориентированного программирования и их преимущества. Абсолютно необходимо размещать объемные логические коды в компактных функциях или классах. Почему? Для лучшего повторного использования кода, лучшего понимания и общей оптимизации кода. Таким образом, вы можете контролировать выполнение кода, а не позволять интерпретатору Python выполнять его, как только он импортирует модуль.

Давайте посмотрим на следующий фрагмент кода:

def get_got ():
print ("& amp; hellip; Получение данных GOT & amp; hellip; n")
data = "Бран Старк завоевывает Железный трон. n"
print ("& amp; hellip; GOT Данные получены & amp; hellip; n")
вернуть данные

print ("n Демо: Использование функций n")
got = get_got ()
печать (есть)
 

В приведенном выше примере я определил функцию под названием « get_got », которая возвращает строку, хранящуюся в переменной «data». Затем это сохраняется в переменной под названием got, которая затем печатается.Я записал вывод ниже:

  • Используйте __name__ для управления выполнением вашего кода.

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

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

 if __name__ == "__main__":
got = "Игра престолов - это легендарный показ"
печать (есть)
new_got = ул.раскол (получил)
print (new_got) 

В приведенном выше примере оператор условного if будет сравнивать значения переменной __name__ со строкой « __main__ ». Если и только если он оценивается как True, выполняется следующий набор логических операторов. Поскольку мы запускаем программу напрямую, мы знаем, что условный оператор будет True. Таким образом, операторы выполняются, и мы получаем желаемый результат. Таким образом, мы можем использовать переменную __name__ для управления выполнением вашего кода.Вы можете обратиться к выводам, показанным ниже:

  • Создайте функцию main (), которая имеет код для запуска.

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

print ("n Демонстрация основных функций")
def demo (есть):
print ("& amp; hellip; Начало Игры престолов & amp; hellip; n")
new_got = ул.раскол (получил)
print ("& amp; hellip; Игра престолов завершена & amp; hellip; n")
вернуть new_got
def main ():
got = "n Бран Старк завоевывает Железный трон n"
печать (есть)
new_got = демо (есть)
печать (новый_гот)
если __name__ == "__main__":
основной()
 

В приведенном выше примере я использовал определение main (), которое содержит логику программы, которую я хочу запустить. Я также определил функцию под названием «demo», чтобы включить фрагмент кода, который можно повторно использовать по мере необходимости. Кроме того, я изменил условный блок, так что он выполняет main ().

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

Примечание. Если вы запустите этот код как скрипт или импортируете его, результат будет таким же. Вы можете посмотреть на вывод ниже:

  • Вызов других функций из main ().

Когда вы пишете полноценные программы на Python, может быть множество функций, которые можно вызывать и использовать.Чаще всего некоторые функции следует вызывать сразу после запуска программы. Следовательно, всегда полезно вызывать другие функции из самой main ().

Давайте посмотрим на фрагмент кода ниже:

print ("n Демонстрация основных функций")
def demo (есть):
print ("& amp; hellip; Начало Демоверсии Игры Престолов1 & amp; hellip; n")
new_got = str.split (получил)
print ("& amp; hellip; Игра престолов завершена & amp; hellip; n")
вернуть new_got
def getgot ():
print ("& amp; hellip; Получение данных GOT & amp; hellip; n")
got = "Бран Старк завоевывает Железный трон n"
print ("& amp; hellip; Данные GOT возвращены & amp; hellip; n")
возврат получил
def main ():
got = getgot ()
печать (есть)
new_got = демо (есть)
печать (новый_гот)
если __name__ == "__main__":
основной()
 

В приведенном выше примере я определил функцию под названием « getgot () » для извлечения данных.И эта функция вызывается из самого main () .

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

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

Если вы сочли эту статью «Понимание основных функций в Python» релевантной, посетите Edureka Python Certification Training, надежную онлайн-обучающую компанию с сетью из более чем 250 000 довольных учеников по всему миру. Этот тренинг помогает учащимся получить опыт написания сценариев на Python и подготовить людей к работе на Python.

Есть к нам вопрос? Пожалуйста, укажите это в разделе комментариев блога «Основные функции в Python», и мы свяжемся с вами в ближайшее время.

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

Основная функция Python - JournalDev

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

Основная функция Python

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

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

python_main_function.py

 
print ("Привет")

print ("__ имя__ значение:", __name__)


def main ():
    print ("основная функция python")


если __name__ == '__main__':
    основной()
  

На изображении ниже показан результат, когда python_main_function.py выполняется как исходный файл.

Основная функция Python как модуль

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

python_import.py

 
импортировать python_main_function

print ("Готово")
  

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

 
Привет
__name__ значение: python_main_function
Сделанный
  

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

2021 © Все права защищены. Карта сайта