Bagaimana cara super () Python bekerja dengan multiple inheritance?

Saya cukup baru dalam pemrograman berorientasi objek Python dan saya mengalami kesulitan memahami super()fungsi (kelas gaya baru) terutama ketika datang ke beberapa warisan.

Misalnya jika Anda memiliki sesuatu seperti:

class First(object):
    def __init__(self):
        print "first"

class Second(object):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__()
        print "that's it"

Yang tidak saya dapatkan adalah: apakah Third()kelas mewarisi kedua metode konstruktor? Jika ya, lalu yang mana yang akan dijalankan dengan super () dan mengapa?

Dan bagaimana jika Anda ingin menjalankan yang lain? Saya tahu ini ada hubungannya dengan metode resolusi urutan Python ( MRO ).

Ini dirinci dengan jumlah detail yang masuk akal oleh Guido sendiri dalam posting blognya Metode Resolution Order (termasuk dua upaya sebelumnya).

Dalam contoh Anda, Third()akan menelepon First.__init__. Python mencari setiap atribut dalam orangtua kelas karena mereka terdaftar kiri ke kanan. Dalam hal ini, kami sedang mencari __init__. Jadi, jika Anda mendefinisikan

class Third(First, Second):
    ...

Python akan mulai dengan melihat First, dan, jika Firsttidak memiliki atribut, maka akan terlihat Second.

Situasi ini menjadi lebih kompleks ketika warisan mulai melintasi jalur (misalnya jika Firstdiwarisi dari Second). Bacalah tautan di atas untuk detail lebih lanjut, tetapi, singkatnya, Python akan mencoba mempertahankan urutan di mana setiap kelas muncul di daftar warisan, dimulai dengan kelas anak itu sendiri.

Jadi, misalnya, jika Anda punya:

class First(object):
    def __init__(self):
        print "first"

class Second(First):
    def __init__(self):
        print "second"

class Third(First):
    def __init__(self):
        print "third"

class Fourth(Second, Third):
    def __init__(self):
        super(Fourth, self).__init__()
        print "that's it"

MRO akan menjadi [Fourth, Second, Third, First].

By the way: jika Python tidak dapat menemukan urutan resolusi metode yang koheren, itu akan menimbulkan pengecualian, bukannya kembali ke perilaku yang mungkin mengejutkan pengguna.

Diedit untuk menambahkan contoh MRO yang ambigu:

class First(object):
    def __init__(self):
        print "first"

class Second(First):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        print "third"

Haruskah ThirdMRO menjadi [First, Second]atau [Second, First]? Tidak ada harapan yang jelas, dan Python akan meningkatkan kesalahan:

TypeError: Error when calling the metaclass bases
    Cannot create a consistent method resolution order (MRO) for bases Second, First

Sunting: Saya melihat beberapa orang berpendapat bahwa contoh di atas tidak memiliki super()panggilan, jadi izinkan saya menjelaskan: Inti dari contoh adalah untuk menunjukkan bagaimana MRO dibangun. Mereka tidak dimaksudkan untuk mencetak "first \ nsecond \ third" atau apa pun. Anda dapat - dan harus, tentu saja, bermain-main dengan contoh ini, menambahkan super()panggilan, melihat apa yang terjadi, dan mendapatkan pemahaman yang lebih dalam tentang model pewarisan Python. Tetapi tujuan saya di sini adalah untuk membuatnya tetap sederhana dan menunjukkan bagaimana MRO dibangun. Dan itu dibangun seperti yang saya jelaskan:

>>> Fourth.__mro__
(<class '__main__.Fourth'>,
 <class '__main__.Second'>, <class '__main__.Third'>,
 <class '__main__.First'>,
 <type 'object'>)

Kode Anda, dan jawaban lainnya, semuanya bermasalah. Mereka kehilangan super()panggilan dalam dua kelas pertama yang diperlukan agar subclass koperasi bekerja.

Ini adalah versi kode yang sudah diperbaiki:

class First(object):
    def __init__(self):
        super(First, self).__init__()
        print("first")

class Second(object):
    def __init__(self):
        super(Second, self).__init__()
        print("second")

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__()
        print("third")

The super()panggilan menemukan metode berikutnya di MRO di setiap langkah, yang mengapa Pertama dan Kedua harus memilikinya juga, jika eksekusi berhenti di akhir Second.__init__().

