Передача переменной из одного экземпляра класса в другой с использованием Python?
У меня проблемы с передачей переменной, определенной в одном экземпляре класса, в другой экземпляр класса. Я относительно новичок в использовании классов, но, насколько я понимаю, переменные можно передавать из одного экземпляра в другой, просто определяя их как часть экземпляра класса (например, в следующем примере). Несмотря на то, что я использовал эту модель в прошлом, я никогда не пытался сделать это, используя графический интерфейс, такой как wxPython .
У меня проблема в том, что экземпляр wxPython предопределен и не принимает никаких дополнительных параметров (что позволяет мне передавать только такие вещи, как title, size и т. Д.) В экземпляр класса.
Другая проблема, с которой я сталкиваюсь, это то, что я пытаюсь передать переменную на три класса глубже, вызывая диалоговое окно, и из диалога я вызываю отдельный класс, предназначенный для запуска рабочего потока.
Итак, мои вопросы:
Как передать переменную из экземпляра первого класса в экземпляр третьего класса?
Как я могу переопределить экземпляр wxPython для определения дополнительных переменных?
ИЛИ Можно ли создать собственный обработчик событий для передачи необходимых данных?
Я использую Python и хотел бы думать, что я понимаю основы программирования с использованием Classes и GUI с такими фреймворками, как Tkinter и wxPython (используется в этом проекте). Я написал основной класс / экземпляр, который получает некоторые данные от пользователя, и я хотел бы иметь возможность передавать информацию, хранящуюся в self.main_instance_var, и передавать ее во второй класс / экземпляр (в данном случае диалоговое окно Progress Dialog звонили из первого класса.
Когда я попытался использовать вышеупомянутую модель в моем диалоге прогресса, я получил очень неинформативную синтаксическую ошибку («не ключевое слово arg после ключевого слова arg»). Предотвращение дальнейшей передачи переменной из диалогового окна Progress в рабочий поток. Если бы я получил исключение, это было бы одно, но синтаксическая ошибка, я не понимаю. Посмотрите ниже для краткого примера:
Передача переменной из одного экземпляра класса в другой с использованием Python?
У меня проблемы с передачей переменной, определенной в одном экземпляре класса, в другой экземпляр класса. Я относительно новичок в использовании классов, но, насколько я понимаю, переменные можно передавать из одного экземпляра в другой, просто определяя их как часть экземпляра класса (например, в следующем примере). Хотя я использовал эту модель в прошлом, я никогда не пытался сделать это с помощью графического интерфейса, такого как wxPython ,
Проблема, с которой я столкнулся, заключается в том, что экземпляр wxPython предопределен и не принимает никаких дополнительных параметров (что позволяет мне передавать только такие вещи, как title, size и т. Д.) В экземпляр класса.
Другая проблема, с которой я сталкиваюсь, заключается в том, что я пытаюсь передать переменную три класса в глубину, вызывая диалоговое окно, и из диалога я вызываю отдельный класс, предназначенный для запуска рабочего потока.
Итак, мои вопросы:
Как я могу передать переменную из первого экземпляра класса в третий экземпляр класса?
Как я могу переопределить экземпляр wxPython для определения дополнительных переменных?
ИЛИ, возможно ли создать собственный обработчик событий для передачи необходимых данных?
Я использую Python и хотел бы думать, что я понимаю основы программирования с использованием Classes и GUI с такими фреймворками, как Tkinter и wxPython (используется в этом проекте). Я написал основной класс / экземпляр, который получает некоторые данные от пользователя, и я хотел бы иметь возможность передавать информацию, хранящуюся в self.main_instance_var, и передавать ее во второй класс / экземпляр (в данном случае диалоговое окно Progress Dialog звонили из первого класса.
Когда я попытался использовать вышеупомянутую модель в моем диалоге прогресса, я получил очень неинформативную синтаксическую ошибку («не ключевое слово arg после ключевого слова arg»). Предотвращение дальнейшей передачи переменной из диалогового окна Progress в рабочий поток. Если бы я получил исключение, это было бы одно, но синтаксическая ошибка, я не понимаю. Посмотрите ниже для краткого примера:
Наследование в Python 3
Объектно-ориентированное программирование позволяет создавать многоразовые шаблоны кода и таким образом уменьшать количество повторяемых блоков кода в программе. Один из методов, с помощью которого это достигается, называется наследованием; при этом один подкласс может использовать код из другого базового класса.
Данное руководство ознакомит вас с основными аспектами наследования в Python: с работой родительских и дочерних классов, переопределением методов и атрибутов, функцией super() и множественным наследованием.
Что такое наследование?
Наследование подразумевает, что дочерний класс использует код, созданный в родительском классе.
Дочерний класс, или подкласс – это класс, который наследует код из родительского, или базового класса.
Предположим, что у нас есть класс Parent с переменными last_name, height, и eye_color. Подкласс Child может наследовать эти переменные из класса Parent, то есть повторно использовать этот код. Это позволяет уменьшить объём кода и снизить избыточность.
Родительские классы
Родительский, или базовый класс создаёт шаблон кода, который в дальнейшем может наследоваться дочерними классами. Родительским классом может быть любой класс. Базовые классы – это не просто шаблоны, а полноценные функционирующие классы.
Предположим, у нас есть общий родительский класс Bank_account с дочерними классами Personal_account и Business_account. Многие параметры классов Personal_account и Business_account будут совпадать. Такие параметры можно наследовать из родительского класса Bank_account. В подклассе Business_account будут индивидуальные параметры (например, методы сбора деловых документов и форм и переменная employee_identification_number).
Аналогичным образом, класс Animal может содержать методы eating() и sleeping(), а подкласс Snake помимо вышеперечисленных наследуемых методов может также содержать методы hissing() и slithering().
Для примера попробуйте создать родительский класс Fish (в дальнейшем мы используем его, чтобы создать различные подклассы с типами рыб).
Создайте файл fish.py и добавьте в него метод конструктора __init__(), который будет содержать переменные first_name и last_name для каждого подкласса (или объекта) Fish.
class Fish:
def __init__(self, first_name, last_name=»Fish»):
self.first_name = first_name
self.last_name = last_name
Переменная last_name содержит строку “Fish”, потому что почти все подклассы будут использовать это значение.
Добавьте в файл другие методы:
class Fish:
def __init__(self, first_name, last_name=»Fish»):
self.first_name = first_name
self.last_name = last_name
def swim(self):
print(«The fish is swimming.»)
def swim_backwards(self):
print(«The fish can swim backwards.»)
Теперь в файле есть методы swim() и swim_backwards(), которые будут наследоваться подклассами.
Добавьте другие атрибуты в метод __init__():
class Fish:
def __init__(self, first_name, last_name=»Fish»,
skeleton=»bone», eyelids=False):
self.first_name = first_name
self.last_name = last_name
self.skeleton = skeleton
self.eyelids = eyelids
def swim(self):
print(«The fish is swimming.»)
def swim_backwards(self):
print(«The fish can swim backwards.»)
Создание родительского класса ничем не отличается от создания обычного класса. Единственный нюанс: нужно заранее продумывать, какие параметры смогут наследовать дочерние классы.
Дочерние классы
Дочерние классы, или подклассы – это классы, которые наследуют параметры родительских классов. Каждый дочерний класс сможет использовать методы и переменные родительского класса.
К примеру, дочерний класс Goldfish может наследовать из класса Fish функцию swim().
Дочерние классы начинаются немного иначе. В первой строке нужно передать родительский класс:
Класс Trout является дочерним по отношению к классу Fish (родительский класс нужно указать в круглых скобках).
В дочернем классе можно добавить больше методов, переопределить методы родительского класса или просто принять его методы с помощью ключевого слова pass, например:
.
class Trout(Fish):
pass
Теперь создайте объект Trout и наследуйте методы родительского класса, не добавляя новых:
.
class Trout(Fish):
pass
terry = Trout(«Terry»)
print(terry.first_name + » » + terry.last_name)
print(terry.skeleton)
print(terry.eyelids)
terry.swim()
terry.swim_backwards()
Теперь в файле есть объект Trout, который использует все методы класса Fish несмотря на то, что они не объявлены в самом объекте. Нужно только передать значение “Terry” переменной first_name; все остальные переменные уже инициализированы.
Запустите программу. Вы получите:
Terry Fish
bone
False
The fish is swimming.
The fish can swim backwards.
Создайте другой дочерний класс, теперь уже добавив новые методы. Класс будет называться Clownfish, его индивидуальный метод – live_with_anemone.
.
class Clownfish(Fish):
def live_with_anemone(self):
print(«The clownfish is coexisting with sea anemone.»)
Создайте объект Clownfish:
.
casey = Clownfish(«Casey»)
print(casey.first_name + » » + casey.last_name)
casey.swim()
casey.live_with_anemone()
Запустив программу, вы получите такой вывод:
Casey Fish
The fish is swimming.
The clownfish is coexisting with sea anemone.
Как видите, объект casey использует методы __init__() и swim() родительского класса Fish и индивидуальный метод live_with_anemone().
Если попробовать использовать метод live_with_anemone() в объекте Trout, получится ошибка:
terry.live_with_anemone()
AttributeError: ‘Trout’ object has no attribute ‘live_with_anemone’
Это потому, что метод live_with_anemone() принадлежит исключительно дочернему классу Clownfish.
Переопределение методов родительского класса
Только что вы создали дочерний класс Trout, который с помощью ключевого слова pass полностью наследует методы родительского класса Fish, и дочерний класс Clownfish, который не только наследует методы родительского класса, но и использует свой собственный метод.
Однако в некоторых случаях нужно использовать не все, а только отдельные методы родительского класса. Для этого методы родительского класса можно переопределять.
Создавая родительский и дочерний класс, важно учитывать проектирование программы, чтобы переопределение не создало ненужного или избыточного кода.
Для примера создайте дочерний класс Shark. При создании класса Fish использовался параметр skeleton=”bone”, но в случае с классом Sharkэто неверно. Переопределите этот параметр.
Примечание: Что касается проектирования программы, если бы переопределяемый параметр использовался несколькими классами, а не одним, лучше было бы создать для них отдельный родительский класс.
Переопределите метод конструктора __init__() и метод swim_backwards(). Метод swim() изменять не нужно. Дочерний класс будет выглядеть так:
.
class Shark(Fish):
def __init__(self, first_name, last_name=»Shark»,
skeleton=»cartilage», eyelids=True):
self.first_name = first_name
self.last_name = last_name
self.skeleton = skeleton
self.eyelids = eyelids
def swim_backwards(self):
print(«The shark cannot swim backwards, but can sink backwards.»)
Параметры метода конструктора __init__() были переопределены; теперь переменная last_name имеет значение “Shark”, переменная skeleton имеет значение “cartilage”, а eyelids – значение True.
Метод swim_backwards() теперь выводит другое значение, а не то, которое определено в родительском классе Fish.
Теперь создайте экземпляр класса Shark, который будет использовать метод swim() родительского класса Fish.
.
wally = Shark(«Wally»)
print(wally.first_name + » » + wally.last_name)
wally.swim()
wally.swim_backwards()
print(wally.eyelids)
print(wally.skeleton)
Запустите этот код, и вы получите:
Wally Shark
The fish is swimming.
The shark cannot swim backwards, but can sink backwards.
True
cartilage
В дочернем классе Shark методы __init__() и swim_backwards() успешно переопределены.
Функция super()
С помощью функции super() вы можете получить доступ к унаследованным методам, которые были перезаписаны в объекте класса.
Функция super() вызывает родительский метод в дочерний и использует его. Например, это позволяет переопределить один из аспектов родительского метода, а затем вызвать остальную часть исходного родительского метода.
К примеру, в программе, которая выставляет оценки студентам, внутри родительского класса Grade может быть дочерний класс Weighted_grade. В классе Weighted_grade можно переопределить метод родительского класса calculate_grade() и унаследовать остальные методы без изменений. Для этого и нужна функция super().
Обычно функция super() используется в методе конструктора __init__(), потому что именно там, скорее всего, появятся уникальные методы дочернего класса.
Попробуйте изменить дочерний класс Trout. Добавьте переменную water в метод __init__() и присвойте ей значение “freshwater”. Остальные методы родительского класса можно наследовать без изменений.
.
class Trout(Fish):
def __init__(self, water = «freshwater»):
self.water = water
super().__init__(self)
.
Метод __init__() класса Trout был переопределён. Он иначе реализует методы __init__() родительского класса Fish. В методе __init__() класса Trout был явно инициализирован метод __init__() класса Fish.
Поскольку метод переопределён, больше не нужно передавать first_name как параметр Trout. Если бы вы передали параметр, параметр freshwater был бы сброшен. Поэтому переменную first_name нужно инициализировать путём вызова в объекте.
Теперь можно вызвать инициализированные переменные родительского класса, а также использовать уникальную дочернюю переменную.
.
terry = Trout()
# Инициализация first name
terry.first_name = «Terry»
# Использование родительского метода __init__() с помощью функции super()
print(terry.first_name + » » + terry.last_name)
print(terry.eyelids)
# Дочерний метод __init__()
print(terry.water)
# Родительский метод swim()
terry.swim()
Terry Fish
False
freshwater
The fish is swimming.
Как видите, объект terry класса Trout может использовать свой метод __init__() с переменной water и родительский метод __init__() класса Fish с переменными first_name, last_name и eyelids.
Множественное наследование
Множественное наследование подразумевает, что класс может наследовать атрибуты и методы из нескольких родительских классов одновременно. Это позволяет программам сократить избыточность, но также может усложнить код, поэтому множественное наследование нужно использовать только с учетом общей конструкции программы.
Попробуйте создать класс Coral_reef, дочерний по отношению к классам Coral и Sea_anemone. Создайте в каждом классе метод и передайте его с помощью ключевого слова pass в дочерний класс Coral_reef.
class Coral:
def community(self):
print(«Coral lives in a community.»)
class Anemone:
def protect_clownfish(self):
print(«The anemone is protecting the clownfish.»)
class CoralReef(Coral, Anemone):
pass
Класс Coral содержит метод community(), который выводит одну строку текста, а класс Anemone содержит метод protect_clownfish(), который отображает другую строку. После этого оба класса вызываются в кортеж. Таким образом класс Coral может наследовать оба родительских класса.
Читайте также: Кортежи в Python 3
Создайте объект класса Coral:
.
great_barrier = CoralReef()
great_barrier.community()
great_barrier.protect_clownfish()
Объект great_barrier класса CoralReef использует методы обоих родительских классов.
Coral lives in a community.
The anemone is protecting the clownfish.
Как видите, множественное наследование работает правильно.
Множественное наследование позволяет использовать методы нескольких родительских классов внутри одного дочернего класса. Если в родительских классах присутствует один и тот же метод, дочерний класс унаследует его из того родительского класса, который идёт первым в кортеже.
Заключение
Теперь вы знакомы с основами наследования в Python 3 и умеете создавать родительские и дочерние классы, переопределять методы, использовать функцию super() и использовать множественное наследование.
Наследование в объектно-ориентированном программировании позволяет соблюдать принцип разработки DRY («don’t repeat yourself»), благодаря чему программа содержит меньше повторяющихся блоков кода. Наследование также заставляет разработчиков заранее продумывать конструкцию программы.
Понимание наследования классов в Python 3
Объектно-ориентированное программирование создает многократно используемые шаблоны кода для сокращения избыточности в проектах разработки. Одним из способов, которым объектно-ориентированное программирование достигает кода, пригодного для повторного использования, является наследование, когда один подкласс может использовать код из другого базового класса.
В этом руководстве будут рассмотрены некоторые из основных аспектов наследования в Python, включая то, как работают родительские классы и дочерние классы, как переопределять методы и атрибуты, как использовать функцию super() и как использовать множественное наследование. .
Что такое наследование?
Inheritance — это когда класс использует код, созданный внутри другого класса. Если мы думаем о наследовании с точки зрения биологии, мы можем думать о ребенке, унаследовавшем определенные черты от своего родителя. То есть ребенок может наследовать рост или цвет глаз родителя. Дети также могут иметь одинаковую фамилию со своими родителями.
Классы, называемыеchild classes илиsubclasses, наследуют методы и переменные отparent classes илиbase classes.
Мы можем представить себе родительский класс с именем Parent , у которого естьclass variables для last_name , height и eye_color , которые наследует дочерний класс Child из Parent .
Поскольку подкласс Child наследуется от базового класса Parent , класс Child может повторно использовать код Parent , что позволяет программисту использовать меньше строк кода и уменьшить избыточность .
Родительские классы
Родительские или базовые классы создают шаблон, на котором могут основываться дочерние или подклассы. Родительские классы позволяют нам создавать дочерние классы посредством наследования без необходимости каждый раз переписывать один и тот же код. Любой класс может быть превращен в родительский класс, поэтому каждый из них является самостоятельным полностью функциональным классом, а не просто шаблоном.
Допустим, у нас есть общий родительский класс Bank_account , у которого есть дочерние классы Personal_account и Business_account . Многие методы между личными и корпоративными счетами будут похожи, например методы снятия и внесения денег, поэтому они могут принадлежать к родительскому классу Bank_account . Подкласс Business_account будет иметь специфические для него методы, включая, возможно, способ сбора бизнес-записей и форм, а также переменную employee_identification_number .
Точно так же класс Animal может иметь методы eating() и sleeping() , а подкласс Snake может включать свои собственные специфические методы hissing() и slithering() .
Давайте создадим родительский класс Fish , который мы позже будем использовать для создания типов рыб в качестве его подклассов. Каждая из этих рыб будет иметь имена и фамилии в дополнение к характеристикам.
Мы создадим новый файл с именем fish.py и начнем с __init__() constructor method, который мы заполним переменными класса first_name и last_name для каждого объекта Fish . или подкласс.
Мы инициализировали нашу переменную last_name строкой «Fish» , потому что мы знаем, что у большинства рыбок будет эта фамилия.
Давайте также добавим некоторые другие методы:
Мы добавили методы swim() и swim_backwards() в класс Fish , чтобы каждый подкласс также мог использовать эти методы.
Поскольку большинство рыб, которые мы будем создавать, считаютсяbony fish (так как у них скелет сделан из кости), а неcartilaginous fish (поскольку у них скелет сделан из хряща) , мы можем добавить еще несколько атрибутов к методу __init__() :
Создание родительского класса следует той же методологии, что и любой другой класс, за исключением того, что мы думаем о том, какие методы дочерние классы смогут использовать после их создания.
Детские классы
Дочерние или подклассы — это классы, которые будут наследоваться от родительского класса. Это означает, что каждый дочерний класс сможет использовать методы и переменные родительского класса.
Например, дочерний класс Goldfish , который является подклассом класса Fish , сможет использовать метод swim() , объявленный в Fish , без необходимости его объявления.
Мы можем думать о каждом дочернем классе как о классе родительского класса. То есть, если у нас есть дочерний класс с именем Rhombus и родительский класс с именем Parallelogram , мы можем сказать, что a Rhombus is a Parallelogram , как и Goldfish is a Fish .
Первая строка дочернего класса выглядит немного иначе, чем не дочерние классы, так как вы должны передать родительский класс в дочерний класс в качестве параметра:
Класс Trout является дочерним по отношению к классу Fish . Мы знаем это благодаря включению в скобки слова Fish .
С дочерними классами мы можем добавить дополнительные методы, переопределить существующие родительские методы или просто принять родительские методы по умолчанию с ключевым словом pass , что мы и сделаем в этом случае:
Теперь мы можем создать объект Trout без необходимости определять какие-либо дополнительные методы.
Мы создали объект Trout terry , который использует каждый из методов класса Fish , хотя мы не определили эти методы в дочернем классе Trout . Нам нужно было только передать значение «Terry» переменной first_name , потому что все другие переменные были инициализированы.
Когда мы запустим программу, мы получим следующий вывод:
Далее, давайте создадим еще один дочерний класс, который включает в себя собственный метод. Назовем этот класс Clownfish , и его специальный метод позволит ему жить с морским анемоном:
Затем давайте создадим объект Clownfish , чтобы увидеть, как это работает:
Когда мы запустим программу, мы получим следующий вывод:
Выходные данные показывают, что объект Clownfish casey может использовать методы Fish __init__() и swim() , а также метод своего дочернего класса live_with_anemone() с.
Если мы попытаемся использовать метод live_with_anemone() в объекте Trout , мы получим ошибку:
Это связано с тем, что метод live_with_anemone() принадлежит только дочернему классу Clownfish , а не родительскому классу Fish .
Дочерние классы наследуют методы родительского класса, к которому он принадлежит, поэтому каждый дочерний класс может использовать эти методы в программах.
Переопределение родительских методов
До сих пор мы рассматривали дочерний класс Trout , который использовал ключевое слово pass для наследования всего поведения родительского класса Fish , и еще один дочерний класс Clownfish , который унаследовал все поведения родительского класса, а также создал свой собственный уникальный метод, специфичный для дочернего класса. Однако иногда нам захочется использовать некоторые из поведений родительского класса, но не все. Когда мы меняем методы родительского класса, мыoverrideих.
При создании родительских и дочерних классов важно помнить о разработке программы, чтобы переопределение не приводило к ненужному или избыточному коду.
Мы создадим дочерний класс Shark родительского класса Fish . Поскольку мы создали класс Fish с идеей, что мы будем создавать в основном костлявую рыбу, нам нужно будет внести изменения для класса Shark , который вместо этого является хрящевой рыбой. С точки зрения разработки программы, если бы у нас было более одной не костистой рыбы, мы, скорее всего, хотели бы создать отдельные классы для каждого из этих двух типов рыб.
У акул, в отличие от костистых рыб, вместо кости есть скелеты из хряща. У них также есть веки, и они не могут плавать назад. Акулы могут, однако, маневрировать в обратном направлении, погружаясь.
В свете этого мы переопределим метод конструктора __init__() и метод swim_backwards() . Нам не нужно изменять метод swim() , поскольку акулы — это рыба, которая умеет плавать. Давайте посмотрим на этот дочерний класс:
Мы переопределили инициализированные параметры в методе __init__() , так что переменная last_name теперь установлена равной строке «Shark» , переменная skeleton теперь установлена равной строка «cartilage» , а для переменной eyelids теперь установлено логическое значение True . Каждый экземпляр класса также может переопределять эти параметры.
Метод swim_backwards() теперь выводит строку, отличную от строки в родительском классе Fish , потому что акулы не могут плавать назад так, как это могут делать костлявые рыбы.
Теперь мы можем создать экземпляр дочернего класса Shark , который по-прежнему будет использовать метод swim() родительского класса Fish :
Когда мы запустим этот код, мы получим следующий вывод:
Дочерний класс Shark успешно переопределил методы __init__() и swim_backwards() родительского класса Fish , а также унаследовал метод swim() родительского класса.
Когда будет ограниченное число дочерних классов, которые являются более уникальными, чем другие, переопределение методов родительского класса может оказаться полезным.
Функция super()
С помощью функции super() вы можете получить доступ к унаследованным методам, которые были перезаписаны в объекте класса.
Когда мы используем функцию super() , мы вызываем родительский метод в дочерний метод, чтобы использовать его. Например, мы можем захотеть переопределить один аспект родительского метода с определенной функциональностью, но затем вызвать остальную часть исходного родительского метода, чтобы завершить метод.
В программе, которая оценивает учащихся, мы можем захотеть иметь дочерний класс для Weighted_grade , который наследуется от родительского класса Grade . В дочернем классе Weighted_grade мы можем захотеть переопределить метод calculate_grade() родительского класса, чтобы включить функциональность для вычисления взвешенной оценки, но при этом сохранить остальную функциональность исходного класса. Вызвав функцию super() , мы сможем этого добиться.
Функция super() чаще всего используется в методе __init__() , потому что именно здесь вам, скорее всего, потребуется добавить некоторую уникальность к дочернему классу, а затем завершить инициализацию от родительского.
Чтобы увидеть, как это работает, давайте изменим наш дочерний класс Trout . Поскольку форель обычно является пресноводной рыбой, давайте добавим переменную water к методу __init__() и установим ее равной строке «freshwater» , но затем сохраним остальные переменные и параметры родительского класса:
Мы переопределили метод __init__() в дочернем классе Trout , предоставив другую реализацию __init__() , которая уже определена его родительским классом Fish . В методе __init__() нашего класса Trout мы явно вызвали метод __init__() класса Fish .
Поскольку мы переопределили метод, нам больше не нужно передавать first_name в качестве параметра в Trout , и если бы мы действительно передали параметр, мы бы вместо этого сбросили freshwater . Поэтому мы инициализируем first_name , вызывая переменную в нашем экземпляре объекта.
Теперь мы можем вызывать инициализированные переменные родительского класса, а также использовать уникальную дочернюю переменную. Давайте использовать это в экземпляре Trout :
Выходные данные показывают, что объект terry дочернего класса Trout может использовать как специфичную для ребенка переменную __init__() water , так и возможность вызова Fish родительские переменные __init__() для first_name , last_name и eyelids .
Встроенная функция Python super() позволяет нам использовать методы родительского класса даже при переопределении определенных аспектов этих методов в наших дочерних классах.
Множественное наследование
Multiple inheritance — это когда класс может наследовать атрибуты и методы более чем одного родительского класса. Это может позволить программам уменьшить избыточность, но может также внести определенную сложность, а также двусмысленность, так что это должно быть сделано с учетом общего дизайна программы.
Чтобы показать, как работает множественное наследование, давайте создадим дочерний класс Coral_reef , а не унаследованный от класса Coral и класса Sea_anemone . Мы можем создать метод в каждом из них, а затем использовать ключевое слово pass в дочернем классе Coral_reef :
Класс Coral имеет метод под названием community() , который печатает одну строку, а класс Anemone имеет метод под названием protect_clownfish() , который печатает другую строку. Затем мы вызываем оба класса в наследованиеtuple. Это означает, что Coral наследуется от двух родительских классов.
Давайте теперь создадим экземпляр объекта Coral :
Объект great_barrier установлен как объект CoralReef и может использовать методы обоих родительских классов. Когда мы запустим программу, мы увидим следующий вывод:
Вывод показывает, что методы из обоих родительских классов эффективно использовались в дочернем классе.
Множественное наследование позволяет нам использовать код более чем одного родительского класса в дочернем классе. Если один и тот же метод определен в нескольких родительских методах, дочерний класс будет использовать метод первого родителя, объявленного в его списке кортежей.
Хотя это может быть эффективно использовано, множественное наследование должно осуществляться с осторожностью, чтобы наши программы не становились двусмысленными и трудными для понимания другими программистами.
Заключение
В этом руководстве было рассмотрено создание родительских и дочерних классов, переопределение родительских методов и атрибутов в дочерних классах с использованием функции super() и разрешение дочерним классам наследовать от нескольких родительских классов.
Наследование в объектно-ориентированном кодировании может позволить придерживаться СУХОГО (не повторяйся) принципа разработки программного обеспечения, что позволяет делать больше с меньшими затратами кода и повторений. Наследование также заставляет программистов задуматься о том, как они проектируют создаваемые ими программы, чтобы обеспечить эффективность и ясность кода.