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

введение

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

C

C++

JAVA

C#

Python

Мы видим, что Python использует только одну строку кода для выполнения нескольких строк вывода на других языках программирования. Привет, мир. Другие языки программирования, такие как C / C ++ / C # / JAVA, будут иметь структуру основных функций. Все коды находятся в Работая под этой структурой,Может быть только одна основная функцияКод начинает выполнение с функции main ()

но:

Python может выполняться без функции Main

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

Python __name__, __main__ and Arguments

Inside the if condition that checks if the variable __name__ is equal to “__main__” we can also handle any parameters passed to our Python application when called directly.

To handle arguments passed to the application we can use the sys module.

In this code we do the following:

• Import the sys module.
• Define a main() function that takes one argument as input. This argument will be a list of strings that contains the arguments passed to the application when executed.
• Pass sys.argv to the main() function inside the if condition that verifies the value of the __name__ variable.

Here is what happens when we run the program in the terminal:

As you can see the first argument received by the Python program is the name of the file .py itself.

Let’s update the main function to print the type of the args variable.

It confirms that args is a list:

When passing arguments we can also unpack the arguments we need in our program excluding the name of the program itself:

And here is how we run this program and the result we get back:

This code uses the slicing operator to take the two numbers passed via the command line. Then it passes the two numbers (at this point still in string format) to the main() function.

The main function then returns the product of the two numbers converted to integers.

Что такое многопроцессорность в Python?

Многопроцессорность в Python – это способность системы запускать несколько процессов параллельно. Проще говоря, многопроцессорность использует два или более ЦП в одной компьютерной системе. Этот метод также может распределять задачи между процессами.

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

Python предоставляет встроенный пакет, называемый multiprocessing, который поддерживает процессы подкачки. Прежде чем работать с многопроцессорной обработкой, мы должны ознакомиться с объектом процесса.

What is __main__ in Python?

The word __name__ in Python represents a special variable.

There are many special variables in Python that start and end with double underscores. To make it short they are referred to as dunder (from Double Underscores). So __name__ is pronounced “dunder name”.

Let’s see what the value of __main__ is by using the Python shell:

As you can see the value is ‘__main__’.

Now, let’s try to import a Python module to see the value assigned to the __name__ variable associated to the module:

Ok, so after importing the random module we can see that the value of __name__ for the module is ‘random’…basically the name of the module.

We are getting somewhere but maybe if we create our own Python program this can become clearer.

__ name __

Тогда если __name __ == ’ __ main __ ’Как реализован этот код?

Системная встроенная переменная, используемая для представления имени текущего модуля., Какое имя файла1 Когда модуль Pyhon запускается напрямую, значение __name__ равно «main”；

2 Когда модуль импортируется в другие файлы и используется в качестве модуля импорта, __name __ — это имя самого модуля. Например, когда на test.py выше ссылается mode.py как на модуль, __ test.py будетname __ значение test

Другими словами: __name__ имеет 2 значения:

• Когда модуль вызывается для выполнения, значением является имя модуля;
• Когда модуль выполняется напрямую, значение этой переменной: __main __

if name == ‘main’: Суть этого предложения — не что иное, как оценка того, используется ли программный файл в качестве основной записи программы. Если вы запускаете файл программы напрямую, этот файл используется как запись основной программы, имя == ‘main’ main program. Если вВызов других программных файлов при запуске основной программы, Другое имя записи программы! = «Main», естественно, не совпадает с главной главной программой.

Для объяснения модулей Python вы можете обратиться к этой статье Описание модуля / как установить модуль

Модули Python пояснили

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

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

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

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

# Python file one module

print("File one __name__ is set to: {}" .format(__name__))

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

File one __name__ is set to: __main__

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

# Python module to import

print("File two __name__ is set to: {}" .format(__name__))

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

# Python module to execute
import file_two

print("File one __name__ is set to: {}" .format(__name__))

Бег нашего код еще раз покажет, что Переменная в не изменился, и все еще остается набор Отказ Но теперь переменная в устанавливается как его модуль, отсюда Отказ

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

File two __name__ is set to: file_two
File one __name__ is set to: __main__

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

File two __name__ is set to: __main__

Переменная Для файла/модуля, который работает, будет всегда Отказ Но Переменная для всех других модулей, которые импортируются, будут установлены на имя их модуля.

Модуль многопроцессорности в Python

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

Давайте разберемся на простом примере множественной обработки.

