Инкапсуляция, наследование, полиморфизм
Недавно мы говорили об основах объектно-ориентированного программирования в python, теперь продолжим эту тему и поговорим о таких понятиях ООП, как инкапсуляция, наследование и полиморфизм.
Инкапсуляция
Инкапсуляция — ограничение доступа к составляющим объект компонентам (методам и переменным). Инкапсуляция делает некоторые из компонент доступными только внутри класса.
Инкапсуляция в Python работает лишь на уровне соглашения между программистами о том, какие атрибуты являются общедоступными, а какие — внутренними.
Одиночное подчеркивание в начале имени атрибута говорит о том, что переменная или метод не предназначен для использования вне методов класса, однако атрибут доступен по этому имени.
Двойное подчеркивание в начале имени атрибута даёт большую защиту: атрибут становится недоступным по этому имени.
File
Однако полностью это не защищает, так как атрибут всё равно остаётся доступным под именем _ИмяКласса__ИмяАтрибута:
Наследование
Наследование подразумевает то, что дочерний класс содержит все атрибуты родительского класса, при этом некоторые из них могут быть переопределены или добавлены в дочернем. Например, мы можем создать свой класс, похожий на словарь:
Для вставки кода на Python в комментарий заключайте его в теги
- Модуль csv - чтение и запись CSV файлов
- Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
- Онлайн-обучение Python: сравнение популярных программ
- Книги о Python
- GUI (графический интерфейс пользователя)
- Курсы Python
- Модули
- Новости мира Python
- NumPy
- Обработка данных
- Основы программирования
- Примеры программ
- Типы данных в Python
- Видео
- Python для Web
- Работа для Python-программистов
- Сделай свой вклад в развитие сайта!
- Самоучитель Python
- Карта сайта
- Отзывы на книги по Python
- Реклама на сайте
Что такое инкапсуляция в python
По умолчанию атрибуты в классах являются общедоступными, а это значит, что из любого места программы мы можем получить атрибут объекта и изменить его. Например:
class Person: def __init__(self, name, age): self.name = name # устанавливаем имя self.age = age # устанавливаем возраст def print_person(self): print(f"Имя: \tВозраст: ") tom = Person("Tom", 39) tom.name = "Человек-паук" # изменяем атрибут name tom.age = -129 # изменяем атрибут age tom.print_person() # Имя: Человек-паук Возраст: -129
Но в данном случае мы можем, к примеру, присвоить возрасту или имени человека некорректное значение, например, указать отрицательный возраст. Подобное поведение нежелательно, поэтому встает вопрос о контроле за доступом к атрибутам объекта.
С данной проблемой тесно связано понятие инкапсуляции. Инкапсуляция является фундаментальной концепцией объектно-ориентированного программирования, которая предполагает скрытие функционала и предотвращение прямого доступа извне к нему.
Язык программирования Python позволяет определить приватные или закрытые атрибуты. Для этого имя атрибута должно начинаяться с двойного подчеркивания - __name . Например, перепишем предыдущую программу, сделав оба атрибута - name и age приватными:
class Person: def __init__(self, name, age): self.__name = name # устанавливаем имя self.__age = age # устанавливаем возраст def print_person(self): print(f"Имя: \tВозраст: ") tom = Person("Tom", 39) tom.__name = "Человек-паук" # пытаемся изменить атрибут __name tom.__age = -129 # пытаемся изменить атрибут __ tom.print_person() # Имя: Tom Возраст: 39
В принципе мы также можем попытаться установить для атрибутов __name и __age новые значения:
tom.__name = "Человек-паук" # пытаемся изменить атрибут __name tom.__age = -129 # пытаемся изменить атрибут __
Но вывод метода print_person покажет, что атрибуты объекта не изменили свои значения:
tom.print_person() # Имя: Tom Возраст: 39
Как это работает? При объявлении атрибута, имя которого начинается с двух прочерков, например, __attribute , Python в реальности определяет атрибута, который называется по шаблону _ClassName__atribute . То есть в случае выше будут создаваться атрибуты _Person__name и _Person__age . Поэтому к такому атрибуту мы сможем обратиться только из того же класса. Но не сможем обратиться вне этого класса. Например, присвоение значения этому атрибуту ничего не даст:
tom.__age = 43
Потому что в данном случае просто определяется динамически новый атрибут __age, но это он не имеет ничего общего с атрибутом self.__age или точнее self._Person__age .
А попытка получить его значение приведет к ошибке выполнения (если ранее не была определена переменная __age):
print(tom.__age)
Тем не менее приватность атрибутов тут довольно относительна. Например, мы можем использовать полное имя атрибута:
class Person: def __init__(self, name, age): self.__name = name # устанавливаем имя self.__age = age # устанавливаем возраст def print_person(self): print(f"Имя: \tВозраст: ") tom = Person("Tom", 39) tom._Person__name = "Человек-паук" # изменяем атрибут __name tom.print_person() # Имя: Человек-паук Возраст: 39
Тем нее менее автор внешнего кода еще должен угадать, как называются атрибуты.
Методы доступа. Геттеры и сеттеры
Может возникнуть вопрос, как обращаться к подобным приватным атрибутам. Для этого обычно применяются специальные методы доступа. Геттер позволяет получить значение атрибута, а сеттер установить его. Так, изменим выше определенный класс, определив в нем методы доступа:
class Person: def __init__(self, name, age): self.__name = name # устанавливаем имя self.__age = age # устанавливаем возраст # сеттер для установки возраста def set_age(self, age): if 0 < age < 110: self.__age = age else: print("Недопустимый возраст") # геттер для получения возраста def get_age(self): return self.__age # геттер для получения имени def get_name(self): return self.__name def print_person(self): print(f"Имя: \tВозраст: ") tom = Person("Tom", 39) tom.print_person() # Имя: Tom Возраст: 39 tom.set_age(-3486) # Недопустимый возраст tom.set_age(25) tom.print_person() # Имя: Tom Возраст: 25
Для получения значения возраста применяется метод get_age:
def get_age(self): return self.__age
Для изменения возраста определен метод set_age:
def set_age(self, age): if 0 < age < 110: self.__age = age else: print("Недопустимый возраст")
Причем опосредование доступа к атрибутам через методы позволяет задать дополнительную логику. Так, в зависимости от переданного возраста мы можем решить, надо ли переустанавливать возраст, так как переданное значение может быть некорректным.
Также еобязательно создавать для каждого приватного атрибута подобную пару методов. Так, в примере выше имя человека мы можем установить только из конструктора. А для получение определен метод get_name.
Аннотации свойств
Выше мы рассмотрели, как создавать методы доступа. Но Python имеет также еще один - более элегантный способ - свойства . Этот способ предполагает использование аннотаций, которые предваряются символом @.
Для создания свойства-геттера над свойством ставится аннотация @property .
Для создания свойства-сеттера над свойством устанавливается аннотация имя_свойства_геттера.setter .
Перепишем класс Person с использованием аннотаций:
class Person: def __init__(self, name, age): self.__name = name # устанавливаем имя self.__age = age # устанавливаем возраст # свойство-геттер @property def age(self): return self.__age # свойство-сеттер @age.setter def age(self, age): if 0 < age < 110: self.__age = age else: print("Недопустимый возраст") @property def name(self): return self.__name def print_person(self): print(f"Имя: \tВозраст: ") tom = Person("Tom", 39) tom.print_person() # Имя: Tom Возраст: 39 tom.age = -3486 # Недопустимый возраст (Обращение к сеттеру) print(tom.age) # 39 (Обращение к геттеру) tom.age = 25 # (Обращение к сеттеру) tom.print_person() # Имя: Tom Возраст: 25
Во-первых, стоит обратить внимание, что свойство-сеттер определяется после свойства-геттера.
Во-вторых, и сеттер, и геттер называются одинаково - age. И поскольку геттер называется age, то над сеттером устанавливается аннотация @age.setter .
После этого, что к геттеру, что к сеттеру, мы обращаемся через выражение tom.age .
Инкапсуляция, наследование, полиморфизм
В предыдущей статье было написано об основах объектно-ориентированного программирования в python, теперь продолжим эту тему и поговорим о таких понятиях ООП, как инкапсуляция, наследование и полиморфизм.
Инкапсуляция
Инкапсуляция — ограничение доступа к составляющим объект компонентам (методам и переменным). Инкапсуляция делает некоторые из компонент доступными только внутри класса.
Инкапсуляция в Python работает лишь на уровне соглашения между программистами о том, какие атрибуты являются общедоступными, а какие — внутренними.
Одиночное подчеркивание в начале имени атрибута говорит о том, что переменная или метод не предназначен для использования вне методов класса, однако атрибут доступен по этому имени.
class A: def _private(self): print("Это приватный метод!") >>> a = A() >>> a._private() Это приватный метод!
Двойное подчеркивание в начале имени атрибута даёт большую защиту: атрибут становится недоступным по этому имени.
>>> class B: . def __private(self): . print("Это приватный метод!") . >>> b = B() >>> b.__private() Traceback (most recent call last): File "", line 1, in AttributeError: 'B' object has no attribute '__private'
Однако полностью это не защищает, так как атрибут всё равно остаётся доступным под именем _ИмяКласса__ИмяАтрибута:
>>> b._B__private() Это приватный метод!
Наследование
Наследование подразумевает то, что дочерний класс содержит все атрибуты родительского класса, при этом некоторые из них могут быть переопределены или добавлены в дочернем. Например, мы можем создать свой класс, похожий на словарь:
>>> class Mydict(dict): . def get(self, key, default = 0): . return dict.get(self, key, default) . >>> a = dict(a=1, b=2) >>> b = Mydict(a=1, b=2)
Класс Mydict ведёт себя точно так же, как и словарь, за исключением того, что метод get по умолчанию возвращает не None, а 0.
>>> b['c'] = 4 >>> print(b) >>> print(a.get('v')) None >>> print(b.get('v')) 0
Полиморфизм
Полиморфизм — разное поведение одного и того же метода в разных классах. Например, мы можем сложить два числа, и можем сложить две строки. При этом получим разный результат, так как числа и строки являются разными классами.
>>> 1 + 1 2 >>> "1" + "1" '11'
Инкапсуляция в Python
Под инкапсуляцией в объектно-ориентированном программировании понимается упаковка данных и методов для их обработки вместе, то есть в классе. В Python инкапсуляция реализуется как на уровне классов, так и объектов. В ряде других языков, например в Java, под инкапсуляцией также понимают сокрытие свойств и методов, в результате чего они становятся приватными. Это значит, что доступ к ним ограничен либо пределами класса, либо модуля.
В Python подобной инкапсуляции нет, хотя существует способ ее имитировать. Перед тем как выяснять, как это делается, надо понять, зачем вообще что-то скрывать.
Дело в том, что классы бывают большими и сложными. В них может быть множество вспомогательных полей и методов, которые не должны использоваться за его пределами. Они просто для этого не предназначены. Они своего рода внутренние шестеренки, обеспечивающие нормальную работу класса.
Кроме того, в других языках программирования хорошей практикой считается сокрытие всех полей объектов, чтобы уберечь их от прямого присвоения значений из основной ветки программы. Их значения можно изменять и получать только через вызовы методов, специально определенных для этих целей.
Например, если надо проверять присваиваемое полю значение на корректность, то делать это каждый раз в основном коде программы будет неправильным. Проверочный код должен быть помещен в метод, который получает данные для присвоения полю. А само поле должно быть закрыто для доступа извне класса. В этом случае ему невозможно будет присвоить недопустимое значение.
Часто намеренно скрываются поля самого класса, а не его объектов. Например, если класс имеет счетчик своих объектов, то необходимо исключить возможность его случайного изменения извне. Рассмотрим пример с таким счетчиком на языке Python.
class B: count = 0 def __init__(self): B.count += 1 def __del__(self): B.count -= 1 a = B() b = B() print(B.count) # выведет 2 del a print(B.count) # выведет 1
Все работает. В чем тут может быть проблема? Проблема в том, что если в основной ветке где-то по ошибке или случайно произойдет присвоение полю B.count , то счетчик будет испорчен:
… B.count -= 1 print(B.count) # выведет 0, хотя остался b
Для имитации сокрытия атрибутов в Python используется соглашение (соглашение – это не синтаксическое правило языка, при желании его можно нарушить), согласно которому, если поле или метод имеют два знака подчеркивания впереди имени, но не сзади, то этот атрибут предусмотрен исключительно для внутреннего пользования:
class B: __count = 0 def __init__(self): B.__count += 1 def __del__(self): B.__count -= 1 a = B() print(B.__count)
Попытка выполнить этот код приведет к выбросу исключения:
. print(B.__count) AttributeError: type object 'B' has no attribute '__count'. Did you mean: '_B__count'?
То есть атрибут __count за пределами класса становится невидимым, хотя внутри класса он вполне себе видимый.
На самом деле сокрытие в Python не настоящее и доступ к счетчику мы получить все же можем. Но для этого надо написать B._B__count :
… print(B._B__count)
Таково соглашение. Если в классе есть атрибут с двумя первыми подчеркиваниями, то для доступа извне к имени атрибута добавляется имя класса с одним впереди стоящим подчеркиванием. В результате атрибут как он есть (в данном случае __count ) оказывается замаскированным. Вне класса такого атрибута просто не существует. Для программиста же наличие двух подчеркиваний перед атрибутом должно сигнализировать, что трогать его вне класса не стоит вообще, даже через _B__count , разве что при крайней необходимости.
Хорошо, мы защитили поле от случайных изменений. Но как теперь получить его значение? Сделать это можно с помощью добавления метода:
class B: __count = 0 def __init__(self): B.__count += 1 def __del__(self): B.__count -= 1 def qty_objects(): return B.__count a = B() b = B() print(B.qty_objects()) # выведет 2
В данном случае метод qty_object() не принимает объект (нет self ), поэтому вызывать его надо через класс. Хотя правильнее такие методы делать статическими (рассматривается в одном из следующих уроков).
Приватными можно делать не только свойства, также методы:
class Natural: def __init__(self, n): self.__origin = n self.number = self.__test() def __test(self): if type(self.__origin) is int and self.__origin > 0: return self.__origin else: print(f"Значение было приобразовано к 1") return 1 a = Natural(34) b = Natural(-250) c = Natural("Hello") print(a.number, b.number, c.number)
Значение -250 было приобразовано к 1 Значение Hello было приобразовано к 1 34 1 1
Может показаться, что несмотря на то, что мы не можем получить значение скрытого атрибута извне, мы можем присвоить ему, обратившись к его имени в той нотации, в которой оно используется в классе (с двумя предстоящими знаками подчеркивания):
class A: def __init__(self, value): self.__field = value a = A(10) # print(a.__field) # Здесь будет ошибка a.__field = 25 print(a.__field) # Будет выведено 25
То есть получается, что при присваивании скрытым полям за пределами класса они становятся открытыми?
На самом деле в данном примере поле экземпляра __field , определенное за пределами класса, – это совсем другое поле. Не тот __field , который находится в классе и обращаться к которому извне надо с помощью _Full__field . В этом можно убедиться, если вывести на экран содержимое атрибута __dict__ :
print(a.__dict__) # Результат: #
Метод __setattr__
В Python атрибуты объекту можно назначать за пределами класса:
class A: def __init__(self, value): self.a = value first = A(10) second = A(25) first.b = "Hello" print(first.__dict__) # print(second.__dict__) #
Если такое поведение нежелательно, его можно запретить с помощью __setattr__ – метода, перегружающего оператор присваивания атрибуту:
class A: def __init__(self, value): self.a = value def __setattr__(self, key, value): if key == 'a': self.__dict__['a'] = value else: raise AttributeError first = A(10) first.b = "Hello"
Traceback (most recent call last): File "test_setattr.py", line 14, in first.b = "Hello" File "test_setattr.py", line 9, in __setattr__ raise AttributeError AttributeError
Метод __setattr__ , если он присутствует в классе, вызывается всегда, когда какому-либо атрибуту выполняется присваивание. Обратите внимание, что присвоение несуществующему атрибуту также обозначает его добавление к объекту.
В примере выше когда создается объект first , в конструктор передается число 10. Здесь для объекта заводится поле a . Попытка присвоения ему значения приводит к автоматическому вызову __setattr__() , в теле которого в данном случае проверяется, соответствует ли имя атрибута строке 'a' . Если это так, то поле с соответствующим ему значением добавляются в словарь атрибутов объекта.
Нельзя в теле __setattr__ написать просто self.a = value , так как это приведет к новому рекурсивному вызову метода __setattr__() . Поэтому поле назначается через словарь __dict__ , который есть у всех объектов, и в котором хранятся их атрибуты со значениями.
Если параметр key не соответствует допустимым полям, то искусственно возбуждается исключение AttributeError . Мы это видим, когда в основной ветке пытаемся обзавестись полем b .
Если объект содержит скрытые поля и к ним происходит обращение из __setattr__ , то делать это надо так, как будто обращение происходит не из класса.
class A: def __init__(self, n): self.a = n self.__x = 100 - n def __setattr__(self, attr, value): if attr in ('a', "_A__x"): self.__dict__[attr] = value else: raise AttributeError a = A(5)
В методе __setattr__ параметр attr – это имя свойства экземпляра в том виде, в котором оно находится в словаре __dict__ . Если свойство скрытое, то в __dict__ оно будет записано через имя класса.
Практическая работа
Разработайте класс с полной инкапсуляцией, доступ к атрибутам которого и изменение данных реализуются через вызовы методов. В объектно-ориентированном программировании принято имена методов для извлечения данных начинать со слова get (взять), а имена методов, в которых свойствам присваиваются значения, – со слова set (установить). Например, get_field , set_field .
Курс с примерами решений практических работ:
pdf-версия
X Скрыть Наверх
Объектно-ориентированное программирование на Python