if __name__ == "__main__" - это часть, которая запускается, когда сценарий запускается (скажем) из командной строки с помощью такой команды, как python myscript.py.

Когда ваш скрипт запускается путем передачи его как команды интерпретатору Python,

python myscript.py

весь код, который находится на уровне отступа 0, будет выполнен. Определенные функции и классы, в общем, определены, но ни один их код не запускается. В отличие от других языков, здесь нет функции main(), которая запускается автоматически - функция main() неявно представляет собой весь код на верхнем уровне.

В этом случае код верхнего уровня - это блок if. __name__ - это встроенная переменная, которая оценивает имя текущего модуля. Однако, если модуль запускается напрямую (как в myscript.py выше), тогда __name__ вместо этого устанавливается в строку "__main__". Таким образом, вы можете проверить, запускается ли ваш скрипт напрямую или импортируется чем-то другим путем тестирования

if __name__ == "__main__":
    ...

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

# file one.py
def func():
    print("func() in one.py")

print("top-level in one.py")

if __name__ == "__main__":
    print("one.py is being run directly")
else:
    print("one.py is being imported into another module")

# file two.py
import one

print("top-level in two.py")
one.func()

if __name__ == "__main__":
    print("two.py is being run directly")
else:
    print("two.py is being imported into another module")

Теперь, если вы вызовете интерпретатор как

python one.py

Выход будет

top-level in one.py
one.py is being run directly

Если вместо этого вы запустите two.py:

python two.py

Ты получаешь

top-level in one.py
one.py is being imported into another module
top-level in two.py
func() in one.py
two.py is being run directly

Таким образом, когда загружается модуль one, его __name__ становится "one" вместо "__main__".

Самое простое объяснение переменной __name__ (imho) следующее:

Создайте следующие файлы.

# a.py
import b

а также

# b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__

Запустив их, вы получите следующий результат:

$ python a.py
Hello World from b!

Как видите, при импорте модуля Python устанавливает globals()['__name__'] в этом модуле на имя модуля. Кроме того, при импорте выполняется весь код модуля. Поскольку оператор if оценивается как False, эта часть не выполняется.

$ python b.py
Hello World from __main__!
Hello World again from __main__!

Как видите, при выполнении файла Python устанавливает globals()['__name__'] в этом файле на "__main__". На этот раз оператор if оценивается как True и выполняется.

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

Это можно было записать несколькими способами. Другой:

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

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

Когда в нашем модуле (M.py) есть определенные операторы, которые мы хотим выполнить, когда он будет работать как основной (не импортированный), мы можем поместить эти операторы (тестовые примеры, операторы печати) в этот блок if.

По умолчанию (когда модуль работает как основной, а не импортированный) для переменной __name__ установлено значение "__main__", а при импорте переменная __name__ получит другое значение, скорее всего, имя модуля ('M'). Это полезно при одновременном запуске различных вариантов модулей и разделении их конкретных операторов ввода и вывода, а также при наличии каких-либо тестовых примеров.

Коротко, используйте этот блок 'if __name__ == "main"', чтобы предотвратить запуск (определенного) кода при импорте модуля.

What does the if __name__ == "__main__": do?

Чтобы изложить основы:

• Глобальная переменная __name__ в модуле, который является точкой входа в вашу программу, - это '__main__'. В противном случае это имя, под которым вы импортируете модуль.

• Таким образом, код под блоком if будет работать только в том случае, если модуль является точкой входа в вашу программу.

• Это позволяет импортировать код в модуле другими модулями без выполнения блока кода ниже при импорте.

Почему нам это надо?

Разработка и тестирование вашего кода

Допустим, вы пишете скрипт Python, предназначенный для использования в качестве модуля:

def do_important():
    """This function does something very important"""

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

do_important()

и запустив его (в командной строке) примерно так:

~$ python important.py

Проблема

Однако, если вы хотите импортировать модуль в другой скрипт:

import important

При импорте будет вызвана функция do_important, поэтому вы, вероятно, закомментируете вызов функции do_important() внизу.

# do_important() # I must remember to uncomment to execute this!

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

Лучший способ

Переменная __name__ указывает на пространство имен, где в данный момент находится интерпретатор Python.

