🔍 Як викликати метод батьківського класу python? Повне керівництво з прикладами та поясненнями

У наведеному прикладі, метод метод() батьківського класу викликається з методу метод() дочірнього класу за допомогою super().метод().

Детальна відповідь

Як викликати метод батьківського класу в Python?

Одним з важливих аспектів спадкування класів у Python є можливість викликати методи батьківського класу з дочірнього класу. У цій статті ми розглянемо, як правильно викликати методи батьківського класу Python.

Метод super()

У Python для виклику методів батьківського класу використовується функція super(). Вона надає доступ до методів батьківського класу, дозволяючи нам викликати їх із дочірнього класу. Нижче наведено приклад:

class БатьківськийКлас: def метод1(self): # Логіка батьківського методу pass class ДочірнійКлас(БатьківськийКлас): def метод2(self): super().метод1() # Виклик методу батьківського класу # Логіка дочірнього методу pass об'єкт = ДочірнійКлас(). метод2()

У наведеному прикладі super().метод1() викликає метод метод1() з батьківського класу БатьківськийКлас. Після цього виконується логіка методу метод2() із дочірнього класу ДочірнійКлас.

Перевизначення методів

Іноді може виникнути необхідність як викликати метод батьківського класу, а й внести до нього зміни. І тому використовується перевизначення методів. Розглянемо приклад:

class БатьківськийКлас: def метод1(self): # Логіка батьківського методу pass class ДочірнійКлас(БатьківськийКлас): def метод1(self): # Перевизначення методу super().метод1() # Виклик методу батьківського класу # Внесення змін pass об'єкт = ДочірнійКлас() объект.метод1()

У цьому прикладі метод метод1() із батьківського класу БатьківськийКлас перевизначається в дочірньому класі ДочірнійКлас. При виклик методу метод1() через super().метод1() спочатку виконається логіка батьківського методу, а потім - внесені зміни в дочірньому методі.

Множинне успадкування та super()

У Python також можливе множинне спадкування, коли дочірній клас успадковує методи відразу від кількох батьківських класів. У такій ситуації функція super() дозволяє викликати методи батьківських класів послідовно. Приклад:

class БатьківськийКлас1: def метод1(self): # Логіка методу з БатьківськогоКласу1 pass class БатьківськийКлас2: def метод2(self): # Логіка методу з БатьківськогоКласу2 pass class ДочірнійКлас(БатьківськийКлас1(БатьківськийКлас3): def. ) # Виклик методу з БатьківськогоКласу1 super().метод2() # Виклик методу з БатьківськогоКласу2 # Логіка дочірнього методу pass об'єкт = ДочірнійКлас() объект.метод3()

У цьому прикладі клас ДочірнійКлас успадковує методи як від БатьківськогоКласу1, так і від БатьківськогоКласу2. За допомогою super() ми можемо викликати методи батьківських класів по черзі.

Висновок

Таким чином, у Python існує простий спосіб викликати методи батьківського класу – використовувати функцію super(). Це дає можливість контролювати порядок виконання методів та перевизначати їх, за необхідності. Сподіваюся, ця стаття допомогла вам зрозуміти, як викликати методи батьківського класу в Python.

🔍 Як викликати батьківський метод python: докладна інструкція та приклади

Щоб викликати батьківський метод Python, ви можете використовувати функцію `super()`.Ця функція звертається до методу батьківського класу, дозволяючи вам виконати код із батьківського методу перед продовженням виконання коду в дочірньому методі. Ось приклад:

class БатьківськийКлас: def метод(self): print("Батьківський метод") class ДочірнійКлас(БатьківськийКлас): def метод(self): super().метод() # Виклик батьківського методу print("Дочірній метод") об'єкт = ДочірнійКлас( ) об'єкт.метод()

Цей код створить екземпляр класу `ДочірнійКлас` та викличе його метод. Всередині методу `метод` дочірнього класу ми використовуємо `super().метод()` для виклику батьківського методу, а потім продовжуємо виконання коду в дочірньому методі. Результат виконання коду буде: Батьківський метод Дочірній метод

Детальна відповідь

Як викликати батьківський метод у Python?

У мові програмування Python, коли створюється клас-спадкоємець, він успадковує властивості та методи від свого батьківського класу. Виникає питання, як викликати чи перевизначити метод із батьківського класу у класі-спадкоємці. Ця стаття розповість про способи виклику батьківського методу Python.

1. Використання функції super()