Пример –

 
from multiprocessing import Process 
   def disp(): 
      print ('Hello !! Welcome to Python Tutorial') 
      if __name__ == '__main__': 
      p = Process(target=disp) 
      p.start() 
      p.join() 

Выход:

'Hello !! Welcome to Python Tutorial' 

Объяснение:

В приведенном выше коде мы импортировали класс Process, а затем создали объект Process в функции disp(). Затем мы запустили процесс с помощью метода start() и завершили процесс с помощью метода join(). Мы также можем передавать аргументы в объявленную функцию, используя ключевые слова args.

Давайте разберемся в следующем примере многопроцессорной обработки с аргументами.

Пример – 2

 
# Python multiprocessing example  
# importing the multiprocessing module  
  
import multiprocessing  
def cube(n):  
   # This function will print the cube of the given number  
   print("The Cube is: {}".format(n * n * n))  
  
def square(n):  
    # This function will print the square of the given number  
   print("The Square is: {}".format(n * n))  
  
if __name__ == "__main__":  
   # creating two processes  
   process1 = multiprocessing.Process(target= square, args=(5, ))  
   process2 = multiprocessing.Process(target= cube, args=(5, ))  
  
   # Here we start the process 1  
   process1.start()  
   # Here we start process 2  
   process2.start()  
  
   # The join() method is used to wait for process 1 to complete  
   process1.join()  
   # It is used to wait for process 1 to complete  
   process2.join()  
  
   # Print if both processes are completed  
   print("Both processes are finished")

Выход:

The Cube is: 125 
The Square is: 25 
Both processes are finished 

Объяснение:

В приведенном выше примере мы создали две функции: функция cube() вычисляет куб данного числа, а функция square() вычисляет квадрат данного числа.

Затем мы определили объект процесса класса Process, который имеет два аргумента. Первый аргумент – это target, который представляет функцию, которая должна быть выполнена, а второй аргумент – это args, который представляет аргумент, который должен быть передан внутри функции.

 
process1 = multiprocessing.Process(target= square, args=(5, )) 
process2 = multiprocessing.Process(target= cube, args=(5, )) 

Мы использовали метод start(), чтобы запустить процесс.

 
process1.start() 
process2.start() 

Как видно из выходных данных, он ожидает завершения первого процесса, а затем второго процесса. Последний оператор выполняется после завершения обоих процессов.

__name__

Это встроенная переменная, используемая для представления имени текущего модуля, а также отражающая структуру пакета. Например, предположим, что существует следующий пакет:

Содержимое всех файлов py в каталоге:

Мы выполняем, Выходной результат:

Видно, чтоОн может четко отражать уровень модуля в упаковке. Фактически, так называемое имя модуля — это имя, которое нужно использовать при импорте, например:

Здесь tornado и tornado.web называются именами модулей.

Если модуль запускается напрямую, он не имеет структуры пакета.Ценность. Например, в приведенном выше примере мы напрямую запускаем файл c.py (python a / b / c.py), и выходные результаты будут следующими:

и другие,Наше простое понимание:Если модуль запускается напрямую, блок кода запускается, если модуль импортируется, блок кода не запускается。

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

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

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

Копировать

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

Копировать

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

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

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

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

__name__ == ‘__main__’¶

When a Python module or package is imported, is set to the
module’s name. Usually, this is the name of the Python file itself without the
extension:

>>> import configparser
>>> configparser.__name__
'configparser'

If the file is part of a package, will also include the parent
package’s path:

>>> from concurrent.futures import process
>>> process.__name__
'concurrent.futures.process'

However, if the module is executed in the top-level code environment,
its is set to the string .

What is the “top-level code environment”?

is the name of the environment where top-level code is run.
“Top-level code” is the first user-specified Python module that starts running.
It’s “top-level” because it imports all other modules that the program needs.
Sometimes “top-level code” is called an entry point to the application.

The top-level code environment can be:

• the scope of an interactive prompt:

  >>> __name__
  '__main__'
  

• the Python module passed to the Python interpreter as a file argument:

• the Python module or package passed to the Python interpreter with the
  argument:

• Python code read by the Python interpreter from standard input:

• Python code passed to the Python interpreter with the argument:

In each of these situations, the top-level module’s is set to
.

As a result, a module can discover whether or not it is running in the
top-level environment by checking its own , which allows a common
idiom for conditionally executing code when the module is not initialized from
an import statement:

if __name__ == '__main__'
    # Execute when the module is not initialized from an import statement.
    ...

See also

