Что такое name в python

Специальная переменная name в Python

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

Одной из таких переменных является __ name __.

В этой статье, Вы узнаете, как использовать специальную переменную __ name __, и почему она так важна.

Но давайте по порядку.

Модули Python.

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

Так что, когда интерпретатор обрабатывает модуль, переменная __ name __, будет установлена как __ main __ если модуль, который выполняется является основной программой.

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

Рассмотрим на примере вышесказанное. Создадим модуль Python с именем mod_one.py и вставим в него следующий код:

print(«Module one __name__ is: «.format(__name__))

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

# вывод Module one __name__ is: __main__

Теперь добавим еще один файл с именем mod_two.py и вставим следующий код:

print(«Module two __name__ is: » .format(__name__))

Кроме того, немного изменим код в mode_one.py, добавив импорт модуля mod_two:

print(«Module one __name__ is: «.format(__name__))

Запуск нашего кода mod_one еще раз покажет, что переменная __ name __ в mod_one не изменилась и по-прежнему остается установленной в __ main __. Но теперь переменная __ name __ для mod_two задается как имя ее модуля, следовательно, mod_two.

# вывод
Module two __name__ is: mod_two
Module one __name__ is: __main__

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

Module two __name__ is: __main__

Часто в программах используется связка:

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

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

Создано 22.12.2020 08:51:23

Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Кнопка:
Она выглядит вот так:
Текстовая ссылка:
Она выглядит вот так: Как создать свой сайт
BB-код ссылки для форумов (например, можете поставить её в подписи):

Комментарии ( 0 ):

Для добавления комментариев надо войти в систему.
Если Вы ещё не зарегистрированы на сайте, то сначала зарегистрируйтесь.

Специальная переменная name

Специальная переменная __name__ не устанавливается пользователем. Он в основном используется , чтобы проверить , является ли модуль в настоящее время работают самостоятельно или работать , потому что import был выполнен. Чтобы избежать вашего модуля для выполнения определенной части своего кода , когда он импортируется, проверьте , if __name__ == ‘__main__’ .

Пусть module_1.py быть только одна строка длиной:

import module2.py

И давайте посмотрим , что происходит, в зависимости от module2.py Ситуация 1

module2.py

print('hello')

Запуск module1.py напечатает hello \ Запуск module2.py напечатает hello Ситуация 2

module2.py

if __name__ == '__main__': print('hello')

Запуск module1.py не будет печатать ничего \ Запуск module2.py напечатает hello

function_class_or_module . name

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

import os class C: pass def f(x): x += 2 return x print(f) # print(f.__name__) # f print(C) # print(C.__name__) # C print(os) # print(os.__name__) # os

__name__ атрибут, однако, не имя переменной , которая ссылается на класс, метод или функцию, а это имя , данное ему при определен.

def f(): pass print(f.__name__) # f - as expected g = f print(g.__name__) # f - even though the variable is named g, the function is still named f

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

def enter_exit_info(func): def wrapper(*arg, **kw): print '-- entering', func.__name__ res = func(*arg, **kw) print '-- exiting', func.__name__ return res return wrapper @enter_exit_info def f(x): print 'In:', x res = x + 2 print 'Out:', res return res a = f(2) # Outputs: # -- entering f # In: 2 # Out: 4 # -- exiting f

Использовать в журнале

При настройке встроенного logging функциональности, общая картина , чтобы создать регистратор с __name__ текущего модуля:

logger = logging.getLogger(__name__)

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

Зачем name == «main»?

В этой небольшой статье мы рассмотрим один из самых популярных «новичковых» вопросов — зачем нам конструкция if __name__ == «__main__».

Эта статья ориентирована на начинающих разработчиков, я пытаюсь объяснить тему максимально понятно и доступно. Поэтому где-то лукавлю, где-то преувеличиваю, но это для лучшего понимания, не кидайтесь ананасами 🙂

Читать:

Как перенести подписчиков из инстаграм в телеграмм

Прежде чем изучить конструкцию if __ name__ == __»main__«, необходимо знать несколько вещей:

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

