- Одиночное ведущее подчёркивание:_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