Внутри импортированного модуля это имя этого модуля.

Но внутри основного модуля (или интерактивного сеанса Python, то есть Read, Eval, Print Loop или REPL интерпретатора) вы запускаете все с его "__main__".

Итак, если вы проверите перед выполнением:

if __name__ == "__main__":
    do_important()

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

Еще лучший способ

Тем не менее, есть способ Pythonic улучшить это.

Что, если мы хотим запустить этот бизнес-процесс извне модуля?

Если мы поместим код, который хотим использовать при разработке и тестировании, в такой функции, а затем сразу же после этого выполним нашу проверку на наличие '__main__':

def main():
    """business logic for when running this module as the primary one!"""
    setup()
    foo = do_important()
    bar = do_even_more_important(foo)
    for baz in bar:
        do_super_important(baz)
    teardown()

# Here's our payoff idiom!
if __name__ == '__main__':
    main()

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

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

import important
important.main()

Эту идиому также можно найти в документации Python в объяснении модуля __main__. Этот текст гласит:

This module represents the (otherwise anonymous) scope in which the interpreter’s main program executes — commands read either from standard input, from a script file, or from an interactive prompt. It is this environment in which the idiomatic “conditional script” stanza causes a script to run:

if __name__ == '__main__':
    main()

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

if __name__ == '__main__':
    # Do something appropriate here, like calling a
    # main() function defined elsewhere in this module.
    main()
else:
    # Do nothing. This module has been imported by another
    # module that wants to make use of the functions,
    # classes and other useful bits it has defined.

What does if __name__ == "__main__": do?

__name__ - это глобальная переменная (в Python глобальная переменная фактически означает уровень модуля), которая существует во всех пространствах имен. Обычно это имя модуля (типа str).

Однако в качестве единственного особого случая в любом запущенном вами процессе Python, например mycode.py:

python mycode.py

в противном случае анонимному глобальному пространству имен присваивается значение '__main__' для его __name__.

Таким образом, включая последние строки

if __name__ == '__main__':
    main()

• в конце вашего скрипта mycode.py,
• когда это основной модуль точки входа, запускаемый процессом Python,

вызовет выполнение уникально определенной функции вашего скрипта main.

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

import mycode
# ... any amount of other code
mycode.main()

Давайте посмотрим на ответ более абстрактно:

Предположим, у нас есть этот код в x.py:

...
<Block A>
if __name__ == '__main__':
    <Block B>
...

Блоки A и B запускаются, когда мы запускаем x.py.

Но просто блок A (а не B) запускается, когда мы запускаем другой модуль, например y.py, в который импортируется x.py, а код запускается оттуда (например, когда функция в x.py вызывается из y.py).

Система (интерпретатор Python) предоставляет ряд переменных для исходных файлов (модулей). Вы можете получить их значения в любое время, поэтому давайте сосредоточимся на переменной / атрибуте __название__:

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

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

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

Если это импортируется из другого модуля, __название__ будет установлено на имя этого модуля.

Итак, в вашем примере частично:

if __name__ == "__main__":
   lock = thread.allocate_lock()
   thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
   thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

означает, что кодовый блок:

lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

будет выполняться только при прямом запуске модуля; кодовый блок не будет выполняться, если другой модуль вызывает / импортирует его, потому что значение __название__ не будет равно «основной» в этом конкретном случае.

Надеюсь, это поможет.

if __name__ == "__main__": - это, по сути, среда сценариев верхнего уровня, и она определяет интерпретатор, который («У меня самый высокий приоритет, который должен быть выполнен первым»).

'__main__' - это имя области, в которой выполняется код верхнего уровня. __name__ модуля устанавливается равным '__main__' при чтении из стандартного ввода, сценария или из интерактивной подсказки.

if __name__ == "__main__":
    # Execute only if run as a script
    main()

Рассмотреть возможность:

print __name__

Вывод для вышеуказанного - __main__.

if __name__ == "__main__":
  print "direct method"

Вышеупомянутое утверждение верно и печатает "прямой метод". Предположим, что если они импортировали этот класс в другой класс, он не печатает "прямой метод", потому что при импорте он установит __name__ equal to "first model name".

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

Итак, если у нас есть два сценария;