For a more detailed look at how is set in all situations, see
the tutorial section .

Idiomatic Usage

Some modules contain code that is intended for script use only, like parsing
command-line arguments or fetching data from standard input. If a module
like this was imported from a different module, for example to unit test
it, the script code would unintentionally execute as well.

This is where using the code block comes in
handy. Code within this block won’t run unless the module is executed in the
top-level environment.

Putting as few statements as possible in the block below can improve code clarity and correctness. Most often, a function
named encapsulates the program’s primary behavior:

# echo.py

import shlex
import sys

def echo(phrase str) -> None
   """A dummy wrapper around print."""
   # for demonstration purposes, you can imagine that there is some
   # valuable and reusable logic inside this function
   print(phrase)

def main() -> int
    """Echo the input arguments to standard output"""
    phrase = shlex.join(sys.argv)
    echo(phrase)
    return 

if __name__ == '__main__'
    sys.exit(main())  # next section explains the use of sys.exit

Note that if the module didn’t encapsulate code inside the function
but instead put it directly within the block,
the variable would be global to the entire module. This is
error-prone as other functions within the module could be unintentionally using
the global variable instead of a local name. A function solves this
problem.

Using a function has the added benefit of the function itself
being isolated and importable elsewhere. When is imported, the
and functions will be defined, but neither of them will be
called, because .

Conclusion

There is a really nice use case for the variable, whether you want a file that can be run as the main program or imported by other modules. We can use an block to allow or prevent parts of code from being run when the modules are imported.

When the Python interpreter reads a file, the variable is set as if the module being run, or as the module’s name if it is imported. Reading the file executes all top level code, but not functions and classes (since they will only get imported).

Bra gjort! (That means «Well done» in Swedish!)

Check out more articles like this on my freeCodeCamp profile, Medium profile, and other fun stuff I build on my GitHub page.

__main__.py и python -m

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

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

Давайте сначала рассмотрим простой пример. Предположим, что существует файл Python run.py со следующим содержимым:

Мы начинаем с прямого запуска (python run.py) и выводим результат (чтобы проиллюстрировать проблему, результат вывода перехватывает только важную часть, то же самое ниже):

Затем запустите как модуль (python -m run.py):

Поскольку в выводе перечислены только ключевые части, должно быть легко увидеть различия между ними. Прямая операция заключается в помещении каталога, в котором находится файл run.py, в атрибут sys.path. При запуске в модульном режиме каталог, в который вы ввели команду (то есть текущий рабочий путь), помещается в атрибут sys.path. Еще одно отличие работы в модульном режиме состоит в том, что есть дополнительная строкаошибка. Фактически, при запуске в качестве модуля Python сначала выполняет импорт run.py, поэтомуОн успешно выполняется, а затем Python пытается запустить модуль run.py, но в переменной пути нет модуля run.py, поэтому выдается сообщение об ошибке. И правильный способ работы должен быть.

Этот пример не ясно иллюстрирует проблему. Тогда давайте посмотримРоль.

Рассмотрим сначала пример, есть следующий пакет:

__init__.py

__main__.py

использоватьрезультат операции:

использоватьрезультат операции:

Тогда подведем итоги:

• 1、 Когда добавлен параметр -m, текущий рабочий каталог добавляется в sys.path, а когда он не добавляется, каталог, в котором находится скрипт, добавляется в sys.path。
• 2、 Когда добавлен параметр -m, Python сначала импортирует модуль или пакет, а затем выполнит
• 3、 Файл __main__.py — это программа входа в пакет или каталог.Используется ли онВсе еще использоватьВо время выполнения всегда выполняется файл __main__.py.

Как понять python __init__.py

При создании пакета в папке появится файл __init__.py Функция файла init.py заключается в том, чтобы превратить папку в модуль Python, а каждый пакет модуля в Python содержит файл __init__.py.

Обычно файл __init__.py пуст, но мы можем добавить в него другие функции. Когда мы импортируем пакет, мы фактически импортируем его файл __init__.py. Таким образом, мы можем пакетно импортировать необходимые нам модули в файл __init__.py вместо того, чтобы импортировать их по одному. Базовая структура каталогов показана на рисунке 1. __init__.py из TestB и __init__.py из TestB импортируются двумя способами.

__init__.py из testB

Второй способ — использовать переменныеimport module

При вызове первый метод можно напрямую

Второй способ можно использовать напрямую

Конечно, его можно использовать обоими способами, например, непосредственно в файле __init__.py testB.

