• Одиночное ведущее подчёркивание:_var
  • Одиночное замыкающее подчёркивание:var_
  • Двойное ведущее подчёркивание:__var
  • Двойное ведущее и замыкающее подчёркивание:__var__
  • Одиночное подчёркивание:_

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

Давайте сразу приступим!

1. Одиночное ведущее подчёркивание _var

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

Смысл префикса подчёркивания состоит в том, чтобы сообщить другим программистам: переменная или метод, начинающиеся с одиночного подчёркивания, предназначены только для внутреннего использования. Это соглашение определено в PEP 8.

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

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

Взгляните на пример ниже:

class Test:
   def __init__(self):
       self.foo = 11
       self._bar = 23

Если вы создадите экземпляр этого класса и попытаетесь получить доступ к атрибутам foo и _bar, определённым в конструкторе __init__, что произойдёт? Давайте посмотрим:

>>> t = Test()
>>> t.foo
11
>>> t._bar
23

Вы увидите, что одиночное подчёркивание в _bar не мешает нам «войти» в класс и получить доступ к значению этой переменной.

Это потому, что префикс с одиночным подчёркиванием в Python — всего лишь соглашение, по крайней мере когда речь идёт об именах переменных и методов.

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

Предположим, у вас есть следующий код в модуле с именем my_module:

# This is my_module.py:

def external_func():
   return 23

def _internal_func():
   return 42

Теперь, если вы используете импорт с подстановочными знаками для импорта всех имён из модуля, Python не будет импортировать имена с ведущим подчёркиванием (если только модуль не определяет список __all__, который переопределяет это поведение):

>>> from my_module import *
>>> external_func()
23
>>> _internal_func()
NameError: "name '_internal_func' is not defined"

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

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

>>> import my_module
>>> my_module.external_func()
23
>>> my_module._internal_func()
42

Я знаю, это может немного запутать. Если вы следуете рекомендации PEP 8 и избегаете импортов с подстановочными знаками, то единственное, что вам действительно нужно запомнить, — это:

Одиночное подчёркивание — это соглашение об именовании в Python, указывающее, что это имя предназначено для внутреннего использования. Обычно оно не контролируется интерпретатором Python, а лишь служит подсказкой для программистов.

2. Одиночное завершающее подчёркивание var_

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

>>> def make_object(name, class):
SyntaxError: "invalid syntax"

>>> def make_object(name, class_):
...    pass

Короче говоря, одиночное завершающее подчёркивание (суффикс) — это соглашение, используемое во избежание конфликтов имён с ключевыми словами Python. PEP 8 объясняет это соглашение.

3. Двойное ведущее подчёркивание __var

До сих пор значения всех рассмотренных нами шаблонов именования происходят из общепринятых соглашений. Но для атрибутов классов Python, начинающихся с двойного подчёркивания (включая переменные и методы), ситуация немного иная.

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

Это также называется искажением имён — интерпретатор изменяет имя переменной, чтобы конфликты были менее вероятны при расширении класса.

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

class Test:
   def __init__(self):
       self.foo = 11
       self._bar = 23
       self.__baz = 23

Давайте воспользуемся встроенной функцией dir(), чтобы посмотреть на атрибуты объекта:

>>> t = Test()
>>> dir(t)
['_Test__baz', '__class__', '__delattr__', '__dict__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'__weakref__', '_bar', 'foo']

Выше приведён список атрибутов этого объекта. Давайте просмотрим этот список и поищем наши исходные имена переменных foo, _bar и __baz — гарантирую, вы заметите некоторые интересные изменения.

Переменная self.foo отображается в списке атрибутов без изменений как foo.

self._bar ведёт себя так же — он появляется в классе как _bar. Как я уже говорил, в этом случае ведущее подчёркивание — это всего лишь соглашение. Просто подсказка программистам. Однако для self.__baz ситуация выглядит немного иначе. Когда вы ищете __baz в этом списке, вы не увидите переменную с таким именем.

Что случилось с __baz?

Если присмотреться, вы увидите, что у этого объекта есть атрибут с именем _Test__baz. Это искажение имён, выполняемое интерпретатором Python. Он делает это, чтобы переменная не была переопределена в подклассах.

Давайте создадим другой класс, наследующий класс Test, и попробуем переопределить существующие атрибуты, добавленные в конструкторе:

class ExtendedTest(Test):
   def __init__(self):
       super().__init__()
       self.foo = 'overridden'
       self._bar = 'overridden'
       self.__baz = 'overridden'

Как вы думаете, появятся ли значения foo, _bar и __baz у экземпляра этого класса ExtendedTest? Давайте посмотрим:

>>> t2 = ExtendedTest()
>>> t2.foo
'overridden'
>>> t2._bar
'overridden'
>>> t2.__baz
AttributeError: "'ExtendedTest' object has no attribute '__baz'"

Подождите минутку, почему мы получаем AttributeError, когда пытаемся посмотреть значение t2 .__ baz? Искажение имён сработало снова! Оказывается, у этого объекта даже нет атрибута __baz:

>>> dir(t2)
['_ExtendedTest__baz', '_Test__baz', '__class__', '__delattr__',
'__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__gt__', '__hash__', '__init__', '__le__',
'__lt__', '__module__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', '_bar', 'foo', 'get_vars']

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

>>> t2._ExtendedTest__baz
'overridden'

Но исходный _Test__baz всё ещё там:

>>> t2._Test__baz
42

Искажение имён с двойным подчёркиванием полностью прозрачно для программиста. Следующий пример это подтверждает:

class ManglingTest:
   def __init__(self):
       self.__mangled = 'hello'

   def get_mangled(self):
       return self.__mangled

>>> ManglingTest().get_mangled()
'hello'
>>> ManglingTest().__mangled
AttributeError: "'ManglingTest' object has no attribute '__mangled'"

Применяется ли искажение имён также к именам методов? Да, применяется. Искажение имён затрагивает все имена, начинающиеся с двух символов подчёркивания ("dunders"), в контексте класса:

class MangledMethod:
   def __method(self):
       return 42

   def call_it(self):
       return self.__method()

>>> MangledMethod().__method()
AttributeError: "'MangledMethod' object has no attribute '__method'"
>>> MangledMethod().call_it()
42

Вот ещё один, возможно, удивительный пример искажения имён в действии:

_MangledGlobal__mangled = 23

class MangledGlobal:
   def test(self):
       return __mangled

>>> MangledGlobal().test()
23

В этом примере я объявил глобальную переменную с именем _MangledGlobal__mangled. Затем я обращаюсь к переменной в контексте класса с именем MangledGlobal. Благодаря искажению имён я могу ссылаться на глобальную переменную _MangledGlobal__mangled как __mangled внутри метода test() класса.

Интерпретатор Python автоматически преобразует имя __mangled в _MangledGlobal__mangled, потому что оно начинается с двух символов подчёркивания. Это показывает, что искажение имён не связано именно с атрибутами класса. Оно применяется к любому имени, начинающемуся с двух символов подчёркивания, используемому в контексте класса.

Здесь многое нужно осмыслить, не так ли?

Честно говоря, эти примеры и объяснения не просто появились у меня в голове сами собой. Я провёл небольшое исследование и поработал над ними. Я использую Python много лет, но такие правила и особые случаи не всегда приходят на ум.

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

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

4. Двойное ведущее и двойное завершающее подчёркивание _var_

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

class PrefixPostfixTest:
   def __init__(self):
       self.__bam__ = 42

>>> PrefixPostfixTest().__bam__
42

Однако Python резервирует имена с двойными ведущими и двойными завершающими подчёркиваниями для специальных целей. Примеры включают конструктор объекта __init__ или __call__ --- который делает объект вызываемым.

Эти dunder-методы часто называют магическими методами - но многим людям в сообществе Python (включая меня) не нравится этот термин.

Лучше избегать использования имён, которые начинаются и заканчиваются двойными подчёркиваниями («dunders»), в ваших собственных программах, чтобы избежать конфликтов с будущими изменениями языка Python.

5. Одинарное подчёркивание _

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

Например, в приведённом ниже цикле нам не нужно обращаться к текущему индексу, поэтому мы можем использовать "_" , чтобы указать, что это просто временное значение:

>>> for _ in range(32):
...    print('Hello, World.')

Вы также можете использовать одиночное подчёркивание как переменную "неважно" в выражениях распаковки, чтобы игнорировать определённые значения. Опять же, это значение только "по соглашению" и не вызывает никакого особого поведения в интерпретаторе Python. Одиночное подчёркивание — это просто допустимое имя переменной, которое служит этой цели.

В приведённом ниже примере кода я распаковываю кортеж car в отдельные переменные, но меня интересуют только значения цвета и пробега. Однако, чтобы выражение распаковки успешно выполнилось, мне нужно присвоить все значения, содержащиеся в кортеже, переменным. В этом случае "_" как переменная-заполнитель оказывается кстати.

>>> car = ('red', 'auto', 12, 3812.4)
>>> color, _, _, mileage = car

>>> color
'red'
>>> mileage
3812.4
>>> _
12

Помимо использования в качестве временной переменной, "_" — это специальная переменная в большинстве REPL Python, которая представляет результат последнего выражения, вычисленного интерпретатором.

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

>>> 20 + 3
23
>>> _
23
>>> print(_)
23

>>> list()
[]
>>> _.append(1)
>>> _.append(2)
>>> _.append(3)
>>> _
[1, 2, 3]

Сводка: шаблоны именования с подчёркиванием в Python

Ниже приведена краткая сводка, "шпаргалка", в которой перечислены значения пяти шаблонов подчёркивания в Python, рассмотренных в этой статье:

Исходный URL: https://zhuanlan.zhihu.com/p/36173202