#script1.py
print "Script 1's name: {}".format(__name__)

а также

#script2.py
import script1
print "Script 2's name: {}".format(__name__)

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

Script 1's name: __main__

И результат выполнения script2:

Script1's name is script1
Script 2's name: __main__

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

Допустим, вы пишете сценарий Python, который делает что-то отличное, и реализуете множество функций, полезных для других целей. Если я хочу их использовать, я могу просто импортировать ваш скрипт и использовать их, не выполняя вашу программу (учитывая, что ваш код выполняется только в контексте if __name__ == "__main__":). В то время как в C / C++ вам придется разделить эти части в отдельный модуль, который затем включает файл. Представьте себе ситуацию ниже;

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

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

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

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

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

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

You can make the file usable as a script as well as an importable module.

fibo.py (модуль с именем fibo)

# Other modules can IMPORT this MODULE to use the function fib
def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

# This allows the file to be used as a SCRIPT
if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

Ссылка: https://docs.python.org/3.5/tutorial/modules.html

Рассмотреть возможность:

if __name__ == "__main__":
    main()

Он проверяет, является ли атрибут __name__ скрипта Python "__main__". Другими словами, если выполняется сама программа, атрибут будет __main__, поэтому программа будет выполнена (в данном случае функция main()).

Однако, если ваш сценарий Python используется модулем, будет выполнен любой код вне оператора if, поэтому if \__name__ == "\__main__" используется только для проверки того, используется ли программа в качестве модуля или нет, и, следовательно, решает, запускать ли код.

Причина для

if __name__ == "__main__":
    main()

в первую очередь, чтобы избежать проблем блокировка импорта, которые могут возникнуть из-за прямой импорт кода. Вы хотите, чтобы main() запускался, если ваш файл был вызван напрямую (это случай __name__ == "__main__"), но если ваш код был импортирован, то импортер должен ввести ваш код из истинного основного модуля, чтобы избежать проблем с блокировкой импорта.

Побочным эффектом является то, что вы автоматически входите в методологию, которая поддерживает несколько точек входа. Вы можете запустить свою программу, используя main() в качестве точки входа, но тебе не обязательно. В то время как setup.py ожидает main(), другие инструменты используют альтернативные точки входа. Например, чтобы запустить файл как процесс gunicorn, вы определяете функцию app() вместо main(). Как и в случае с setup.py, gunicorn импортирует ваш код, поэтому вы не хотите, чтобы он что-либо делал во время импорта (из-за проблемы с блокировкой импорта).

Создайте файл a.py:

print(__name__) # It will print out __main__

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

Создайте еще один файл, b.py, в том же каталоге:

import a  # Prints a

Запустить его. Он напечатает а, то есть имя файла, который импортируется.

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

# Code to be run when imported into another python file

if __name__ == '__main__':
    # Code to be run only when run directly

Прежде чем что-либо объяснять о if __name__ == '__main__', важно понять, что такое __name__ и для чего он нужен.

What is __name__?

__name__ - это DunderAlias - может рассматриваться как глобальная переменная (доступная из модулей) и работает аналогично global.

Это строка (глобальная, как упомянуто выше), обозначенная type(__name__) (дающая <class 'str'>), и является встроенным стандартом для версий Python 3 и Python 2.

Where:

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

Устный переводчик:

>>> print(__name__)
__main__
>>>

Сценарий:

test_file.py:

print(__name__)

В результате получается __main__

Модуль или пакет:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

В результате получается somefile

Обратите внимание, что при использовании в пакете или модуле __name__ принимает имя файла. Путь к фактическому модулю или пакету не указан, но есть собственный DunderAlias ​​__file__, который позволяет это.

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

Practice:

Переменная означает, что ее значение может будет перезаписано («можно» не означает «следует»), перезапись значения __name__ приведет к нечитаемости. Так что не делайте этого ни по какой причине. Если вам нужна переменная, определите новую переменную.

Всегда предполагается, что значением __name__ будет __main__ или имя файла. Еще раз изменение этого значения по умолчанию вызовет еще большую путаницу, что это принесет пользу, что вызовет проблемы в дальнейшем.

пример:

>>> __name__ = 'Horrify' # Change default from __main__
>>> if __name__ == 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>