Одним із поширених способів виклику батьківського методу є використання функції super(). Функція super() дозволяє звернутися до батьківського класу та викликати його методи. Ось приклад:

class БатьківськийКлас: def метод(self): print("Це батьківський метод") class КласСпадкоємець(БатьківськийКлас):def метод(self): super().метод() print("Це метод класу-спадкоємця") спадкоємець = КласСпадкоємець( ) Спадкоємець.

У цьому прикладі ми створюємо клас БатьківськийКлас з методом метод(). Потім ми створюємо клас КласСпадкоємець, який успадковується від БатьківськийКлас. У методі метод() класу-спадкоємця ми викликаємо батьківський метод за допомогою super().метод(). Потім виводимо повідомлення, що відноситься до методу класу-спадкоємця. Під час виконання цього коду ви побачите наступний результат: Це батьківський метод
Це метод класу-спадкоємця Викликавши функцію super() та вказавши метод, ви хочете викликати, ви отримаєте доступ до батьківського методу та можете виконати додаткові операції, додані у класі-спадкоємці.

2. Використання імені батьківського класу

Ще один спосіб викликати батьківський метод – це використання імені батьківського класу. Зверніться до батьківського методу, додавши ім'я батьківського класу перед методом. Ось приклад:

class БатьківськийКлас: def метод(self): print("Це батьківський метод") class КласСпадкоємець(БатьківськийКлас): def метод(self):БатьківськийКлас.метод(self) print("Це метод класу-спадкоємця") спадкоємець = КласСпадкоємець() спадкоємець.метод()

У цьому прикладі ми знову створюємо клас БатьківськийКлас з методом метод(). Потім ми створюємо клас КласСпадкоємець, який успадковується від БатьківськийКлас. У методі метод() класу-спадкоємця ми викликаємо батьківський метод за допомогою імені батьківського класу БатьківськийКлас.метод(self). Потім виводимо повідомлення, що відноситься до методу класу-спадкоємця. При виконанні цього коду ви отримаєте такий самий результат, як і в попередньому прикладі: Це батьківський метод
Це метод класу-спадкоємця Використовуючи ім'я батьківського класу, ви явно вказуєте, який метод вам потрібно викликати, і передаєте посилання на екземпляр класу-спадкоємця за допомогою self.

3. Перевизначення методу із викликом батьківського методу

Якщо ви хочете перевизначити метод у класі-спадкоємці, але також викликати метод із батьківського класу, ви можете використати один із попередніх підходів. Ось приклад:

class БатьківськийКлас: def метод(self): print("Це батьківський метод") class КласСпадкоємець(БатьківськийКлас):def метод(self): super().метод() print("Це перевизначений метод класу-спадкоємця") спадкоємець = КласСпадкоємець () Спадкоємець.

У цьому прикладі клас КласСпадкоємець перевизначає метод метод() та викликає батьківський метод за допомогою super().метод(). Потім виводить повідомлення, що стосується перевизначеного методу класу-спадкоємця. Під час виконання цього коду ви побачите наступний результат: Це батьківський метод
Це перевизначений метод класу-спадкоємця Таким чином, ви можете перевизначити метод у класі-спадкоємці та викликати батьківський метод для виконання додаткових операцій.

Висновок

Виклик батьківського методу Python може бути досягнутий з використанням функції super() чи імені батьківського класу. Обидва підходи дозволяють вам викликати метод із батьківського класу, коли він був перевизначений у класі-спадкоємці. Таким чином, ви можете успадковувати функціональність від батьківського класу та додавати власні зміни до класу-спадкоємця.

успадкування

Спадкування – важлива складова об'єктно-орієнтованого програмування. Так чи інакше ми вже стикалися з ним, адже об'єкти успадковують атрибути своїх класів. Проте зазвичай під наслідуванням в ООП розуміється наявність класів та підкласів. Також їх називають супер-або надкласами та класами, а також батьківськими та дочірніми класами.

Суть спадкування тут схожа на спадкування об'єктами від класів. Дочірні класи успадковують батьківські атрибути, а також можуть перевизначати атрибути і додавати свої.

Просте успадкування методів батьківського класу

Як приклад розглянемо два класи столів. Клас Table – батьківський стосовно DeskTable (письмові столи). Незалежно від свого типу всі столи мають довжину, ширину та висоту. Нехай для письмових столів також важлива площа поверхні. Загальне винесемо до класу, приватне – до підкласу.

Спадковий зв'язок між класами встановлюється через підклас. При визначенні дочірнього після його імені у дужках зазначається батьківський.

