Главная функция: главная функция — это… Что такое главная функция?

Главная функция женщины в жизни – быть мамой — Детская городская поликлиника №1

 интервал d = 42;
int o = 052;
int x = 0x2a;
int X = 0X2A;
int b = 0b101010; // C ++ 14 

 беззнаковый длинный длинный l1 = 18446744073709550592ull; // C ++ 11
беззнаковое длинное длинное l2 = 18'446'744'073'709'550'592llu; // C ++ 14
беззнаковый длинный длинный l3 = 1844'6744'0737'0955'0592uLL; // C ++ 14
беззнаковый длинный длинный l4 = 184467'440737'0'95505'92LLU; // C ++ 14 

 авто x = 0xE + 2.0; // ошибка
авто y = 0xa + 2.0; // ХОРОШО
авто z = 0xE +2.0; // ХОРОШО
авто q = (0xE) +2.0; // ОК 

 #include 
#include 
#include 

int main ()
{
std :: cout << 123 << '\ п'
          << 0123 << '\ n'
          << 0x123 << '\ n'
          << 0b10 << '\ n'
          << 123456784567890ull << '\ n'
          << 123456784567890u << '\ n'; // тип беззнаковый длинный длинный четный
                                              // без длинного длинного суффикса

// std :: cout << -72036854775808 << '\ n'; // ошибка: значение
                // 72036854775808 не может поместиться в длинное длинное число со знаком, которое является
                // самый большой тип, разрешенный для десятичного целочисленного литерала без суффиксов
     std :: cout << -72036854775808u << '\ n'; // унарный минус применяется к беззнаковому
                // значение вычитает его из 2 ^ 64, это дает 72036854775808
     std :: cout << -72036854775807 - 1 << '\ n'; // правильный способ расчета
                                                    // значение -72036854775808

#if __cpp_size_t_suffix> = 202011L // C ++ 23
     static_assert (std :: is_same_v );
     static_assert (std :: is_same_v >);
#endif
} 

 123
83
291
2
123456784567890
123456784567890
72036854775808
-72036854775808 

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

Параметры двухпараметрической формы основной функции позволяют передавать произвольные многобайтовые символьные строки из среды выполнения (обычно они известны как аргументы командной строки ). Указатели argv [1] .. argv [argc-1] указывают на первые символы в каждой из этих строк. argv [0] — указатель на начальный символ многобайтовых строк с завершающим нулем, который представляет имя, используемое для вызова самой программы (или, если это не поддерживается средой хоста, argv [0] [0] гарантированно равняется нулю).

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

Строки можно изменять, и любые сделанные изменения сохраняются до завершения программы, хотя эти изменения не распространяются обратно в среду хоста: их можно использовать, например, с помощью strtok.

Размер массива, на который указывает argv , составляет не менее argc + 1 , а последний элемент, argv [argc] , гарантированно будет нулевым указателем.

Основная функция имеет несколько специальных свойств:

1) Прототип этой функции не может быть предоставлен программой

[править] Пример

Демонстрирует, как сообщить программе, где найти ввод и куда записать результаты.Вызов: ./a.out indatafile outdatafile

 #include 

int main (int argc, char * argv [])
{
    printf ("argc =% d \ n", argc);
    для (int ndx = 0; ndx! = argc; ++ ndx)
        printf ("argv [% d] ->% s \ n", ndx, argv [ndx]);
    printf ("argv [argc] =% p \ n", (void *) argv [argc]);
} 

Возможный выход:

 argc = 3
argv [0] -> ./a.out
argv [1] -> indatafile
argv [2] -> файл исходящих данных
argv [argc] = (nil) 

[править] Ссылки

• C11 стандарт (ISO / IEC 9899: 2011):

• 5.1.2.2.1 Запуск программы (стр: 13)

• C99 стандарт (ISO / IEC 9899: 1999):

• 5.1.2.2.1 Запуск программы (стр: 12)

• Стандарт C89 / C90 (ISO / IEC 9899: 1990):

• 5.1.2.2 Размещенная среда

[править] См. Также

Основная функция — cppreference.com

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

[редактировать] Параметры

Имена argc и argv обозначают количество аргументов и вектор аргументов.Имена и представление типов параметров произвольные: int main (int ac, char ** av) одинаково допустимы.

Распространенной формой main, определяемой реализацией, является int main (int argc, char * argv [], char * envp []), где третий аргумент типа char * [] указывает на массив указателей на переменные среды хоста.

[править] Возвращаемое значение

Если используется оператор return, возвращаемое значение используется в качестве аргумента неявного вызова exit () (подробности см. Ниже).Нулевые значения и EXIT_SUCCESS указывают на успешное завершение, значение EXIT_FAILURE указывает на неудачное завершение.

[править] Объяснение

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

Параметры двухпараметрической формы основной функции позволяют передавать произвольные многобайтовые символьные строки из среды выполнения (обычно они известны как аргументы командной строки ). Указатели argv [1] .. argv [argc-1] указывают на первые символы в каждой из этих строк. argv [0] — указатель на начальный символ многобайтовых строк с завершающим нулем, который представляет имя, используемое для вызова самой программы (или, если это не поддерживается средой хоста, argv [0] [0] гарантированно равняется нулю).

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