В целом считается хорошей практикой включать if __name__ == '__main__' в сценарии.

Now to answer if __name__ == '__main__':

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

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

Это означает, что если __name__ совпадает с __main__, то файл должен быть главным файлом и фактически должен быть запущен (или это интерпретатор), а не модуль или пакет, импортированный в сценарий.

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

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

Modules:

__name__ также может использоваться в модулях для определения имени модуля.

Variants:

С __name__ также можно делать другие, менее распространенные, но полезные вещи, некоторые из которых я покажу здесь:

Выполняется, только если файл является модулем или пакетом:

if __name__ != '__main__':
    # Do some useful things 

Выполнение одного условия, если файл является основным, и другого, если это не так:

if __name__ == '__main__':
    # Execute something
else:
    # Do some useful things

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

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

если название == 'основной':

Смотрим ли __name__ == '__main__': довольно часто.

Он проверяет, импортируется модуль или нет.

Другими словами, код в блоке if будет выполняться только тогда, когда код запускается напрямую. Здесь directly означает not imported.

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

# test.py
def test():
   print('test module name=%s' %(__name__))

if __name__ == '__main__':
   print('call test()')
   test()

Если мы запустим код напрямую через python test.py, имя модуля будет __main__:

call test()
test module name=__main__

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

Предположим, у вас есть два файла Python, a.py и b.py. Теперь a.py импортирует b.py. Мы запускаем файл a.py, где сначала выполняется код «import b.py». Перед запуском остальной части кода a.py необходимо полностью выполнить код в файле b.py.

В коде b.py есть некоторый код, который является эксклюзивным для этого файла b.py, и мы не хотим, чтобы какой-либо другой файл (кроме файла b.py), который импортировал файл b.py, запускал его.

Вот что проверяет эта строка кода. Если это основной файл (например, b.py), выполняющий код, а в данном случае это не так (a.py - это основной запущенный файл), то выполняется только код.

Если этот файл .py импортируется другими файлами .py, код под «оператором if» не будет выполнен.

Если этот .py запускается python this_py.py под оболочкой или дважды щелкнул в Windows. код под «оператором if» будет выполнен.

Обычно пишется для тестирования.

Я так много читал ответы на этой странице. Я бы сказал, что если вы знаете эту вещь, вы наверняка поймете эти ответы, в противном случае вы все равно запутаетесь.

Короче говоря, нужно знать несколько моментов:

1. Действие import a фактически запускает все, что можно запустить в a.py, то есть каждую строку в a.py.

2. Из-за пункта 1 вы можете не захотеть, чтобы все запускалось в a.py при его импорте.

3. Чтобы решить проблему в пункте 2, python позволяет поставить проверку состояния

4. __name__ - это неявная переменная во всех модулях .py:

• когда a.py является imported, значение __name__ модуля a.py устанавливается равным имени его файла "a"
• когда a.py запускается напрямую с использованием «python a.py», значение __name__ устанавливается в строку __main__

5. Знаете ли вы, как достичь точки 3, основываясь на механизме того, как python устанавливает переменную __name__ для каждого модуля? Ответ довольно прост, правда? Поместите условие if: if __name__ == "__main__": // do A

• тогда python a.py запустит часть // do A
• и import a пропустит часть // do A

6. Можно даже если __name__ == "a" поставить в зависимости от ваших функциональных потребностей, но редко.

Важная вещь, в которой Python является особенным, - это пункт 4! Остальное - всего лишь базовая логика.

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

1. Вызов класса из других файлов. Вам просто нужно импортировать его в вызывающую программу.

2. Запустите класс отдельно в целях тестирования.

В последнем случае класс должен содержать общедоступный статический метод void main (). В Python этой цели служит глобально определенная метка '__main__'.

Просто это точка входа для запуска файла, как функция main в языке программирования C.

Каждый модуль в Python имеет атрибут __name__. Значение атрибута __name__ - __main__, когда модуль запускается напрямую, например python my_module.py. В противном случае (например, когда вы говорите import my_module) значение __name__ - это имя модуля.

Небольшой пример для краткого объяснения.

#Script test.py

apple = 42

def hello_world():
    print("I am inside hello_world")

