Все переменные во многих языках программирования условно разделяются на приватные и публичные. Первые видны исключительно в рамках того класса, в котором они объявляются. Публичные переменные – это те, к которым может получить доступ любая функция в любой части программы. Если говорить о языке Java, то там для объявления приватной переменной необходимо воспользоваться ключевым словом private. С его помощью можно получить доступ к переменным и методам, которые находятся в том же классе. Перезапись таких методов со стороны технически невозможна. В Python все не так. Вместо использования ключевого слова private необходимо использовать два символа нижнего подчеркивания возле любого метода или переменной, которые надо сделать приватными.
Что такое переменные?
Для начала давайте вспомним, что такое вообще переменные в Python. Это что-то типа ячейки, в которой содержится определенная информация. Название переменной в Python начинается с алфавитного символа. цифры либо со знака подчеркивания (о них мы ниже поговорим более подробно), а в его названии не должно присутствовать ключевых слов Python
Поскольку ключевых слов немного, то необходимо просто их запомнить.
and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield.
Чтобы было проще выучить этот список, рекомендуется учить их по 5 штук каждый день. Так за неделю можно выучить весь список.
Или же просто изучайте язык дальше, и этот список автоматически отложится у вас в голове.
Давайте теперь попробуем создать переменную.
name = «Tom»
Здесь мы создали переменную name, в которой будет храниться значение «Tom».
Наименования переменных могут быть двух типов: camel case и underscore notation.
Если мы говорим о Camel Case, то каждое новое подслово в наименовании переменной начинается с новой буквы.
Пример:
userName = "Tom"
Подслова в названии переменной могут разделяться знаком подчеркивания.
user_name = "Tom"
Этот тип наименования и называется Underscore notation.
Обязательно учитывайте то, что названия переменных зависимы от регистра. Следовательно, переменные name и Name будут интерпретатором считаться, как совершенно разные.
В переменных могут храниться исключительно данные одного типа. В Python типов данных очень много, но все они могут быть условно разделены на числа, последовательности, словари, наборы.
Давайте приведем перечень основных типов данных.
- boolean — логическое значение True или False
- int — представляет целое число, например, 1, 4, 8, 50.
- float — представляет число с плавающей точкой, например, 1.2 или 34.76
- complex — комплексные числа
- str — строки, например «hello». В Python 3.x строки представляют набор символов в кодировке Unicode
- bytes — последовательность чисел в диапазоне 0-255
- byte array — массив байтов, аналогичен bytes с тем отличием, что может изменяться
- list — список
- tuple — кортеж
- set — неупорядоченная коллекция уникальных объектов
- frozen set — то же самое, что и set, только не может изменяться (immutable)
- dict — словарь, где каждый элемент имеет ключ и значение
В принципе, если вы уже немного работали с Python, вы должны их знать. Мы привели лишь перечень основных типов данных для напоминания.
Типизация в Python динамическая. Это означает, что в зависимости от присвоенного переменной значения, и зависит тип данных. Процесс автоматический. Это удобно, потому что в других языках программирования такой возможности нет. Приходится каждый раз указывать тип данных, и его невозможно изменить потом. Нужно использовать специальные функции для преобразования, что неудобно.
На практике это работает так. Если переменной присваивается какая-то совокупность символов (без разницы, это буквы или числа), заключенные в кавычки, автоматически тип становится str. Если присваивается целочисленное значение, тип становится int, и так далее.
А если присвоить переменной число с плавающей точкой или экспоненциальную запись, то тогда будет тип float.
x = 3.9e3 print(x) # 3900.0 x = 3.9e-3 print(x) # 0.0039
Обратите внимание: число float может записываться исключительно в 18 значимых символах. Если оказывается, что это число слишком велико, то тогда и используется экспоненциальная запись.
После экспоненты записывается степень числа 10, которая и умножается на число, которое служит значением экспоненты.
То же касается и слишком маленьких чисел, количество знаков после запятой которых слишком большое, чтобы такое число могло уместиться.
Чтобы узнать тип переменной, используется функция type().
А теперь, после того, как мы повторили базовые знания о переменных, давайте перейдем к изучению того, что такое приватные переменные. По умолчанию, все они публичные. Чтобы сделать их приватными, необходимо выполнить определенные действия. Разберемся, какие именно.
Принцип работы приватных переменных в Python
На практике, приватные методы и переменные отсутствуют в Python. По крайней мере, нет специального ключевого слова, предназначенного для этого. Здесь используются два символа нижнего подчеркивания в начале любой переменной либо метода, которые требуется сделать приватными.
Особенность приватных переменных в том, что их нельзя изменять так, как это возможно с публичными. Доступ к последним можно получить абсолютно из любого класса. Следовательно, их значения могут изменяться. Как следствие, могут возникать конфликты разного рода.
Давайте наглядно рассмотрим, как правильно использовать приватные переменные в Python
Приватные переменные: примеры реализации
Давайте сразу приведем первый пример.
class Mainclass:
__private_variable = 2020;
def __private_method(self):
print("Это приватный метод")
def insideclass(self):
print("Приватная переменная:", Mainclass.__private_variable)
self.__private_method()
foo = Mainclass()
foo.insideclass()
Попробуйте запустить этот код. У вас должно получиться что-то типа этого.
Приватная переменная: 2020
Это приватный метод
В этом коде есть класс Mainclass, внутри которого создаются приватные переменные и методы. О том, что доступ к ним ограничен, мы делаем вывод по наличию двух подчеркиваний: __private_variable и __private_method. Только в рамках этого класса можно получить доступ к таким переменным. Если попробовать сделать это из другого класса, будет выдана ошибка. Чтобы продемонстрировать это, давайте приведем второй пример.
class Mainclass:
__private_variable = 2020
def __private_method(self):
print("Это приватный метод")
def insideclass(self):
print("Приватная переменная:", Mainclass.__private_variable)
foo = Mainclass()
foo.insideclass()
foo.__private_method()
Если запустить этот код, вывод получим следующий.
Private Variable: 2020
Traceback (most recent call last):
File «C:\Python37\da.py», line 13, in
foo.__private_method()
AttributeError: ‘Mainclass’ object has no attribute ‘__private_method’
Обратите внимание на то, что в этом приложении используется приватный метод, но при этом осуществляется попытка доступа к нему за пределами класса, в котором он используется. Поэтому возвращается ошибка. Ведь этот атрибут отсутствует у класса, из которого осуществляется вызов.
Таким образом, все методы публичные внутри класса, но они мгновенно становятся приватными, когда к ним пытаются получить доступ за пределами.
Искажение имен – вот, как называется процесс превращения переменных или методов в локальные. Чтобы не было неоднозначности при определении имен подклассов, он и используется. Это же дает возможность не прерывать вызовы методов внутри класса, чтобы перезаписывать методы подклассов.
К слову, настоящей приватности в Python таки нет. А та, что есть, называется «слабым индикатором внутреннего пользователя». В этом случае используется один символ нижнего подчеркивания.
Давайте приведем пример.
class Vehicle:
def _start_engine(self):
return "Создаем мотоцикл."
def run(self):
return self._start_engine()
if __name__ == '__main__':
bike = Vehicle()
print(bike._start_engine())
print("Мотоцикл создан.")
bike.run()
print("Мотоцикл запущен.")
Результат исполнения этой программы будет следующим.
Создаем мотоцикл.
Мотоцикл создан.
Мотоцикл запущен.
В последнем приведенном нами примере мы использовали нижнее подчеркивание для метода _start_engine. Но на деле, такое подчеркивание довольно редко используется. Оно, по сути, имеет ту же функцию, что и двойное подчеркивание, только защита не такая надежная.
Если метод с одним подчеркиванием редактирует любую переменную класса и при этом вызывается, возможны конфликты.
А вот неоднозначности при объявлении приватных переменных можно избежать, если использовать двойное подчеркивание.
Одним словом, приватные переменные в Python немного отличаются от тех, которые есть в C++ или Java. Тем не менее, их можно использовать.
Выводы
Большая часть языков программирования предусматривает 3 модификатора доступа: публичный, приватный и защищенный. Но их использование в Python отличается от других языков программирования.
Приватные переменные – это такие переменные, доступ к которым можно получить исключительно в пределах того класса, в котором они вызываются. Чтобы их объявить, используются одиночные и двойные подчеркивания. Тем не менее, вторые применяются гораздо чаще в силу большей надежности. Они дают возможность получать доступ изнутри класса и выполнять «искажение имен».
