Примеры работы с классами в Python
Python — объектно-ориентированный язык с начала его существования. Поэтому, создание и использование классов и объектов в Python просто и легко. Эта статья поможет разобраться на примерах в области поддержки объектно-ориентированного программирования Python. Если у вас нет опыта работы с объектно-ориентированным программированием (OOП), ознакомьтесь с вводным курсом или учебным пособием, чтобы понять основные понятия.
Создание классов
Пример создания класса на Python:
Создание экземпляров класса
Доступ к атрибутам
Теперь, систематизируем все.
При выполнении этого кода, мы получаем следующий результат:
Вы можете добавлять, удалять или изменять атрибуты классов и объектов в любой момент.
Вместо использования привычных операторов для доступа к атрибутам вы можете использовать эти функции:
Встроенные атрибуты класса
Для вышеуказанного класса давайте попробуем получить доступ ко всем этим атрибутам:
Когда этот код выполняется, он возвращает такой результат:
Удаление объектов (сбор мусора)
Python автоматически удаляет ненужные объекты (встроенные типы или экземпляры классов), чтобы освободить пространство памяти. С помощью процесса ‘Garbage Collection’ Python периодически восстанавливает блоки памяти, которые больше не используются.
Сборщик мусора Python запускается во время выполнения программы и тогда, когда количество ссылок на объект достигает нуля. С изменением количества обращений к нему, меняется количество ссылок.
Пример работы __del__()
Деструктор __del__() выводит имя класса того экземпляра, который должен быть уничтожен:
Когда вышеуказанный код выполняется и выводит следующее:
Наследование класса в python
Наследование — это процесс, когда один класс наследует атрибуты и методы другого. Класс, чьи свойства и методы наследуются, называют Родителем или Суперклассом. А класс, свойства которого наследуются — класс-потомок или Подкласс.
Вместо того, чтобы начинать с нуля, вы можете создать класс, на основе уже существующего. Укажите родительский класс в круглых скобках после имени нового класса.
Класс наследник наследует атрибуты своего родительского класса. Вы можете использовать эти атрибуты так, как будто они определены в классе наследнике. Он может переопределять элементы данных и методы родителя.
Синтаксис наследования класса
Классы наследники объявляются так, как и родительские классы. Только, список наследуемых классов, указан после имени класса.
Наследование
Наследование – важная составляющая объектно-ориентированного программирования. Так или иначе мы уже сталкивались с ним, ведь объекты наследуют атрибуты своих классов. Однако обычно под наследованием в ООП понимается наличие классов и подклассов. Также их называют супер- или надклассами и классами, а также родительскими и дочерними классами.
Суть наследования здесь схожа с наследованием объектами от классов. Дочерние классы наследуют атрибуты родительских, а также могут переопределять атрибуты и добавлять свои.
Простое наследование методов родительского класса
В качестве примера рассмотрим два класса столов. Класс Table – родительский по отношению к DeskTable (письменные столы). Независимо от своего типа все столы имеют длину, ширину и высоту. Пусть для письменных столов также важна площадь поверхности. Общее вынесем в класс, частное – в подкласс.
Наследственная связь между классами устанавливается через подкласс. При определении дочернего после его имени в скобках указывается родительский.
В данном случае у класса DeskTable нет своего конструктора, поэтому он наследует его от родителя. При создании объектов передавать аргументы необходимо в обоих случаях. Попытка вызова DeskTable с пустыми скобками приведет к ошибке.
С другой стороны, экземпляры надкласса Table, согласно неким родственным связям, не наследуют метод square своего подкласса.
В этом смысле терминология «родительский и дочерний класс» не совсем верна. Наследование в ООП – это скорее аналог систематизации и классификации наподобие той, что есть в живой природе. Все млекопитающие имеют четырехкамерное сердце, но только носороги – рог.
Полное переопределение метода надкласса
Рассмотрим вариант программы с «цепочкой наследования». Пусть дочерний по отношению к Table класс DeskTable в свою очередь выступит родительским по отношению к ComputerTable (компьютерные столы):
Допустим, по задумке разработчиков рабочая поверхность компьютерного стола может вычисляться за вычетом площади, которую занимает монитор. В результате метод square в ComputerTable имеет отличия.
Определив в дочернем классе метод, одноименный методу родительского, мы тем самым переопределяем метод родительского класса. При вызове square на экземпляры ComputerTable будет вызываться метод из этого класса, а не из родительского класса DeskTable.
В то же время ComputerTable наследует конструктор класса от своей «бабушки» – класса Table.
Дополнение, оно же расширение, метода
Часто требуется не столько заменить, то есть полностью переопределить, метод родительского класса в дочернем, сколько дополнить, то есть расширить, код метода родительского класса в дочернем. В таких случаях решением является вызов метода надкласса в теле соответствующего метода подкласса. Обычно после этого в теле метода подкласса пишется дополнительный код.
Пусть имеется подкласс кухонных столов, для которых необходимо еще одно поле – количество посадочных мест. Из-за этой детали мы вынуждены в дочернем классе переопределить конструктор родительского.
Поскольку существенная часть кода конструктора подкласса является такой же как в надклассе, правильнее будет вызвать метод другого класса, а не дублировать код:
Здесь в теле конструктора KitchenTable мы вызываем метод __init__ через объект-класс Table, а не через объект-экземпляр. Вспомним, что в таких случаях метод вызывается как обычная функция (объект, к которому применяется метод, не передается в качестве первого аргумента). Поэтому в конструктор надкласса мы «вручную» передаем текущий экземпляр (self), записывая его перед остальными аргументами.
У кода выше есть небольшой недостаток. Нам ничего не мешает (при условии совпадения количества параметров) вызвать конструктор другого класса, а не только родительского, указав его имя вместо Table. Кроме того, имя надкласса может измениться, и тогда есть риск неправильных обращений к нему из дочерних классов.
В Python c целью улучшения так называемой обслуживаемости кода можно использовать встроенную в язык функцию super. Наиболее распространенным вариантом ее применения является вызов метода родительского класса из метода подкласса:
В данном случае аргумент self в скобках вызываемого родительского метода указывать явно не требуется.
Параметры со значениями по умолчанию у родительского класса
Рассмотрим случай, когда родительский класс имеет параметры со значениями по умолчанию, а дочерний – нет:
При таком определении классов можно создать экземпляр от Table без передачи аргументов для конструктора:
Когда создается объект от дочернего класса, сначала вызывается его конструктор, если он есть. Интерпретатор еще не знает, что в теле этого конструктора будет вызван конструктор родительского класса. Ведь это не обязательно. Значит, если все параметры дочернего конструктора не имеют значений по умолчанию, при построении объекта все значения должны передаваться.
Поэтому, если требуется допустить создание объектов от дочернего класса без передачи аргументов, придется назначить значения по умолчанию также в конструкторе дочернего класса.
Поэтому лучше, когда методы родственных классов принимают одинаковое число параметров. А если разное, то у «лишних» должны быть значения по-умолчанию, чтобы при вызове конструктора их можно было бы не передавать. Если такие параметры находятся еще и в конце, передачу аргументов для предстоящих параметров можно выполнять без ключей.
Другой вариант – отказаться от конструктора в дочернем классе, а значение для поля places устанавливать отдельным вызовом метода:
Здесь у всех кухонных столов по-умолчанию будет 4 места. Если мы хотим изменить значение поля places, можем вызвать метод set_places(). Хотя в случае Python можем сделать это напрямую, присвоив полю. При этом у экземпляра появится собственное поле places.
Поэтому метод set_places() в общем-то не нужен.
В любом случае произвольное количество мест будет устанавливаться не в конструкторе, а отдельно. Если все же требуется указывать места при создании объекта, это можно сделать и в конструкторе родителя:
С помощью функции isinstance() проверяется, что создаваемый объект имеет тип KitchenTable. Если это так, то у него появляется поле places.
Мы не используем параметр p со значением по умолчанию в заголовке конструктора потому, что, если объектам других родственных классов он не нужен, не происходило путаницы и сложностей с документированием кода.
Практическая работа
Разработайте программу по следующему описанию.
В некой игре-стратегии есть солдаты и герои. У всех есть свойство, содержащее уникальный номер объекта, и свойство, в котором хранится принадлежность команде. У солдат есть метод «иду за героем», который в качестве аргумента принимает объект типа «герой». У героев есть метод увеличения собственного уровня.
В основной ветке программы создается по одному герою для каждой команды. В цикле генерируются объекты-солдаты. Их принадлежность команде определяется случайно. Солдаты разных команд добавляются в разные списки.
Измеряется длина списков солдат противоборствующих команд и выводится на экран. У героя, принадлежащего команде с более длинным списком, увеличивается уровень.
Отправьте одного из солдат первого героя следовать за ним. Выведите на экран идентификационные номера этих двух юнитов.
Курс с примерами решений практических работ:
android-приложение, pdf-версия
С. Шапошникова © 2021
Объектно-ориентированное программирование на Python
Основы наследования в Python
Наследование в Python – важный аспект объектно-ориентированной парадигмы. Наследование обеспечивает возможность повторного использования кода в программе, потому что мы можем использовать существующий класс для создания нового класса вместо того, чтобы создавать его с нуля.
При наследовании дочерний класс получает свойства и может получить доступ ко всем элементам данных и функциям, определенным в родительском классе. Дочерний класс также может предоставлять свою конкретную реализацию функциям родительского класса. В этом разделе руководства мы подробно обсудим основы наследования в Python.
В python производный класс может наследовать базовый класс, просто указав базу в скобках после имени производного класса. Рассмотрим следующий синтаксис, чтобы наследовать базовый класс в производный класс.
Класс может наследовать несколько классов, указав их все внутри скобок. Рассмотрим следующий синтаксис.
Многоуровневое наследование Python
Многоуровневое наследование возможно в Python, как и в других объектно-ориентированных языках. Архивируется, когда производный класс наследует другой производный класс. Нет ограничений на количество уровней, до которых многоуровневое наследование архивируется в python.
Синтаксис многоуровневого наследования приведен ниже.
Множественное наследование в Python
Python предоставляет нам маневренность для наследования нескольких базовых классов в дочернем классе.
Синтаксис для выполнения множественного наследования приведен ниже.
Метод issubclass(sub, sup)
Метод issubclass(sub, sup) используется для проверки отношений между указанными классами. Он возвращает true, если первый класс является подклассом второго класса, и false в противном случае.
Рассмотрим следующий пример:
Метод isinstance(obj, class)
Метод isinstance() используется для проверки взаимосвязи между объектами и классами. Он возвращает true, если это первый параметр, а Obj является экземпляром второго параметра, т. е. классом.
Рассмотрим следующий пример.
Переопределение метода
Мы можем предоставить некоторую конкретную реализацию метода родительского класса в нашем дочернем классе. Когда метод родительского класса определен в дочернем классе с некоторой конкретной реализацией, эта концепция называется переопределением метода. Нам может потребоваться выполнить переопределение метода в сценарии, когда в дочернем классе требуется другое определение метода родительского класса.
Рассмотрим следующий пример, чтобы выполнить переопределение метода в Python.
Реальный пример переопределения метода –
Абстракция данных в Python
Абстракция – важный аспект объектно-ориентированного программирования. В python мы также можем выполнять скрытие данных, добавляя двойное подчеркивание (___) в качестве префикса к атрибуту, который необходимо скрыть. После этого атрибут не будет виден за пределами класса через объект.
Простое наследование классов
На этом занятии мы начнем рассмотрение очень важной темы в ООП – наследование классов. На первом уроке данного курса я приводил пример с кофемолкой и говорил, что для создания электрической кофемолки можно взять уже готовые наработки механической кофемолки, добавить туда мотор, схему и получим новый прибор. Этот пример как раз описывает общий принцип наследования в ООП: мы можем взять некий класс и на его основе создать новый, дочерний, изменив и расширив функционал базового класса.
Причем, в Python 3 любой создаваемый класс, например:
автоматически является дочерним по отношению к базовому object:
И в этом легко убедиться, вызвав специальную функцию:
которая возвращает True, если класс является дочерним для класса, указанного вторым параметром.
Теперь давайте посмотрим как в Python реализуется механизм наследования. Для начала создадим вспомогательный класс Point для хранения координат на плоскости:
И после него объявим класс для работы с графическим примитивом линией:
Обратите внимание вот на эту нотацию (:Point, :str, :int). Так можно в тексте программы указывать: какого типа параметры мы здесь ожидаем получать. Конечно, это не значит, что другие типы здесь не могут быть переданы (сюда по прежнему можно передать что угодно), это лишь подсказка программисту с чем мы тут собираемся иметь дело – с объектами класса Point.
Создадим экземпляр этого класса:
И в консоли увидим не совсем читаемое сообщение. Дело в том, что при вызове self._sp возвращаются не координаты точки, а стандартное сообщение класса Point. Давайте его переопределим, чтобы выводились координаты:
Теперь при запуске видим то, что нам было нужно.
Далее, мы подумали и решили добавить класс еще одного примитива – прямоугольника. И мы пишем следующее:
Смотрите, мы здесь фактически, продублировали текст из класса Line. Отличие только вот этот метод drawRect, остальное абсолютно такое же. Как только что-то подобное встречается в тексте программы, это значит, что программист нарушает общеизвестный принцип DRY (Don’t Repeat Yourself) – не повторяйся! И как раз это можно поправить с помощью механизма наследования.
Вот этот дублирующий текст вынесем в отдельный класс:
а, классы примитивов будем наследовать от него:
То есть, мы в круглых скобках после имени класса указываем базовый класс. В результате, получаем такую иерархию:
И когда мы создаем объекты этих примитивов:
то вот этот self ссылается на общий класс Line, поэтому все публичные свойства и методы создаются для дочерних классов Line и Rect.
Вот это нижнее подчеркивание сигнализирует программисту о режиме доступа protected к этим атрибутам. То есть, мы оговариваем, что они должны использоваться только внутри объекта Prop и во всех его дочерних классах. И здесь ключевое слово оговариваем. Python при этом никак не ограничивает область их использования. Фактически, это такие же публичные атрибуты, только с одним нижним подчеркиванием. Если выполнить вот такую операцию:
то это свойство будем выведено в консоль без каких-либо ошибок. Но тогда зачем нам писать это нижнее подчеркивание, если оно не играет никакой роли. Одна роль у этого префикса все-таки есть: нижнее подчеркивание должно предостерегать программиста от использования этого свойства вне класса. Впоследствии это может стать причиной непредвиденных ошибок. Например, изменится версия модуля и такое свойство может перестать существовать, т.к. никто не предполагал доступа к нему извне. А вот сеттеры и геттеры будут по-прежнему работать и давать тот же результат. Так что, к таким атрибутам лучше не обращаться напрямую – это внутренние, служебные переменные.
Далее, создавая экземпляры дочерних классов, мы использовали инициализатор базового класса Prop. В действительности, сначала вызывается инициализатор в дочерних классах, но так как мы его явно там не прописывали, то использовался инициализатор по умолчанию, который вызывал инициализатор базового класса.
Давайте переопределим инициализатор в дочернем классе Line и убедимся в этом:
Если теперь запустить программу, то мы увидим сообщение «Переопределенный инициализатор» и, затем ошибку, связанную с отсутствием выводимых свойств, так как инициализатор базового класса не был вызван и локальные свойства не были созданы.
Инициализатор суперкласса можно вызвать, просто обратившись к нему:
И в инициализаторе Prop добавим:
Но делать так – порочная практика. В случае множественного наследования – это источник потенциальных ошибок. Почему? Мы об этом позже еще поговорим. А сейчас отметим, что вместо явного указания имени базового класса, следует вызвать специальную функцию super, которая в правильном порядке будет перебирать вышестоящие классы:
О ней мы подробнее еще поговорим. Теперь, наша программа вновь обрела работоспособность и мы видим порядок вызовов инициализаторов: от дочернего к базовому классу.
Вот так в самом простом варианте работает механизм наследования. Давайте, теперь немного усложним программу и посмотрим как наследуются приватные (частные) свойства. Укажем в суперклассе Prop свойство _width как приватное:
добавим в него метод
При запуске видим ожидаемую ошибку, т.к. частное свойство __width базового класса Prop стало недоступно в дочернем классе Line. Но почему? Ведь self в базовом классе Prop ссылается на Line. Так и есть, но создавая приватную переменную в каком-либо определенном классе, она создается с префиксом этого класса и среди локальных свойств Line мы увидим свойство
Выведем их в косоль:
и вот в списке локальных атрибутов объекта Line появилось _Prop__width со значением 1. Причем, обратиться к нему мы можем только из метода getWidth класса Prop:
Вызывая метод getWidth базового класса, мы сначала ищем его в классе Line, не находим и переходим в базовый класс Prop. Там он есть, вызываем его и, обращаясь к частному свойству уже из этого класса, к нему добавляется префикс _Prop и мы успешно читаем этот локальный атрибут из экземпляра класса Line.
Если в инициализаторе класса Line после вызова инициализатора базового класса создать такое же частное свойство:
то в экземпляре класса Line появится запись:
к которому мы можем обратиться напрямую из этого класса:
Вот так создаются приватные атрибуты классов. Ко всем остальным можно напрямую обращаться из любых экземпляров классов.
Задания для самоподготовки
2. Повторите это задания для суперкласса «Человек» и подклассов «Мужчина» и «Женщина». Подумайте, какие общие характеристики можно выделить в суперкласс и какие частные свойства указать в подклассах.
Видео по теме
#1: парадигма ООП, классы, экземпляры классов, атрибуты
#2: методы класса, параметр self, конструктор и деструктор
#4: объекты свойства (property) и дескрипторы классов
#5: статические свойства и методы классов, декоратор @staticmethod, создание синглетона
#6: простое наследование классов, режим доступа protected
#7: переопределение и перегрузка методов, абстрактные методы
#8: множественное наследование, функция super
#9: перегрузка операторов
#10: собственные исключения и итерабельные объекты
#11: функторы и менеджеры контекста
#12: нейронная сеть (пример реализации)
#14: полиморфизм в ООП на Python
#15: Моносостояние экземпляров класса
#16: Магические методы __str__, __repr__, __len__, __abs__
#17: Коллекция __slots__ для классов
#18: Как работает __slots__ с property и при наследовании классов
#19. Введение в обработку исключений
#20. Распространение исключений (propagation exceptions)
#21. Инструкция raise и пользовательские исключения
© 2021 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Вызов метода родительского класса из дочернего класса в Python?
при создании простой иерархии объектов в Python я хотел бы иметь возможность вызывать методы родительского класса из производного класса. В Perl и Java есть ключевое слово для этого ( super ). В Perl я мог бы сделать следующее:
Это не кажется правильным, так как такое поведение затрудняет создавать глубокие иерархии. Если детям нужно знать, какой класс определил унаследованный метод, то создается всевозможная информационная боль.
является ли это фактическим ограничением в python, пробелом в моем понимании или обоими?
13 ответов
да, но только с новый-стиль-классы. Используйте super() функция:
Python также имеет супер а также:
super(type[, object-or-type])
возвращает прокси-объект, который делегирует вызовы методов родителя или отпрыска класс тип. Это полезно для доступа к унаследованным методам, которые были переопределены в классе. Порядок поиска совпадает с порядком, используемым getattr (), за исключением того, что сам тип пропускается.
будет просто отлично, будет ли определен непосредственный родительский класс frotz сам или унаследовал его. super нужен только для правильной поддержки несколько наследование (и то он работает только если каждый класс использует его правильно). В общем, AnyClass.whatever собирается искать whatever на AnyClass ‘предки, если AnyClass не определяет / переопределяет его, и это справедливо для «дочернего класса, вызывающего метод родителя», как и для любого другого случая!
пример использования super ():
во многих ответах объясняется, как вызвать метод из родительского элемента, который был переопределен в дочернем элементе.
«Как вы вызвать метод родительского класса из дочернего класса?»
также может означать:
» Как вы называете унаследованные методы?»
вы можете вызывать методы, унаследованные от родительского класса, так же, как если бы они были методами дочернего класса, если они не были перезаписанный.
например, в python 3:
да, это может быть довольно очевидно, но я чувствую, что, не указывая на это, люди могут оставить этот поток с впечатлением, что вам нужно прыгать через смешные обручи только для доступа к унаследованным методам в python. Тем более, что этот вопрос высоко ценится в поисках «как получить доступ к методу родительского класса в Python», а OP написан с точки зрения кого-то нового для python.
I найдено: https://docs.python.org/3/tutorial/classes.html#inheritance чтобы быть полезным в понимании того, как вы получаете доступ к унаследованным методам.
Я бы рекомендовал использовать CLASS.__bases__ что-то вроде этого!—3—>
Если вы не знаете, сколько аргументов вы можете получить, и хотите передать их все ребенку:
в python также есть super ().
пример того, как метод суперкласса вызывается из метода подкласса
этот пример аналогичен описанному выше.Однако есть одно отличие, что super не имеет никаких аргументов, переданных ему.Этот приведенный выше код является исполняемым в версии python 3.4.
в Python 2 мне не очень повезло с super (). Я использовал ответ из jimifiki на эту нить как ссылаться на родительский метод в python?. Затем я добавил к нему свой собственный маленький поворот, который, я думаю, является улучшением удобства использования (особенно если у вас длинные имена классов).
определить базовый класс в одном модуле:
затем импортируйте класс в другие модули as parent :