Inilah yang saya dapatkan:

>>> Third()
second
first
third

Saya ingin menguraikan jawaban dengan sedikit mati karena ketika saya mulai membaca tentang cara menggunakan super () dalam hierarki pewarisan berganda di Python, saya tidak segera mendapatkannya.

Yang perlu Anda pahami adalah super(MyClass, self).__init__()menyediakan metode berikutnya __init__ sesuai dengan algoritma Method Resolution Ordering (MRO) yang digunakan dalam konteks hierarki warisan lengkap .

Bagian terakhir ini penting untuk dipahami. Mari kita perhatikan contohnya lagi:

#!/usr/bin/env python2

class First(object):
  def __init__(self):
    print "First(): entering"
    super(First, self).__init__()
    print "First(): exiting"

class Second(object):
  def __init__(self):
    print "Second(): entering"
    super(Second, self).__init__()
    print "Second(): exiting"

class Third(First, Second):
  def __init__(self):
    print "Third(): entering"
    super(Third, self).__init__()
    print "Third(): exiting"

Menurut artikel ini tentang Metode Penyelesaian Resolusi oleh Guido van Rossum, perintah untuk menyelesaikan __init__dihitung (sebelum Python 2.3) menggunakan "traversal kiri-ke-kanan kedalaman-pertama":

Third --> First --> object --> Second --> object

Setelah menghapus semua duplikat, kecuali yang terakhir, kami mendapatkan:

Third --> First --> Second --> object

Jadi, mari ikuti apa yang terjadi ketika kita membuat instance dari Thirdkelas, misalnya x = Third().

1. Menurut MRO Third.__init__dieksekusi.
   • cetakan Third(): entering
   • kemudian super(Third, self).__init__()jalankan dan pengembalian MRO First.__init__yang disebut.
2. First.__init__ mengeksekusi.
   • cetakan First(): entering
   • kemudian super(First, self).__init__()jalankan dan pengembalian MRO Second.__init__yang disebut.
3. Second.__init__ mengeksekusi.
   • cetakan Second(): entering
   • kemudian super(Second, self).__init__()jalankan dan pengembalian MRO object.__init__yang disebut.
4. object.__init__ dijalankan (tidak ada pernyataan cetak dalam kode di sana)
5. eksekusi kembali ke Second.__init__yang kemudian dicetakSecond(): exiting
6. eksekusi kembali ke First.__init__yang kemudian dicetakFirst(): exiting
7. eksekusi kembali ke Third.__init__yang kemudian dicetakThird(): exiting

Ini menjelaskan mengapa instantiating Third () menghasilkan ke:

Third(): entering
First(): entering
Second(): entering
Second(): exiting
First(): exiting
Third(): exiting

Algoritma MRO telah ditingkatkan dari Python 2.3 dan seterusnya untuk bekerja dengan baik dalam kasus-kasus yang kompleks, tapi saya rasa menggunakan "kedalaman-pertama-ke-kanan traversal" + "menghapus duplikat harapan untuk yang terakhir" masih berfungsi dalam kebanyakan kasus (silakan berkomentar jika ini bukan masalahnya). Pastikan untuk membaca posting blog oleh Guido!

Ini dikenal sebagai Masalah Berlian , halaman tersebut memiliki entri pada Python, tetapi singkatnya, Python akan memanggil metode superclass dari kiri ke kanan.

Ini adalah bagaimana saya memecahkan masalah memiliki beberapa pewarisan dengan variabel yang berbeda untuk inisialisasi dan memiliki beberapa MixIns dengan pemanggilan fungsi yang sama. Saya harus secara eksplisit menambahkan variabel untuk lulus ** kwargs dan menambahkan antarmuka MixIn menjadi titik akhir untuk panggilan super.

Berikut Aadalah kelas dasar yang dapat diperpanjang dan Bdan Cmerupakan kelas MixIn yang menyediakan fungsi f. Adan Bkeduanya mengharapkan parameter vdi __init__dan Cmengharapkan mereka w. Fungsi ini fmengambil satu parameter y. Qmewarisi dari ketiga kelas. MixInFadalah antarmuka mixin untuk Bdan C.

• IPython NoteBook Dari Kode Ini
• Github Repo dengan contoh kode

