Двойное подчеркивание: Двойное нижнее подчеркивание в Python

Двойное нижнее подчеркивание в Python

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

Понимание подчеркивания Python

Символ подчеркивания(_) в Python не прост. Во многих языках подчеркивание используется только для обозначения функций и переменных в snake case; однако Python имеет гораздо более важное применение. Скорее всего, большинству из нас может быть знаком следующий синтаксис:

1. for _ in range(20)
2. __init__(self)
3. _ = 10

Символ подчеркивания(_) передает разные значения при разных условиях.

Ниже указано несколько вариантов использования подчеркивания(_):

1. Использование подчеркивания в интерпретаторе.
2. Для игнорирования значений.
3. Подчеркивание в циклах.
4. Подчеркивание для разделения цифр чисел.
5. Использование подчеркивания для наименования.

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

Эти соглашения об именах подразделяются на два типа:

1. Двойное подчеркивание: __var
2. Двойное начало и конец подчеркивания: __var__

Итак, приступим.

Двойное ведущее подчеркивание

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

Синтаксис двойного нижнего подчеркивания показан ниже:

 
__var 

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

Изменение имени. Интерпретатор Python изменяет имя переменной таким способом, который вызывает затруднения при наследовании класса.

Рассмотрим пример, основанный на этой функциональности.

Пример 1:

 
# defining a class 
class mySample(): 
    # using the __init__() function 
    def __init__(self): 
        self.

  
 first = 10 
        self._second = 15 
        self.__third = 20 
 
# instantiating the class 
myObj = mySample() 
# printing the directory of the object 
print(dir(myObj)) 

Выход:

 ['__class__', 
'__delattr__', 
'__dict__', 
'__dir__', 
'__doc__', 
'__eq__', 
'__format__', 
'__ge__', 
'__getattribute__', 
'__gt__', 
'__hash__', 
'__init__', 
'__init_subclass__', 
'__le__', 
'__lt__', 
'__module__', 
'__ne__', 
'__new__', 
'__reduce__', 
'__reduce_ex__', 
'__repr__', 
'__setattr__', 
'__sizeof__', 
'__str__', 
'__subclasshook__', 
'__weakref__', 
'_mySample__third', 
'_second', 
'first'] 

Объяснение:

В приведенном выше фрагменте кода мы определили класс как mySample() и использовали функцию инициализации для объявления некоторых значений. Затем мы создали экземпляр класса, используя объект myObj. Наконец, мы распечатали каталог объекта.

В результате приведенный выше блок кода возвращает все атрибуты объекта класса. Теперь давайте посмотрим на переменные в списке атрибутов.

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

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

Однако мы можем наблюдать некоторые изменения в случае переменной self .__ third.

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

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

Пример:

 
# defining a class 
class mySample(): 
    # using the __init__() function 
    def __init__(self): 
        self.first = 10 
        self._second = 15 
        self. __third = 20 
# defining a child class 
class AnotherClass(mySample): 
    def __init__(self): 
        super().__init__() 
        self.first = "Variable Overridden" 
        self._second = "Variable Overridden" 
        self.__third = "Variable Overridden" 
# instantiating the child class 
myobj = AnotherClass() 
# printing the values of variables 
print(myobj.first) 
print(myobj._second) 
print(myobj.__third) 

Выход:

 Variable Overridden 
Variable Overridden 
Traceback(most recent call last): 
  File "D:\Python\ternarypy.py", line 24, in  
    print(myobj.__third) 
AttributeError: 'AnotherClass' object has no attribute '__third' 

Объяснение:

В приведенном выше фрагменте кода мы определили класс как mySample() и использовали функцию инициализации для объявления некоторых переменных. Затем мы определили дочерний класс для класса mySample(), где мы использовали функцию super() для наследования переменных из родительского класса и их отмены.

Наконец, мы создали дочерний класс и распечатали значения замещающих переменных.

В результате сообщения первых двух переменных печатаются успешно; однако программа вызвала исключение в случае переменной «__third». Это происходит из-за искажения имени, которое изменило myObj .__ third на _AnotherClass__third.

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

Пример 2:

 
# defining a class 
class mySample(): 
    # using the __init__() function 
    def __init__(self): 
        self.first = 10 
        self._second = 15 
        self.__third = 20 
