когда ваш скрипт запускается, передавая его в качестве команды интерпретатору 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__'] в этом модуле к имени модуля.

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

как вы можете видеть, при выполнении файла Python устанавливает globals()['__name__'] в этом файле "__main__".

что значит if __name__ == "__main__": делать?

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

• глобальная переменная __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, т. е. чтения интерпретатора, Eval, цикла печати или REPL) вы запускаете все из его "__main__".

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

if __name__ == "__main__":
    do_important()

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

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

есть Питонический способ улучшить это, хотя.

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

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

import important
important.main()

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

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

if __name__ == '__main__':
    main()

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

что значит if __name__ == "__main__": делать?

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

как единственный частный случай, однако, в любом процессе 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()

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

взять файл "ab.py":

def a():
    print('A function in ab file');
a()

и второй файл "xy.py":

import ab
def main():
    print('main function: this is where the action is')
def x():
    print ('peripheral task: might be useful in other projects')
x()
if __name__ == "__main__":
    main()

что на самом деле делает этот код?

при выполнении xy.py, вы import ab. Оператор import модуль сразу по импорту, так что abоперации выполняются до того, как остальная часть xy. После того, как закончил с ab на xy.

интерпретатор отслеживает, какие скрипты выполняются с помощью __name__. Когда вы запускаете сценарий - независимо от того, как вы его назвали - интерпретатор называет его "__main__", что делает его основным или "домашним" скриптом, который возвращается после запуска внешнего скрипта.

любой другой скрипт, который вызывается из этого "__main__" скрипту присваивается его имя файла как его __name__ (например, __name__ == "ab.py"). Следовательно, линия if __name__ == "__main__": - это тест интерпретатора, чтобы определить, интерпретирует ли он / анализирует сценарий "home", который был первоначально выполнен, или если он временно заглядывает в другой (внешний) скрипт. Это дает программисту гибкость, чтобы сценарий вел себя по-разному, если он выполняется непосредственно против внешнего вызова.

давайте пройдем через приведенный выше код, чтобы понять, что происходит, фокусируясь сначала по неиндентированным строкам и порядку их появления в скриптах. Запомните эту функцию-или def - блоки ничего не делают сами по себе, пока их не вызовут. Что бы сказал переводчик, если бы пробормотал про себя:--34-->

• открыть xy.py как "домашний" файл; назовите его "__main__" на __name__ переменной.
• импортировать и открыть файл с помощью __name__ == "ab.py".
• о, функция. Я запомню это.
• Ok, функция a(); я только что узнал что. Печать'функция в файле ab'.
• конец файла; вернуться к "__main__"!
• о, функция. Я запомню это.
• еще один.
• функции x(); ok, печать'периферийная задача: может быть полезно в других проектах'.
• что это? Ан if заявление. Ну, условие выполнено (переменная __name__ установлено в "__main__"), поэтому я войду в

  но код работает и без него

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

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

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

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

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

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

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

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

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

при интерактивном запуске 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.

просто __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++, где, если файл не реализует функцию "main", он не может быть скомпилирован как исполняемый файл, и если это так, он не может быть использован в качестве библиотеки.

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

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

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

считаем:

if __name__ == "__main__":
    main()

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

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

что это __name__?

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

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

где:

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

переводчик:

>>> 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, вернет имя файла, из которого он произошел.

практика:

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

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

пример:

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

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

теперь ответ if __name__ == '__main__':

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

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

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

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

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

модули:

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

варианты:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def some_function_for_instance_main():
    dosomething()


__name__ == '__main__' and some_function_for_instance_main()

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

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

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

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

причина

if __name__ == "__main__":
    main()

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

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

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

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

считаем:

print __name__

вывод выше __main__.

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

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

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

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

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

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

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

4. __name__ является неявной переменной во всех .модули py; когда a.py импортируется, значение __name__ of a.модуль py имеет имя файла "a"; когда a.py запускается напрямую с помощью " python a.py", что означает a.py-точка входа, затем значение __name__ of a.модуль py имеет значение string __main__

5. на основе механизма, как python устанавливает переменную __name__ для каждого модуля, вы знаете, как достичь точки 3? Ответ довольно прост, верно? Если поставить условие: if __name__ == "__main__": ...; вы даже можете поставить, если __name__ == "a" в зависимости от функциональной необходимости

важно, что python является особенным в точке 4! Остальное-простая логика.

создать файл, a.py:

print(__name__) # It will print out __main__

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

создать другой файл, б.ру в одном каталоге:

import a  # Prints a

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

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

# Code to be run when imported into another python file

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

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

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

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

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

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

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

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

если имя =='main':

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

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

другими словами, код внутри if блок будет выполняться только при непосредственном запуске кода. Вот!--4--> означает 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__

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

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

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

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

недавно я наткнулся на это при создании класса в python (глубокое обучение) и в моем понимании и в согласии с приведенными выше объяснениями, я разработаю

имя=="main"

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

имя=="main"

xxx=class_name ()

ХХХ.create_data()

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

_ имя _ == _ main _ убедитесь, что код / операторы, присутствующие внутри этого блока, будут выполняться только при непосредственном выполнении этого файла, вместо этого, если мы импортируем его как модуль в другой файл python, мы можем вызвать функцию, определенную в нем, а также блок, который присутствует внутри _ имя == main _ не будет выполняться.

что делает if имя ==" main": что делать?

схема:

1, как исполняемый скрипт, работает для себя как самозанятый: Он выполняет коды в модуле, если запускается непосредственно как "python foo.py"
2, Как импортированный модуль для работы для других:
Его коды можно безопасно использовать повторно, если они импортированы в другой модуль как "import foo"