class A(object):
    def __init__(self, v, *args, **kwargs):
        print "A:init:v[{0}]".format(v)
        kwargs['v']=v
        super(A, self).__init__(*args, **kwargs)
        self.v = v


class MixInF(object):
    def __init__(self, *args, **kwargs):
        print "IObject:init"
    def f(self, y):
        print "IObject:y[{0}]".format(y)


class B(MixInF):
    def __init__(self, v, *args, **kwargs):
        print "B:init:v[{0}]".format(v)
        kwargs['v']=v
        super(B, self).__init__(*args, **kwargs)
        self.v = v
    def f(self, y):
        print "B:f:v[{0}]:y[{1}]".format(self.v, y)
        super(B, self).f(y)


class C(MixInF):
    def __init__(self, w, *args, **kwargs):
        print "C:init:w[{0}]".format(w)
        kwargs['w']=w
        super(C, self).__init__(*args, **kwargs)
        self.w = w
    def f(self, y):
        print "C:f:w[{0}]:y[{1}]".format(self.w, y)
        super(C, self).f(y)


class Q(C,B,A):
    def __init__(self, v, w):
        super(Q, self).__init__(v=v, w=w)
    def f(self, y):
        print "Q:f:y[{0}]".format(y)
        super(Q, self).f(y)

Saya mengerti ini tidak langsung menjawab super() pertanyaan, tetapi saya merasa cukup relevan untuk dibagikan.

Ada juga cara untuk memanggil langsung setiap kelas yang diwarisi:

class First(object):
    def __init__(self):
        print '1'

class Second(object):
    def __init__(self):
        print '2'

class Third(First, Second):
    def __init__(self):
        Second.__init__(self)

Catatan saja bahwa jika Anda melakukannya dengan cara ini, Anda harus memanggil satu sama secara manual karena saya cukup yakin First's __init__()tidak akan dipanggil.

Secara keseluruhan

Dengan asumsi semuanya turun dari object(Anda berada di Anda sendiri jika tidak), Python menghitung urutan resolusi metode (MRO) berdasarkan pohon warisan kelas Anda. MRO memenuhi 3 properti:

• Anak-anak dari kelas datang sebelum orang tua mereka
• Orang tua kiri datang sebelum orang tua benar
• Kelas hanya muncul sekali di MRO

Jika tidak ada pemesanan seperti itu, kesalahan Python. Cara kerja bagian dalam ini adalah Linerisasi C3 dari nenek moyang kelas. Baca semua tentang ini di sini: https://www.python.org/download/releases/2.3/mro/

Jadi, dalam kedua contoh di bawah, itu adalah:

1. Anak
2. Kiri
3. Baik
4. Induk

Ketika suatu metode dipanggil, kemunculan pertama metode itu di MRO adalah yang disebut. Setiap kelas yang tidak mengimplementasikan metode itu dilewati. Panggilan apa pun ke superdalam metode itu akan memanggil kemunculan metode itu selanjutnya di MRO. Akibatnya, itu penting baik urutan mana Anda menempatkan kelas dalam warisan, dan di mana Anda menempatkan panggilansuper dalam metode.

Dengan superpertama di setiap metode

class Parent(object):
    def __init__(self):
        super(Parent, self).__init__()
        print "parent"

class Left(Parent):
    def __init__(self):
        super(Left, self).__init__()
        print "left"

class Right(Parent):
    def __init__(self):
        super(Right, self).__init__()
        print "right"

class Child(Left, Right):
    def __init__(self):
        super(Child, self).__init__()
        print "child"

Child() Output:

parent
right
left
child

Dengan yang superterakhir di setiap metode

class Parent(object):
    def __init__(self):
        print "parent"
        super(Parent, self).__init__()

class Left(Parent):
    def __init__(self):
        print "left"
        super(Left, self).__init__()

class Right(Parent):
    def __init__(self):
        print "right"
        super(Right, self).__init__()

class Child(Left, Right):
    def __init__(self):
        print "child"
        super(Child, self).__init__()

Child() Output:

child
left
right
parent

Tentang @ komentar calfzhou ini , Anda dapat menggunakan, seperti biasanya, **kwargs:

Contoh menjalankan online

class A(object):
  def __init__(self, a, *args, **kwargs):
    print("A", a)

class B(A):
  def __init__(self, b, *args, **kwargs):
    super(B, self).__init__(*args, **kwargs)
    print("B", b)