# defining a child class 
class AnotherClass(mySample): 
 
    def __init__(self): 
        super().__init__() 
        self.first = "Variable Overridden" 
        self._second = "Variable Overridden" 
        self.__third = "Variable Overridden" 
# instantiating the child class 
myobj = AnotherClass() 
# printing the value(s) of variable(s) 
print(myobj.  _AnotherClass__third) 

Выход:

 Variable Overridden 

Объяснение:

В приведенном выше фрагменте кода мы можем заметить, что мы использовали переменную «_AnotherClass__third» вместо переменной «__third» для доступа к значению переменной.

Мы можем получить доступ к двойным ведущим переменным Underscore с помощью методов в классе. Рассмотрим пример, основанный на этой функциональности.

Пример 3:

 
# defining the class 
class myClass: 
    # initializing function 
    def __init__(self): 
        self.__myVar = "Welcome" 
    # defining another method to return the variable 
    def get_Var(self): 
        return self.__myVar 
# instantiating the class 
myObj = myClass() 
# it returns the "Welcome" which is a __var 
print(myObj.get_Var()) 
# here, an error is raised as stated before. It alters the variable's name 
print(myObj.
 
 __myVar) 

Выход:

 Welcome 
Traceback(most recent call last): 
  File "D:\Python\ternarypy.py", line 15, in  
    print(myObj.__myVar) 
AttributeError: 'myClass' object has no attribute '__myVar' 

Объяснение:

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

В результате программа возвращает оператор «Добро пожаловать» при печати метода. Однако он также вызвал исключение для другого метода, поскольку он изменяет имя переменной.

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

Пример 4:

 
# defining a class 
class myClass: 
    # defining a double-leading underscore function 
    def __myfunction(self): 
        return "Welcome" 
    # defining a function to call the above function 
    def call_function(self): 
        return self.

  
 __myfunction() 
# instantiating the class 
myObj = myClass() 
# printing the value within the function 
print(myObj.call_function()) 
# raised an error 
print(myObj.__myfunction()) 

Выход:

 Welcome 
Traceback(most recent call last): 
  File "D:\Python\ternarypy.py", line 14, in  
    print(myObj.__myfunction()) 
AttributeError: 'myClass' object has no attribute '__myfunction' 

Объяснение:

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

Теперь давайте разберемся с другим способом искажения имен. Прежде всего, мы объявим переменную с именем _myClass__myVar, и мы попытаемся получить доступ к этой переменной, используя двойное начальное имя Underscore.

Пример 5:

 
# declaring a variable 
_myClass__myVar = "Welcome" 
# defining a class 
class myClass: 
    # defining a function to return the declared variable 
    def call_function(self): 
        return __myVar 
# instantiating the class 
myObj = myClass() 
# printing the value of the variable 
print(myObj. call_function()) 

Выход:

Welcome 

Объяснение:

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

Двойные начальное и конечное подчеркивания

В языке программирования, таком как Python, мы обнаружим различные имена, которые начинаются и заканчиваются двойным подчеркиванием. Эти соглашения об именах известны как методы Magic или методы Dunder.

Синтаксис двойного начального и конечного подчеркивания показан ниже:

 
__var__ 

Рассмотрим пример, основанный на магических методах.

Пример:

 
# defining a class 
class myClass: 
    # using a magic method 
    def __init__(self): 
        # using a magic method as variable name 
        self. __myNum__ = 10 
# instantiating the class 
myObj = myClass() 
# printing the value of the variable 
print(myObj.__myNum__) 

Выход:

10 

Объяснение:

В приведенном выше фрагменте кода мы определили класс. Мы определили магический метод как функцию __init __() внутри класса, также известную как функция инициализации. Затем мы объявили переменную как __num__. Наконец, мы создали экземпляр класса и распечатали значение переменной.

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

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

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

Еще для изучения:

«Как на компе убрать двойное подчеркивание в ворде?» — Яндекс Кью

Популярное

Сообщества

Светлана Аникиева

164Z»>9 октября 2018  ·

21,4 K

ОтветитьУточнить

Светлана Карманова

15,3 K