Строки можно изменять, и любые сделанные изменения сохраняются до завершения программы, хотя эти изменения не распространяются обратно в среду хоста: их можно использовать, например, с помощью strtok.

Размер массива, на который указывает argv , составляет не менее argc + 1 , а последний элемент, argv [argc] , гарантированно будет нулевым указателем.

Основная функция имеет несколько специальных свойств:

1) Прототип этой функции не может быть предоставлен программой

[править] Пример

Демонстрирует, как сообщить программе, где найти ввод и куда записать результаты.Вызов: ./a.out indatafile outdatafile

 #include 

int main (int argc, char * argv [])
{
    printf ("argc =% d \ n", argc);
    для (int ndx = 0; ndx! = argc; ++ ndx)
        printf ("argv [% d] ->% s \ n", ndx, argv [ndx]);
    printf ("argv [argc] =% p \ n", (void *) argv [argc]);
} 

Возможный выход:

 argc = 3
argv [0] -> ./a.out
argv [1] -> indatafile
argv [2] -> файл исходящих данных
argv [argc] = (nil) 

[править] Ссылки

• C11 стандарт (ISO / IEC 9899: 2011):

• 5.1.2.2.1 Запуск программы (стр: 13)

• C99 стандарт (ISO / IEC 9899: 1999):

• 5.1.2.2.1 Запуск программы (стр: 12)

• Стандарт C89 / C90 (ISO / IEC 9899: 1990):

• 5.1.2.2 Размещенная среда

[править] См. Также

Основная функция — cppreference.com

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

[редактировать] Параметры

Имена argc и argv обозначают количество аргументов и вектор аргументов.Имена и представление типов параметров произвольные: int main (int ac, char ** av) одинаково допустимы.

Распространенной формой main, определяемой реализацией, является int main (int argc, char * argv [], char * envp []), где третий аргумент типа char * [] указывает на массив указателей на переменные среды хоста.

[править] Возвращаемое значение

Если используется оператор return, возвращаемое значение используется в качестве аргумента неявного вызова exit () (подробности см. Ниже).Нулевые значения и EXIT_SUCCESS указывают на успешное завершение, значение EXIT_FAILURE указывает на неудачное завершение.

[править] Объяснение

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

Параметры двухпараметрической формы основной функции позволяют передавать произвольные многобайтовые символьные строки из среды выполнения (обычно они известны как аргументы командной строки ). Указатели argv [1] .. argv [argc-1] указывают на первые символы в каждой из этих строк. argv [0] — указатель на начальный символ многобайтовых строк с завершающим нулем, который представляет имя, используемое для вызова самой программы (или, если это не поддерживается средой хоста, argv [0] [0] гарантированно равняется нулю).

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

Строки можно изменять, и любые сделанные изменения сохраняются до завершения программы, хотя эти изменения не распространяются обратно в среду хоста: их можно использовать, например, с помощью strtok.

Размер массива, на который указывает argv , составляет не менее argc + 1 , а последний элемент, argv [argc] , гарантированно будет нулевым указателем.

Основная функция имеет несколько специальных свойств:

1) Прототип этой функции не может быть предоставлен программой

[править] Пример

Демонстрирует, как сообщить программе, где найти ввод и куда записать результаты.Вызов: ./a.out indatafile outdatafile

 #include 

int main (int argc, char * argv [])
{
    printf ("argc =% d \ n", argc);
    для (int ndx = 0; ndx! = argc; ++ ndx)
        printf ("argv [% d] ->% s \ n", ndx, argv [ndx]);
    printf ("argv [argc] =% p \ n", (void *) argv [argc]);
} 

Возможный выход:

 argc = 3
argv [0] -> ./a.out
argv [1] -> indatafile
argv [2] -> файл исходящих данных
argv [argc] = (nil) 

[править] Ссылки

• C11 стандарт (ISO / IEC 9899: 2011):

• 5.1.2.2.1 Запуск программы (стр: 13)

• C99 стандарт (ISO / IEC 9899: 1999):

• 5.1.2.2.1 Запуск программы (стр: 12)

• Стандарт C89 / C90 (ISO / IEC 9899: 1990):

• 5.1.2.2 Размещенная среда

[править] См. Также

Определение основных функций в 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 () не приводят к выходным данным, как и при выполнении кода из командной строки.

Используйте

Что делать, если вы хотите, чтобы 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. Вы должны назвать свою точку входа функцией main () , чтобы передать назначение функции, даже если Python не придает особого значения функции с именем main () .

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

Заключение

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Нужна ли Python функция Main?

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

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

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

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

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

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

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

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

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

Основная функция 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, выполняется следующий набор логических операторов. Поскольку мы непосредственно запускаем программу, мы знаем, что условное выражение будет истинным. Таким образом, операторы выполняются, и мы получаем желаемый результат. Таким образом, мы можем использовать переменную __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» релевантной, ознакомьтесь с курсом сертификации Python Edureka, надежной компанией онлайн-обучения с сетью из более чем 250 000 довольных учеников по всему миру. Это обучение помогает учащимся получить опыт написания сценариев на Python и подготовить людей к работе на Python.

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

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

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.