if __name__ == __main__ в Python

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

Копировать

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

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

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

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

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

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

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

Копировать

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

Копировать

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

Копировать

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

Копировать

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

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

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

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

Детальное объяснение:

Есть два способа использовать файл Python:

• 1，Выполнять прямо как сценарий.
• 2，импорт в другие скрипты Python (файлы .py), импорт выполняется как вызов модуля。

if name == ‘main’: Функция состоит в том, чтобы контролировать процесс выполнения кода в этих двух случаях.name == ‘main’: Приведенный ниже код будет выполнен только в первом случае (то есть файл выполняется непосредственно как сценарий), и он не будет выполняться при импорте в другие сценарии в качестве модуля.

Проще говоря:

if __ name __ == ’ __ main __ ‘означает: когда файл .py запускается напрямую, если __name __== ’ __ main Блок кода под __ ‘будет выполнен; Когда файл .py импортируется как модуль, если __ _name __== ’ __ main Блок кода под __ ‘не выполняется.

Python Modules Explained

Python files are called modules and they are identified by the file extension. A module can define functions, classes, and variables.

So when the interpreter runs a module, the variable will be set as   if the module that is being run is the main program.

But if the code is importing the module from another module, then the  variable will be set to that module’s name.

Let’s take a look at an example. Create a Python module named and paste this top level code inside:

file_one.py

By running this file you will see exactly what we were talking about. The variable for this module is set to :

Now add another file named and paste this code inside:

file_two.py

Also, modify the code in like this so we import the module:

file_one.py

Running our code once again will show that the variable in the did not change, and still remains set to . But now the variable in is set as its module name, hence .

The result should look like this:

But run directly and you will see that its name is set to :

The variable for the file/module that is run will be always . But the variable for all other modules that are being imported will be set to their module’s name.

An Example to Understand __name__ in Python

We have seen how the value of the __name__variable changes depending on how we execute our code.

But, how do we use the condition if __name__ == “__main__” in our Python programs?

To explain this concept we will create a Python program that calls three different functions. We will use the same file understand_name_main.py:

This code runs three functions. The implementation of the three function is a simple print statement because I want you to focus on the concept behind this and not on the implementation of the functions:

Now, let’s say another Python program needs to use the function step1(). To do that we would have to import our file as a module.

Here is what happens when we do that:

After importing the module we can execute the step1() function. The problem is that when we import the module the three lines below are automatically executed:

How can we avoid that?

Ответы.

Ответ 1.

Это тесно связано с тем, как работает интерпретатор Python:

• Когда интерпретатор читает файл кода, он выполняет весь глобальный код в нем. Это предполагает создание объектов для каждой определенной функции или класса и глобальных переменных.
• Каждый модуль (файл кода) в Python имеет специальный атрибут __name__, определяющий пространство имен, в котором он работает. Используется для уникальной идентификации модуля в системе импорта.
• “__main__” – это имя области видимости, в которой выполняется код верхнего уровня (ваша основная программа).
• Интерпретатор передает значение атрибута __name__ в строку ‘__main__‘, если модуль запущен как основная программа (когда вы запускаете его, вызывая интерпретатор в терминале с помощью python my_module.py, дважды щелкая по нему, запуская его в интерактивном интерпретаторе и т.д.).
• Если модуль вызывается не как основная программа, а импортируется из другого модуля, атрибут __name__ становится именем самого файла.

То есть, если у вас есть файл с названием my_modul.py, то при запуске его в качестве основной программы атрибут __name__ будет ‘__main__‘, если вы используете его, импортируя из другого модуля (import my_module), то атрибут __name__ будет равен ‘my_module’.

В основном, используя if name == “main“:, вы проверяете, был ли модуль выполнен напрямую или нет (импортирован). Если он был выполнен как основная программа, то выполняется код внутри условного.

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

Ответ 2.

Оператор if, типа:

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

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

Ответ 3.

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

В Python метод __ name__ – это имя вашего файла.

Например: calculator.py >> он примет __ name__ имя вашего .py файла и сравнит его с __main__, который всегда будет для Python главным файлом, файлом с наивысшей иерархией.

Вы, возможно, задаетесь вопросом: в чем смысл? Зачем мне тратить время на создание условия, если я просто хочу, чтобы программа выполнялась?

Ответ на этот вопрос заключается в следующем.

Давайте представим себе приложение с тысячами .py файлов, и вам поручают проект, который уже делал кто-то другой, как вы узнаете, какой файл является корневым?