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

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

Лучше

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

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

но внутри основного модуля (или интерактивного сеанса Python, т. е. интерпретатора Read, Eval, Print Loop или 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 тип).

как единственный частный случай, однако, в любом процессе 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 ' s. после того, как закончил с ab на xy.

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

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

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

• открыть xy.py как "домашний" файл; назовите его "__main__" на __name__ переменной.
• импорт и открытие файла с помощью __name__ == "ab.py".
• о, функция. Я запомню это.
• ОК, функция a(); я только что узнал что. Печать'функция в файле ab'.
• конец файла; вернуться к "__main__"!
• о, функция. Я запомню это.
• еще один.
• функции x(); ОК, печать 'периферийная задача: может быть полезно в других проектах'.
• что это? Ан 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++, где, если файл не реализует "основную" функцию, то он не может быть скомпилирован как исполняемый файл, а если это так, то он не может быть использован в качестве библиотеки.

скажем, вы пишете скрипт Python, который делает что-то большое, и вы реализуете множество функций, которые полезны для других целей. Если я хочу использовать их, я могу просто импортировать ваш скрипт и использовать их без выполнения вашей программы (учитывая что ваш код выполняется только в if __name__ == "__main__": контексте). В то время как в 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) предоставляет для исходных файлов (модулей). Вы можете получить их значения в любое время, так что, давайте сосредоточимся на _ _ name__ переменной/атрибутов:

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

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

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

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

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

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

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

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

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

__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__'. Это хорошая конвенция для вызова основного функция в 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. To решите проблему в пункте 2, python позволяет поставить условие check

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

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

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

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

print(__name__) # It will print out __main__

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

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

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

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

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

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

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

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

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

посмотрим, если __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__

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

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

(2) Запустите класс автономно, в целях тестирования.

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

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

имя=="главная"

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

имя=="главная"

xxx=class_name ()

ХХХ.create_data()

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

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

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

схема:

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