Pengantar Multiple Inheritance & super()

super dan multiple inheritance

Sebelum kita masuk ke multiple inheritance dan super... Peringatan, ini bisa menjadi cukup aneh dan rumit.

Pertama-tama, apa itu multiple inheritance? Sejauh ini contoh kode membahas satu child class yang mewarisi dari satu parent class. Dalam multiple inheritance, ada lebih dari satu parent class. Sebuah child class dapat mewarisi dari 2, 3, 10, dan seterusnya parent class.

Di sinilah manfaat super menjadi lebih jelas. Selain menghemat ketukan tombol untuk mereferensikan berbagai nama parent class, ada manfaat bernuansa dalam menggunakan super dengan pola multiple inheritance. Singkatnya, jika Anda akan menggunakan multiple inheritance, gunakan super.

Multiple inheritance tanpa super

Mari lihat contoh multiple inheritance yang menghindari modifikasi metode parent mana pun dan pada gilirannya menghindari super.

Input

class B:
    def b(self):
        print('b')


class C:
    def c(self):
        print('c')


class D(B, C):
    def d(self):
        print('d')


d = D()
d.b()
d.c()
d.d()
Didukung oleh

Output

b
c
d
Didukung oleh

Multiple-resolution order

Output ini tidak terlalu mengejutkan mengingat konsep multiple inheritance. D mewarisi metode x dan z dari parent class-nya, dan semuanya baik-baik saja... untuk saat ini.

Lalu bagaimana jika B dan C sama-sama memiliki metode dengan nama yang sama? Di sinilah konsep yang disebut 'multiple-resolution order' berperan atau disingkat MRO. MRO dari sebuah child class yang menentukan di mana Python akan mencari suatu metode, dan metode mana yang akan dipanggil ketika terjadi konflik.

Mari lihat contohnya.

Input

class B:
    def x(self):
        print('x: B')


class C:
    def x(self):
        print('x: C')


class D(B, C):
    pass


d = D()
d.x()
print(D.mro())
Didukung oleh

Output

x: B
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]
Didukung oleh

Saat kita memanggil metode x yang diwarisi, kita hanya melihat output yang diwarisi dari B. Kita dapat melihat MRO dari kelas D kita dengan memanggil metode kelas mro. Dari output D.mro() kita mengetahui hal berikut: program kita akan mencoba memanggil metode D secara default, lalu beralih ke B, kemudian C, dan terakhir object. Jika tidak ditemukan di tempat-tempat tersebut, maka kita akan mendapatkan error bahwa D tidak memiliki metode yang kita minta.

Perlu dicatat bahwa secara default, setiap kelas mewarisi dari object, dan itu berada di bagian akhir setiap MRO.

Multiple inheritance, super, dan diamond problem

Di bawah ini contoh penggunaan super untuk menangani MRO dari init dengan cara yang bermanfaat. Pada contoh ini, kita membuat serangkaian kelas pemrosesan teks dan menggabungkan fungsinya dalam kelas lain dengan multiple inheritance. Kita akan membuat 4 kelas, dan struktur inheritance akan mengikuti struktur pada diagram di bawah.

Catatan: Struktur ini untuk tujuan ilustrasi, dan, jika tidak ada kendala, ada cara yang lebih baik untuk mengimplementasikan logika ini.

Ini sebenarnya contoh 'diamond problem' pada multiple inheritance. Namanya tentu berdasarkan bentuk desainnya, dan fakta bahwa ini adalah masalah yang cukup membingungkan.

Di bawah ini desainnya dituliskan dengan penggunaan super.

Input

class Tokenizer:
    """Tokenize text"""
    def __init__(self, text):
        print('Start Tokenizer.__init__()')
        self.tokens = text.split()
        print('End Tokenizer.__init__()')


class WordCounter(Tokenizer):
    """Count words in text"""
    def __init__(self, text):
        print('Start WordCounter.__init__()')
        super().__init__(text)
        self.word_count = len(self.tokens)
        print('End WordCounter.__init__()')


class Vocabulary(Tokenizer):
    """Find unique words in text"""
    def __init__(self, text):
        print('Start init Vocabulary.__init__()')
        super().__init__(text)
        self.vocab = set(self.tokens)
        print('End init Vocabulary.__init__()')


class TextDescriber(WordCounter, Vocabulary):
    """Describe text with multiple metrics"""
    def __init__(self, text):
        print('Start init TextDescriber.__init__()')
        super().__init__(text)
        print('End init TextDescriber.__init__()')


td = TextDescriber('row row row your boat')
print('--------')
print(td.tokens)
print(td.vocab)
print(td.word_count)
Didukung oleh

Output

Start init TextDescriber.__init__()
Start WordCounter.__init__()
Start init Vocabulary.__init__()
Start Tokenizer.__init__()
End Tokenizer.__init__()
End init Vocabulary.__init__()
End WordCounter.__init__()
End init TextDescriber.__init__()
--------
['row', 'row', 'row', 'your', 'boat']
{'boat', 'your', 'row'}
5
Didukung oleh

Pertama, kita melihat kelas TextDescriber mewarisi semua atribut dari pohon keluarga kelas. Berkat multiple inheritance kita dapat "menggabungkan" fungsionalitas lebih dari satu kelas.

Sekarang mari bahas keluaran print yang berasal dari metode init setiap kelas:

Setiap metode __init__ dipanggil satu kali dan hanya satu kali.

Kelas TextDescriber mewarisi dari 2 kelas yang mewarisi dari Tokenizer. Mengapa Tokenizer.__init__ tidak dipanggil dua kali?

Jika kita mengganti semua pemanggilan super dengan cara lama, kita akan berakhir dengan 2 pemanggilan Tokenizer.__init__. Pemanggilan ke super lebih "memikirkan" pola kita dan melewatkan perjalanan ekstra ke A.

Setiap metode __init__ dimulai sebelum salah satu yang lain selesai.

Urutan mulai dan selesai dari setiap __init__ patut diperhatikan jika Anda mencoba menetapkan atribut yang memiliki konflik penamaan dengan parent class lain. Atribut tersebut akan ditimpa, dan ini bisa menjadi sangat membingungkan.

Dalam kasus kita, kita menghindari konflik penamaan dengan atribut yang diwarisi, sehingga semuanya bekerja sesuai harapan.

Perlu ditegaskan, diamond problem bisa menjadi rumit dengan cepat dan menyebabkan hasil yang tidak terduga. Dalam sebagian besar kasus pemrograman, sebaiknya hindari desain yang rumit.

Apa yang kita pelajari

• Kita mempelajari fungsi super dan bagaimana fungsi ini dapat digunakan untuk menggantikan ParentName.method dalam single inheritance. Ini bisa menjadi praktik yang lebih mudah dirawat.
• Kita mempelajari multiple inheritance dan bagaimana kita dapat mewariskan fungsionalitas dari beberapa parent class ke satu child class.
• Kita mempelajari multiple-resolution order dan bagaimana hal itu menentukan apa yang terjadi dalam multiple inheritance ketika ada konflik penamaan antar metode parent.
• Kita mempelajari diamond problem dan melihat contoh bagaimana penggunaan super menavigasi diamond tersebut.