class A1(A):
  def __init__(self, a1, *args, **kwargs):
    super(A1, self).__init__(*args, **kwargs)
    print("A1", a1)

class B1(A1, B):
  def __init__(self, b1, *args, **kwargs):
    super(B1, self).__init__(*args, **kwargs)
    print("B1", b1)


B1(a1=6, b1=5, b="hello", a=None)

Hasil:

A None
B hello
A1 6
B1 5

Anda juga dapat menggunakannya secara posisi:

B1(5, 6, b="hello", a=None)

tetapi Anda harus mengingat MRO, itu benar-benar membingungkan.

Saya bisa sedikit mengganggu, tetapi saya perhatikan bahwa orang-orang lupa setiap kali menggunakan *argsdan **kwargsketika mereka mengganti metode, sementara itu salah satu dari sedikit penggunaan yang benar-benar bermanfaat dan waras dari 'variabel ajaib' ini.

Poin lain yang belum dibahas adalah melewati parameter untuk inisialisasi kelas. Karena tujuan darisuper bergantung pada subkelas, satu-satunya cara yang baik untuk melewatkan parameter adalah mengemas semuanya. Maka berhati-hatilah untuk tidak memiliki nama parameter yang sama dengan makna yang berbeda.

Contoh:

class A(object):
    def __init__(self, **kwargs):
        print('A.__init__')
        super().__init__()

class B(A):
    def __init__(self, **kwargs):
        print('B.__init__ {}'.format(kwargs['x']))
        super().__init__(**kwargs)


class C(A):
    def __init__(self, **kwargs):
        print('C.__init__ with {}, {}'.format(kwargs['a'], kwargs['b']))
        super().__init__(**kwargs)


class D(B, C): # MRO=D, B, C, A
    def __init__(self):
        print('D.__init__')
        super().__init__(a=1, b=2, x=3)

print(D.mro())
D()

memberi:

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
D.__init__
B.__init__ 3
C.__init__ with 1, 2
A.__init__

Memanggil kelas super __init__langsung ke penugasan parameter yang lebih langsung memang menggoda tetapi gagal jika adasuper panggilan di kelas super dan / atau MRO diubah dan kelas A dapat dipanggil beberapa kali, tergantung pada implementasinya.

Untuk menyimpulkan: pewarisan kooperatif dan parameter super dan spesifik untuk inisialisasi tidak bekerja bersama dengan sangat baik.

class First(object):
  def __init__(self, a):
    print "first", a
    super(First, self).__init__(20)

class Second(object):
  def __init__(self, a):
    print "second", a
    super(Second, self).__init__()

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__(10)
    print "that's it"

t = Third()

Output adalah

first 10
second 20
that's it

Panggilan ke Third () menempatkan init yang didefinisikan dalam Third. Dan panggilan ke super dalam rutin itu memanggil init yang didefinisikan dalam First. MRO = [Pertama, Kedua]. Sekarang panggilan ke super in init didefinisikan dalam Pertama akan terus mencari MRO dan menemukan init didefinisikan dalam Kedua, dan setiap panggilan ke super akan menekan objek init default . Saya harap contoh ini menjelaskan konsep ini.

Jika Anda tidak menelepon super dari Pertama. Rantai berhenti dan Anda akan mendapatkan output berikut.

first 10
that's it

Dalam learningpythonthehardway saya belajar sesuatu yang disebut super () fungsi bawaan jika tidak salah. Fungsi panggilan super () dapat membantu warisan melewati orang tua dan 'saudara kandung' dan membantu Anda melihat lebih jelas. Saya masih pemula tetapi saya senang berbagi pengalaman saya menggunakan super () ini di python2.7.

Jika Anda telah membaca komentar di halaman ini, Anda akan mendengar tentang Method Resolution Order (MRO), metode yang menjadi fungsi yang Anda tulis, MRO akan menggunakan skema Kedalaman-Pertama-Kiri-ke-Kanan untuk mencari dan menjalankan. Anda dapat melakukan lebih banyak penelitian tentang itu.

Dengan menambahkan fungsi super ()

super(First, self).__init__() #example for class First.