Имею психологическое образование. Интересуюсь устройством мира.   · 8 февр 2019

Выделить фрагмент или слово, щелкнуть правой кнопкой мыши, появляется окно, нужно выбрать «Шрифт». Там будет поле с названием «Подчёркивание». В поле, по идее, две линии, справа от них, в том же поле, выпадающее меню(стрелочка вниз). Нужно на нее нажать и убрать двойное подчеркивание. В верхнем меню, рядом с кнопкой «Ч», тоже должно быть выпадающее меню, можно попробовать от туда. Можно поменять стиль подчеркивания или убрать его совсем.

Галина Далецкая

9 декабря 2019

Кот лапами встал на клаву и образовалось двойное подчёркивание. Кук убрать? Видимо надо нажать на какую -то… Читать дальше

Комментировать ответ…Комментировать…

Анна Бекер

73

филолог, интересуюсь психологией  · 15 апр 2019

К сожалению, Ваши методы не работают, т. к моё подчёркивание образовалось в момент когда я для себя отделила часть текста дефисами — после того как нажала Enter, образовалась двойная черта (на которую махнула рукой, подумав, что уберу потом). Какие-то убрала методом тыка (увеличивая кол-во страниц Энтером и дальше Делетом), но вот одна после перезахода в файл всё равно… Читать далее

Анна Бекер

15 апреля 2019

Мне помогло следующее: поставить курсор в строке над чертой и выбрать в меню «Главная-Границы-нет границ».

Комментировать ответ…Комментировать…

Олег777

14

12 авг 2021

Двойное подчёркивание пропадёт если в открытом документе Microsoft Word нажать на «Файл» и в открывшемся меню перейти на «Параметры» —

«Правописание» и там снять галочку с «Отмечать грамматические ошибки в процессе набора текста».

Комментировать ответ…Комментировать…

Анонимный ответ15 марта 2021

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

Элина Цигельман

9 июня 2021

спасибо большое помогло

Комментировать ответ…Комментировать…

Вы знаете ответ на этот вопрос?

Поделитесь своим опытом и знаниями

Войти и ответить на вопрос

Что означают одиночные и двойные символы подчеркивания в Python? | by Ahmed Besbes

Я никогда не обращал внимания на эти специальные символы, пока не узнал, что они означают. и функции в Python?

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

В этом посте рассказывается о различных способах использования символов подчеркивания. It’ll cover:

1. single leading underscores: _foo
2. single trailing underscores: foo_
3. single underscores: _
4. double leading and конечные символы подчеркивания (используются при определении методов dunder ): __bar__
5. двойное начальное подчеркивание: __bar

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

Это также поможет вам соответствовать стандартным соглашениям об именах.

Давайте без лишних слов рассмотрим несколько практических примеров 🔍

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

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

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

Рассмотрим следующий файл module.py , в котором определены две переменные.

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

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

Одиночное начальное подчеркивание обычно используется в классах для определения «внутренних» атрибутов. Я заключил в двойные кавычки внутренний , потому что в Python нет такой вещи, как внутренние атрибуты. Ведущее подчеркивание остается обозначением и должно рассматриваться как таковое.

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

Давайте рассмотрим пример: рассмотрим класс Employee, который определяет атрибут _seniority , который, среди прочего, необходим для расчета компенсационного пакета.

Как видите, к атрибуту _seniority можно получить доступ извне класса.

В некоторых ситуациях вы хотите использовать имя переменной, которое на самом деле является зарезервированным ключевым словом в Python, например class , def , type , object и т. д.

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

  class_ = "A"  

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

Вот они в двух словах.

→ Для определения временных или неиспользуемых переменных.

Пример #1
Если вы не используете текущий индекс цикла for, вы можете легко заменить его одним символом подчеркивания.

Пример #2
Если ваша функция возвращает кортеж из пяти элементов, но вам нужно использовать только два из них (например, первый и четвертый), вы можете использовать подчеркивание для имени трех оставшихся элементов.

→ Результат последней оценки в интерактивном интерпретаторе Python сохраняется в «_».

→ Для использования в качестве визуального разделителя для цифровой группировки

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

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

Двойные начальные и конечные символы подчеркивания используются для определения специальных методов универсального класса, называемых методами dunder (сокращение от D двойных методов оценки Under ).