class Table:  def
__init__(self, l, w, h): self.length
= l  self.width
= w  self.height
= h  class DeskTable(Table): def square(self): return
self.width * self.length t1  = Table(1.5,
1.8,
0.75) t2  = DeskTable(0.8,
0.6,
0.7)
print(t2.square())
# Висновок: 0.48

У даному випадку клас DeskTable не має свого конструктора, тому він успадковує його від батька. При створенні об'єктів передавати аргументи необхідно в обох випадках. Спроба виклику DeskTable з порожніми дужками приведе до помилки.

З іншого боку, екземпляри надкласу Table, згідно з деякими родинними зв'язками, не успадковують спосіб square свого підкласу.

У цьому сенсі термінологія " батьківський і дочірній клас " зовсім вірна. Спадкування в ООП – це скоріше аналог систематизації та класифікації на кшталт тієї, що є у живій природі. Усі ссавці мають чотирикамерне серце, але носороги – ріг.

Повне перевизначення методу надкласу

Розглянемо варіант програми з "ланцюжком успадкування". Нехай дочірній по відношенню до Table клас DeskTable у свою чергу виступить батьківським по відношенню до ComputerTable (комп'ютерні столи):

class Table:  def
__init__(self, l, w, h): self.length
= l  self.width
= w  self.height
= h  class DeskTable(Table): def square(self): return
self.width * self.length
class ComputerTable(DeskTable): def square(self, monitor=0.0): return
self.width * self.length - monitor t3  = ComputerTable(0.8,
0.6,
0.7)
print(t3.square(0.3))
# Висновок: 0.18

Припустимо, за задумом розробників робоча поверхня комп'ютерного столу може обчислюватися за вирахуванням площі, яку займає монітор. В результаті метод square в ComputerTable має відмінності.

Визначивши в дочірньому класі метод, однойменний метод батьківського, ми тим самим перевизначаємо метод батьківського класу. При виклику square на екземпляри ComputerTable викликатиметься метод із цього класу, а не з батьківського класу DeskTable .

У той же час ComputerTable успадковує конструктор класу від своєї "бабусі" - класу Table.

Доповнення, воно ж розширення, методу

Часто потрібно не так замінити, тобто повністю перевизначити, метод батьківського класу в дочірньому, скільки доповнити, тобто розширити, код методу батьківського класу в дочірньому. У разі рішенням є виклик методу надкласу у тілі відповідного методу підкласу. Зазвичай після цього в тілі методу підклас пишеться додатковий код.

Нехай є підклас кухонних столів, для яких потрібне ще одне поле - кількість місць. Через цю деталь ми змушені у дочірньому класі перевизначити конструктор батьківського.

class Table:  def
__init__(self, l, w, h): self.length
= l  self.width
= w  self.height
= h  class KitchenTable(Table): def
__init__(self, l, w, h, p): self.length
= l  self.width
= w  self.height
= h  self.places
= p t4  = KitchenTable(1.5,
2,
0.75,
6)

Оскільки суттєва частина коду конструктора підкласу є такою самою як у надкласі, правильніше буде викликати метод іншого класу, а не дублювати код:

class Table:  def
__init__(self, l, w, h): self.length
= l  self.width
= w  self.height
= h  class KitchenTable(Table): def
__init__(self, l, w, h, p): Table.__init__(self, l, w, h)
self.places
= p t4  = KitchenTable(1.5,
2,
0.75,
6)

Тут у тілі конструктора KitchenTable ми викликаємо метод __init__ через об'єкт-клас Table, а не через об'єкт-примірник. Згадаймо, що в таких випадках метод викликається як звичайна функція (об'єкт, до якого застосовується метод, не передається як перший аргумент). Тому в конструктор надкласу ми "вручну" передаємо поточний екземпляр (self), записуючи його перед рештою аргументів.

У коду є невеликий недолік. Нам нічого не заважає (за умови збігу кількості параметрів) викликати конструктор іншого класу, а не лише батьківського, вказавши його ім'я замість Table. Крім того, ім'я надкласу може змінитись, і тоді є ризик неправильних звернень до нього з дочірніх класів.

У Python з метою поліпшення так званої сервісності коду можна використовувати вбудовану в мову функцію super. Найбільш поширеним варіантом її застосування є виклик методу батьківського класу з методу підкласу:

class KitchenTable(Table): def
__init__(self, l, w, h, p): super().__init__(l, w, h)
self.places
= p

В даному випадку аргумент self у дужках викликаного батьківського методу вказувати явно не потрібно.

Параметри зі значеннями за замовчуванням у батьківського класу

Розглянемо випадок, коли батьківський клас має параметри зі значеннями за промовчанням, а дочірній – ні.

class Table:  def
__init__(self, l=1, w=1, h=1): self.length
= l  self.width
= w  self.height
= h  class KitchenTable(Table): def
__init__(self, p, l, w, h): Table.__init__(self, l, w, h)
self.places
= p

За такого визначення класів можна створити екземпляр від Table без передачі аргументів для конструктора:

Чи можемо ми створити екземпляр від KitchenTable, передавши значення лише для параметра p? Наприклад, ось так:

Чи можливо, що p буде надано число 10, а l , w і h отримають по одиниці від батьківського класу? Неможливо буде викинуто виняток через невідповідність кількості переданих аргументів кількості необхідних конструктором:

. k = KitchenTable(10) TypeError: __init__() missing 3 потрібні positional arguments: 'l', 'w', 'h'

Коли створюється об'єкт від дочірнього класу, спочатку викликається конструктор, якщо він є. Інтерпретатор ще не знає, що в тілі цього конструктора буде викликано конструктора батьківського класу. Це ж не обов'язково. Отже, якщо всі параметри дочірнього конструктора не мають значень за замовчуванням, при побудові об'єкта всі значення мають передаватися.

Тому якщо потрібно допустити створення об'єктів від дочірнього класу без передачі аргументів, доведеться призначити значення за замовчуванням також у конструкторі дочірнього класу.

class Table:  def
__init__(self, l=1, w=1, h=1): self.length
= l  self.width
= w  self.height
= h  class KitchenTable(Table): def
__init__(self, l=1, w=1, h=0.7, p=4): Table.__init__(self, l, w, h)
self.places
= p

Параметр p, якого немає у батьківського класу, ми робимо останнім не так. Буває, об'єкти різних родинних класів створюються чи обробляються одному циклі, тобто за одним алгоритму. При цьому у них повинні бути однакові "інтерфейси", тобто однакова кількість аргументів, що передаються в конструктор.

Тому краще, коли методи споріднених класів приймають однакову кількість параметрів. А якщо різне, то у "зайвих" мають бути значення за замовчуванням, щоб при виклику конструктора їх можна було б не передавати.Якщо такі параметри ще й наприкінці, передачу аргументів для майбутніх параметрів можна виконувати без ключів.

Інший варіант – відмовитися від конструктора в дочірньому класі, а значення поля поля встановлювати окремим викликом методу:

class Table:  def
__init__(self, l=1, w=1, h=1): self.length
= l  self.width
= w  self.height
= h  class KitchenTable(Table): places  =
4
def set_places(self, p): self.places
= p

Тут у всіх кухонних столів за замовчуванням буде 4 місця. Якщо ми хочемо змінити значення поля places, можемо викликати метод set_places. Хоча у випадку Python можемо зробити це безпосередньо, надавши полю. При цьому в екземпляра з'явиться власне поле places.

k  = KitchenTable() k.places
=
6

Тому метод set_places загалом не потрібний.

У будь-якому випадку довільна кількість місць встановлюватиметься не в конструкторі, а окремо. Якщо все ж таки потрібно вказувати місця при створенні об'єкта, це можна зробити і в конструкторі батька:

class Table:  def
__init__(self, l=1, w=1, h=1): self.length
= l  self.width
= w  self.height
= h  if
isinstance(self, KitchenTable): p  =
int(input("Скільки місць:"))
self.places
= p

За допомогою функції isinstance перевіряється, що об'єкт, що створюється, має тип KitchenTable . Якщо це так, то з'являється поле places .

Ми не використовуємо параметр p зі значенням за замовчуванням у заголовку конструктора тому, що, якщо об'єктам інших споріднених класів він не потрібен, не відбувалося б плутанини та складнощів із документуванням коду.

Практична робота

Розробте програму за таким описом.

У якійсь грі-стратегії є солдати та герої. Усі мають властивість, що містить унікальний номер об'єкта, і властивість, у якому зберігається приналежність команді.У солдатів є метод "іду за героєм", який як аргумент приймає об'єкт типу "герой".

В основній гілці програми створюється по одному героя для кожної команди. У циклі генеруються об'єкти-солдати.

Вимірюється довжина списків солдатів протиборчих команд і виводиться на екран.

Надішліть одного з солдатів першого героя слідувати за ним.

Курс із прикладами рішень практичних робіт:
pdf-версія

Об'єктно-орієнтоване програмування на Python