Anda dapat menghubungkan beberapa instance dan 'keluarga' dengan super (), dengan menambahkan masing-masing dan semua orang di dalamnya. Dan itu akan mengeksekusi metode, pergi melalui mereka dan pastikan Anda tidak ketinggalan! Namun, menambahkannya sebelum atau sesudahnya akan membuat perbedaan, Anda akan tahu jika Anda telah melakukan latihan setelah latihan 44. Biarkan kesenangan dimulai !!

Mengambil contoh di bawah ini, Anda dapat menyalin & menempel dan coba jalankan:

class First(object):
    def __init__(self):

        print("first")

class Second(First):
    def __init__(self):
        print("second (before)")
        super(Second, self).__init__()
        print("second (after)")

class Third(First):
    def __init__(self):
        print("third (before)")
        super(Third, self).__init__()
        print("third (after)")


class Fourth(First):
    def __init__(self):
        print("fourth (before)")
        super(Fourth, self).__init__()
        print("fourth (after)")


class Fifth(Second, Third, Fourth):
    def __init__(self):
        print("fifth (before)")
        super(Fifth, self).__init__()
        print("fifth (after)")

Fifth()

Bagaimana cara kerjanya? Contoh dari kelima () akan seperti ini. Setiap langkah beralih dari kelas ke kelas tempat fungsi super ditambahkan.

1.) print("fifth (before)")
2.) super()>[Second, Third, Fourth] (Left to right)
3.) print("second (before)")
4.) super()> First (First is the Parent which inherit from object)

Orangtua ditemukan dan akan berlanjut ke Ketiga dan Keempat !!

5.) print("third (before)")
6.) super()> First (Parent class)
7.) print ("Fourth (before)")
8.) super()> First (Parent class)

Sekarang semua kelas dengan super () telah diakses! Kelas induk telah ditemukan dan dieksekusi dan sekarang terus membuka kotak fungsi dalam warisan untuk menyelesaikan kode.

9.) print("first") (Parent)
10.) print ("Fourth (after)") (Class Fourth un-box)
11.) print("third (after)") (Class Third un-box)
12.) print("second (after)") (Class Second un-box)
13.) print("fifth (after)") (Class Fifth un-box)
14.) Fifth() executed

Hasil dari program di atas:

fifth (before)
second (before
third (before)
fourth (before)
first
fourth (after)
third (after)
second (after)
fifth (after)

Bagi saya dengan menambahkan super () memungkinkan saya untuk melihat lebih jelas tentang bagaimana python akan mengeksekusi pengkodean saya dan memastikan warisan dapat mengakses metode yang saya maksud.

Saya ingin menambahkan apa yang dikatakan @Visionscaper di bagian atas:

Third --> First --> object --> Second --> object

Dalam hal ini interpreter tidak memfilter kelas objek karena diduplikasi, melainkan karena kedua muncul dalam posisi kepala dan tidak muncul dalam posisi ekor dalam subset hierarki. Sedangkan objek hanya muncul di posisi ekor dan tidak dianggap posisi kuat dalam algoritma C3 untuk menentukan prioritas.

Linearisasi (mro) dari kelas C, L (C), adalah

• Kelas C
• ditambah penggabungan
  • linearisasi dari orang tuanya P1, P2, .. = L (P1, P2, ...) dan
  • daftar orang tuanya P1, P2, ..

Penggabungan Linier dilakukan dengan memilih kelas umum yang muncul sebagai kepala daftar dan bukan ekor karena urutan penting (akan menjadi jelas di bawah)

Linearisasi Ketiga dapat dihitung sebagai berikut:

    L(O)  := [O]  // the linearization(mro) of O(object), because O has no parents

    L(First)  :=  [First] + merge(L(O), [O])
               =  [First] + merge([O], [O])
               =  [First, O]

    // Similarly, 
    L(Second)  := [Second, O]

    L(Third)   := [Third] + merge(L(First), L(Second), [First, Second])
                = [Third] + merge([First, O], [Second, O], [First, Second])
// class First is a good candidate for the first merge step, because it only appears as the head of the first and last lists
// class O is not a good candidate for the next merge step, because it also appears in the tails of list 1 and 2, 
                = [Third, First] + merge([O], [Second, O], [Second])
// class Second is a good candidate for the second merge step, because it appears as the head of the list 2 and 3
                = [Third, First, Second] + merge([O], [O])            
                = [Third, First, Second, O]

Jadi untuk implementasi super () dalam kode berikut:

class First(object):
  def __init__(self):
    super(First, self).__init__()
    print "first"

class Second(object):
  def __init__(self):
    super(Second, self).__init__()
    print "second"

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__()
    print "that's it"

menjadi jelas bagaimana metode ini akan diselesaikan

Third.__init__() ---> First.__init__() ---> Second.__init__() ---> 
Object.__init__() ---> returns ---> Second.__init__() -
prints "second" - returns ---> First.__init__() -
prints "first" - returns ---> Third.__init__() - prints "that's it"

Dalam pewarisan python 3.5+ terlihat dapat diprediksi dan sangat bagus untuk saya. Silakan lihat kode ini:

class Base(object):
  def foo(self):
    print("    Base(): entering")
    print("    Base(): exiting")


class First(Base):
  def foo(self):
    print("   First(): entering Will call Second now")
    super().foo()
    print("   First(): exiting")


class Second(Base):
  def foo(self):
    print("  Second(): entering")
    super().foo()
    print("  Second(): exiting")


class Third(First, Second):
  def foo(self):
    print(" Third(): entering")
    super().foo()
    print(" Third(): exiting")


class Fourth(Third):
  def foo(self):
    print("Fourth(): entering")
    super().foo()
    print("Fourth(): exiting")

Fourth().foo()
print(Fourth.__mro__)

Output:

Fourth(): entering
 Third(): entering
   First(): entering Will call Second now
  Second(): entering
    Base(): entering
    Base(): exiting
  Second(): exiting
   First(): exiting
 Third(): exiting
Fourth(): exiting
(<class '__main__.Fourth'>, <class '__main__.Third'>, <class '__main__.First'>, <class '__main__.Second'>, <class '__main__.Base'>, <class 'object'>)

Seperti yang Anda lihat, ia memanggil foo tepat SATU kali untuk setiap rantai yang diwarisi dalam urutan yang sama seperti yang diwarisi. Anda bisa mendapatkan pesanan itu dengan menelepon . mro :

Keempat -> Ketiga -> Pertama -> Kedua -> Basis -> objek

Mungkin masih ada sesuatu yang bisa ditambahkan, contoh kecil dengan Django rest_framework, dan dekorator. Ini memberikan jawaban untuk pertanyaan tersirat: "mengapa saya tetap menginginkan ini?"

Seperti yang dikatakan: kami menggunakan Django rest_framework, dan kami menggunakan tampilan umum, dan untuk setiap jenis objek dalam basis data kami, kami mendapati diri kami dengan satu kelas tampilan yang menyediakan GET dan POST untuk daftar objek, dan kelas tampilan lainnya menyediakan GET , PUT, dan DELETE untuk objek individual.

Sekarang POST, PUT, dan DELETE kami ingin menghiasnya dengan login_required Django. Perhatikan bagaimana ini menyentuh kedua kelas, tetapi tidak semua metode di kedua kelas.

Sebuah solusi bisa melalui banyak pewarisan.

from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required

class LoginToPost:
    @method_decorator(login_required)
    def post(self, arg, *args, **kwargs):
        super().post(arg, *args, **kwargs)

Demikian juga untuk metode lainnya.

Dalam daftar warisan kelas konkret saya, saya akan menambahkan LoginToPostsebelum ListCreateAPIViewdan LoginToPutOrDeletesebelumnya RetrieveUpdateDestroyAPIView. Kelas konkret saya getakan tetap tidak didekorasi.

Posting jawaban ini untuk referensi saya di masa mendatang.

Python Multiple Inheritance harus menggunakan model berlian dan tanda tangan fungsi tidak boleh berubah dalam model.

    A
   / \
  B   C
   \ /
    D

Cuplikan kode contoh adalah; -

class A:
    def __init__(self, name=None):
        #  this is the head of the diamond, no need to call super() here
        self.name = name

class B(A):
    def __init__(self, param1='hello', **kwargs):
        super().__init__(**kwargs)
        self.param1 = param1

class C(A):
    def __init__(self, param2='bye', **kwargs):
        super().__init__(**kwargs)
        self.param2 = param2

class D(B, C):
    def __init__(self, works='fine', **kwargs):
        super().__init__(**kwargs)
        print(f"{works=}, {self.param1=}, {self.param2=}, {self.name=}")

d = D(name='Testing')

Di sini kelas A adalah object