Методы Dunder — это зарезервированные методы, которые вы все равно можете перезаписать. Они имеют особое поведение и называются по-разному. Например:

• __init__ используется как конструктор класса
• __call__ используется для того, чтобы сделать объект вызываемым.
• __str__ используется для определения того, что будет напечатано на экране, когда мы передаем объект в функцию print .

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

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

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

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

Для иллюстрации рассмотрим следующий класс:

Теперь проверим атрибуты объекта car с помощью встроенного метода dir .

Мы заметили, что цвет и _скорость доступны, но не __марка .

Однако есть _Car__brand 9вместо атрибута 0021. Это искажение имени: интерпретатор добавляет перед атрибутом один «_» плюс имя класса. Это сделано для того, чтобы избежать переопределения значения атрибута __brand в подклассах.

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

Теперь давайте проверим атрибуты объекта extended_car :

Как мы видим, был добавлен новый атрибут:0018 _Car_brand из родительского класса все еще там.

Если мы попытаемся получить доступ к этим двум атрибутам:

Мы заметим, что значение атрибута __brand (из родительского класса) не было переопределено, хотя определение класса ExtendedCar предполагает это.

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

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

• https://towardsdatascience.com/5- different-meanings-of-underscore-in-python-3fafa6cd0379
• https://www.python.org/dev/peps/pep-0515/
• https: //www.python.org/dev/peps/pep-0008/
• Сообщение в французском блоге о Дандерсе: https://he-arc.github.io/livre-python/dunders/index.html
• https: //www.section.io/engineering-education/dunder-methods-python/

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

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

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

Краткая история о *args и **kwargs

в направленииdatascience.com

На сегодня у меня все. До скорого! 👋

Впервые на Medium? Вы можете подписаться за 5 долларов в месяц и разблокировать неограниченное количество статей на различные темы (технологии, дизайн, предпринимательство…) Вы можете поддержать меня, нажав на мою реферальную ссылку ссылка

Присоединяйтесь к Medium по моей реферальной ссылке — Ahmed Besbes

Как член Medium, часть вашего членского взноса идет авторам, которых вы читаете, и вы получаете полный доступ к каждой истории…

ahmedbesbes.medium.com

Photo by Karsten Winegeart on Unsplash

python — Что означает одиночное и двойное подчеркивание перед именем объекта?

Одиночное подчеркивание в начале:

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

 класс BaseForm(StrAndUnicode):
    защита _get_errors (я):
        «Возвращает ErrorDict для данных, предоставленных для формы»
        если self._errors равно None:
            self.full_clean ()
        вернуть self._errors
    ошибки = свойство (_get_errors)
 

(Этот фрагмент кода был взят из исходного кода django: django/forms/forms.py). В этом коде ошибок является общедоступным свойством, но метод, вызываемый этим свойством, _get_errors, является «приватным», поэтому вам не следует обращаться к нему.

Два подчеркивания в начале:

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

 класс A (объект):
    деф __тест(сам):
        print "Я тестовый метод в классе A"
    защитный тест (сам):
        самопроверка()
а = А()
тест()
# a. __test() # Это завершается ошибкой AttributeError
a._A__test() # Работает! Мы можем получить доступ к искаженному имени напрямую!
 

Вывод:

 $ python test.py
Я тестовый метод в классе А
Я тестовый метод в классе А
 

Теперь создайте подкласс B и выполните настройку для метода __test

 класса B(A):
    деф __тест(сам):
        print "Я тестовый метод в классе B"
б = В()
б.тест()
 

Вывод будет….

 $ python test.py
Я тестовый метод в классе А
 

Как мы видели, A.test() не вызывает методы B.__test(), как можно было бы ожидать. Но на самом деле это правильное поведение для __. Два метода с именем __test() автоматически переименовываются (искажаются) в _A__test() и _B__test(), поэтому они не переопределяются случайно. Когда вы создаете метод, начинающийся с __, это означает, что вы не хотите, чтобы кто-либо мог его переопределить, и вы намереваетесь получить к нему доступ только из своего собственного класса.

Два символа подчеркивания в начале и в конце:

Когда мы видим метод вроде __this__ , не вызывайте его.