В языках программирования существует такое понятие, как точка входа. В некоторых языках программирования (C, C#, Go) конструкция if __name__ = не требуется, потому что в самом начале разработки задается точка входа, без нее компилятор выдаст ошибку. Python же относится к этому лояльно и позволяет пользователю не указывать точку входу (Python в качестве точки входа считает первую строку), что может приводить к серьезным проблемам.

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

Например, у нас есть две программы:

(test.py) выводит значение переменной __name__, а затем строку «Hello world».
(test_2.py) импортирует модуль test.

Если в качестве исходной (откуда происходит запуск) программы мы выберем test.py, то на выводе получаем следующее:

Так как в качестве исходной программы мы выбрали test.py, интерпретатор Python присвоил значение переменной __name__: __main__. Теперь попробуем запустить test_2.py.

Как видим, вместо __main__ мы получили test. Почему это произошло? Потому что мы запустили модуль test, в котором есть строка print(__name__), но так как мы запустили этот код из другой программы (test_2.py), интерпретатор не вывел __main__.

Проще говоря, если мы запускаем программу через «побочную» программу, то переменной __name__ не будет задаваться значение __main__, что позволяет избежать лишнего срабатывания кода. Например:

Мы запустили файл test.py и получили на вывод результат сложения двух чисел и их разность. Также в конце вывели строку, говорящую, что запуск выполнен с помощью test.py. Если же мы импортирует этот модуль в программу test_2.py, то получим на вывод следующее:

А именно сообщение, что мы выполнили действия с помощью test.py, хотя в действительности это не так, ведь мы использовали test_2.py, а не test.py. Чтобы избежать подобного «лишнего» срабатывания фрагментов кода, необходимо в исходном файле (модуле) дописать конструкцию if __name__ == “__main__”. Должно получиться вот так:

Теперь при импортировании модуля test в test_2.py будет выполняться проверка значения переменной __name__. Запускаем наш test_2.py и видим, что теперь срабатывания print(“успешно выполнено с помощью test.py”) не произошло.

Благодарю за прочтение статьи, надеюсь вы подчерпнули из неё что-то новое.

Пишите в комменты какую тему разобрать в следующий раз, всем добра!

Переменная name в Python

Введение в переменную _ _name_ _ и варианты ее использования в Python

Published in

NOP::Nuances of Programming

2 min read
Mar 17, 2019

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

if __name__ == '__main__': 
main()

Рассмотрим пример использования этой переменной при создании модулей в Python.

Зачем использовать переменную _ _name_ _?

Переменная __name__ (два нижних подчеркивания перед и после) — это особая переменная в Python, получающая значение в зависимости от того, каким образом выполняется содержащийся в ней сценарий.

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

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

Какие значения может содержать переменная name?

При запуске сценария значение переменной __name__ равно __main__ . При импортировании кода сценария она будет содержать название сценария.

Рассмотрим два случая использования.

Вариант 1 — Запуск сценария

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

def myFunction(): 
print 'The value of __name__ is ' + __name__def main(): 
myFunction()if __name__ == '__main__': 
main()

При запуске nameScript.py последует нижеприведенный процесс.

До запуска остальной части кода значение переменной __name__ установлено на __main__. После этого запускаются утверждения def main и myFunction . Поскольку установлено значение true, вызывается функция main. В свою очередь, вызывается myFunction. В результате выводится значение __main__ .

Вариант 2 — Импорт сценария в другой сценарий

Чтобы использовать myFunction в другом сценарии, например importingScript.py , импортируем nameScript.py в качестве модуля.

Код importingScript.py выглядит следующим образом:

import nameScript as nsns.myFunction()

Получаем две области видимости: importingScript и nameScript .

В importingScript.py значение переменной __name__ установлено на __main__. При импортировании nameScript Python начинает искать файл, добавив .py к названию модуля, а затем запускает код импортированного файла.

В этом случае значение установлено на nameScript. Снова запускаются утверждения def для main и myFunction. Однако в этот раз установлено значение false, а функция main не вызывается.

В importingScript.py вызываем myFunction, которая выводит nameScript. NameScript становится известен для myFunction при определении функции.

При вводе __name__ в importingScript получаем __main__ , поскольку Python использует значение, известное в области видимости importingScript.

Заключение

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

Специальная переменная __name__ в Python

Комментарии ( 0 ):

Специальная переменная __name__

function_class_or_module .__ name__