Двойное подчеркивание: Двойная линия (двойное подчеркивание) в Ворде

Двойное нижнее подчеркивание в 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 вместе с вами, читаю, собираю и записываю информацию опытных программистов.

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

Как сделать подчеркивание в Google Таблицах (ярлык)

Перейти к содержимому

Содержание:

Иногда простые методы форматирования могут значительно упростить чтение и использование ваших данных.

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

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

В этом уроке я покажу вам несколько простых методов подчеркивания в Google Таблицах .

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

Подчеркнуть весь текст в ячейке

Если вы хотите подчеркнуть весь текст в ячейке, вы можете сделать это, выполнив следующие действия:

• Выберите ячейку, которую вы хотите подчеркнуть (или диапазон ячеек)
• Выберите в меню опцию Формат.
• Нажмите на опцию «Подчеркнутый».

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

Если вы хотите отменить это изменение, либо повторите те же шаги, либо используйте сочетание клавиш Control + Z

Сочетание клавиш для подчеркивания в Google Таблицах — Control + U (удерживайте клавишу Control и нажмите клавишу U) или Command + U при использовании Mac.

Подчеркнуть определенный текст в ячейке

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

Предположим, у вас есть текст «Hello World» в ячейке, и вы хотите только подчеркнуть слово «Hello».

Ниже приведены шаги для этого:

• Выделите ячейку с текстом, который вы хотите подчеркнуть
• Дважды щелкните ячейку (или нажмите F2), чтобы перейти в режим редактирования.
• Выделите текст, который вы хотите подчеркнуть в ячейке
• Выберите параметр «Формат», а затем нажмите «Подчеркнутый» (или используйте сочетание клавиш Control + U).

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

Подчеркните ячейку (или диапазон ячеек)

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

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

Ниже приведены шаги, чтобы подчеркнуть одну ячейку.

• Выберите ячейку, которую вы хотите подчеркнуть (если вы выберете диапазон ячеек, будут подчеркнуты только нижние)
• Щелкните значок границы на панели инструментов
• Нажмите на опцию нижней границы

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

Если вам нужно двойное подчеркивание, вы можете выбрать опцию «Стиль границы», а затем выбрать опцию двойной границы.

Если вы хотите выбрать диапазон ячеек в столбце и дать всем ячейкам нижнюю границу, выберите параметр «Горизонтальная граница» в параметрах границы на панели инструментов.

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

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

Надеюсь, вы нашли этот урок полезным!

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

Я никогда не обращал внимания на эти специальные символы, пока не узнал, что они означают Ван Дер Бекен на Unsplash

Вы когда-нибудь интересовались различными значениями одинарного и двойного подчеркивания при именовании переменных и функций в Python?

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

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

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

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

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

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

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

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

Прочитайте все истории Ахмеда Бесбеса (и тысяч других авторов на Medium). Ваш членский взнос напрямую поддерживает…

medium.com

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

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

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

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

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

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

Одиночное начальное подчеркивание обычно используется в классах для определения "внутренних" атрибутов. Я заключил внутренних в двойные кавычки, потому что в 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__ используется, чтобы сделать объект вызываемым 9 функция.

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

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

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

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

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

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

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

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

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

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

Как мы видим, был добавлен новый атрибут: _ExtendedCar_brand в то время как _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. До скорого! 👋

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, является «частным», поэтому вам не следует обращаться к нему.

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

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

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

Вывод:

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

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

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

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

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

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

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

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