if __name__ == "__main__":
    print("Value of __name__ is: ", __name__)
    print("Going to call hello_world")
    hello_world()

Мы можем выполнить это напрямую как

python test.py  

Выход

Value of __name__ is: __main__
Going to call hello_world
I am inside hello_world

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

#script external_calling.py

import test
print(test.apple)
test.hello_world()

print(test.__name__)

Когда вы выполняете это

python external_calling.py

Выход

42
I am inside hello_world
test

Таким образом, выше самоочевидно, что при вызове теста из другого скрипта, если цикл __name__ в test.py не будет выполняться.

Если интерпретатор python запускает конкретный модуль, глобальная переменная __name__ будет иметь значение "__main__".

  def a():
      print("a")
  def b():
      print("b")

  if __name__ == "__main__": 

          print ("you can see me" )
          a()
  else: 

          print ("You can't see me")
          b()

При запуске этот скрипт печатает ты можешь видеть меня

а

Если вы импортируете этот файл, скажем, A в файл B и выполните файл B, тогда if __name__ == "__main__" в файле A станет ложным, поэтому он напечатает Ты не видишь меня

б

Вы можете проверить специальную переменную __name__ на этом простом примере:

создать file1.py

if __name__ == "__main__":
    print("file1 is being run directly")
else:
    print("file1 is being imported")

создать file2.py

import file1 as f1

print("__name__ from file1: {}".format(f1.__name__))
print("__name__ from file2: {}".format(__name__))

if __name__ == "__main__":
    print("file2 is being run directly")
else:
    print("file2 is being imported")

Выполнить file2.py

выход:

file1 is being imported
__name__ from file1: file1
__name__ from file2: __main__
file2 is being run directly

Код под if __name__ == '__main__':будет выполняться только в том случае, если модуль вызывается как скрипт.

В качестве примера рассмотрим следующий модуль my_test_module.py:

# my_test_module.py

print('This is going to be printed out, no matter what')

if __name__ == '__main__':
    print('This is going to be printed out, only if user invokes the module as a script')

1-й вариант: Импортировать my_test_module.py в другой модуль

# main.py

import my_test_module

if __name__ == '__main__':
    print('Hello from main.py')

Теперь, если вы вызовете main.py:

python main.py 

>> 'This is going to be printed out, no matter what'
>> 'Hello from main.py'

Обратите внимание, что выполняется только оператор print() верхнего уровня в my_test_module.

2-я возможность: вызвать my_test_module.py как скрипт

Теперь, если вы запустите my_test_module.py как скрипт Python, оба оператора print() будут выполнены:

python my_test_module.py

>>> 'This is going to be printed out, no matter what'
>>> 'This is going to be printed out, only if user invokes the module as a script'

Для более подробного объяснения вы можете прочтите это сообщение в блоге.

ОСНОВНАЯ ФУНКЦИЯ PYTHON - это начальная точка любой программы. Когда программа запускается, интерпретатор python запускает код последовательно. Основная функция выполняется только тогда, когда она запускается как программа Python ...

def main():
     print ("i am in the function")
print ("i am out of function")

при запуске скрипта show:

i am out of function

а не код "я в функции" Это потому, что мы не объявили функцию вызова "if__name __ ==" основной ". если вы используете от него:

def main():
     print ("i am in the function")


if __name__ == "__main__":
    main()

print ("i am out of function")

Выход равен

i am in the function
i am out of function

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

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

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

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

Каждый модуль в Python имеет специальный атрибут название. Значение атрибута название устанавливается на «основной», когда модуль выполняется как основная программа (например, работает python foo.py). В противном случае значение название устанавливается равным имени модуля, из которого он был вызван.

Простыми словами:

Код, который вы видите в if __name__ == "__main__":, будет вызван только тогда, когда ваш файл python выполняется как «python example1.py».

Однако, если вы хотите импортировать свой файл python example1.py в качестве модуля для работы с другим файлом python, скажем, example2.py, код под if __name__ == "__main__": не будет запускаться и работать не будет.

if __name__ = "__main__" означает, что если вы обычно запускаете файл python, например python foo.py, он назначит специальную переменную __name__ для "__main__", но если вы импортируете файл, например "import foo", он назначит __name__ для "foo" и не запустит функцию.