在Python中，調(diào)用父類的__init__方法主要有兩種方式。 1. 使用super()函數(shù)，這是現(xiàn)代且推薦的方法，它使代碼更清晰，並自動遵循方法解析順序（MRO），例如super().__init__(name)。 2. 直接調(diào)用父類的__init__方法，如Parent.__init__(self, name)，這在需要完全控製或處理舊代碼時有用，但不會自動遵循MRO。在多重繼承情況下，應始終一致地使用super()以確保正確的初始化順序和行為。

In Python, calling the parent class's __init__ method is a common need when working with inheritance. If you're creating a subclass and want to make sure the initialization logic from the parent class runs properly, there are clear ways to do that.

Using super() in Python 3

The most modern and recommended way to call the parent class's __init__ is by using the super() function. This keeps your code clean and avoids hardcoding the parent class name.

For example:

 class Parent:
    def __init__(self, name):
        self.name = name

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name) # Calls Parent's __init__
        self.age = age

Here, super().__init__(name) makes sure the Parent class initializes the name attribute.
This approach works well even if you have multiple levels of inheritance, since super() follows the method resolution order (MRO) automatically.

A few things to keep in mind:

• You don't need to pass self when using super() in Python 3.
• Always match the parameters expected by the parent class's __init__ .

Calling Parent Class Directly

Another option is to explicitly call the parent class's __init__ by referring to it directly.

Like this:

 class Parent:
    def __init__(self, name):
        self.name = name

class Child(Parent):
    def __init__(self, name, age):
        Parent.__init__(self, name) # Explicit call
        self.age = age

This can be useful in certain situations — especially if you're dealing with older Python 2 code or multiple inheritance where you want full control.

But here's the catch:

• It doesn't follow the MRO automatically like super() does.
• If your class inherits from more than one parent class, this might cause issues unless you're careful.

So, use this method only when you know what you're doing or when you specifically need to bypass super() behavior.

Handling Multiple Inheritance

When a class inherits from multiple parents, using super() becomes even more important.

Take this example:

 class A:
    def __init__(self):
        print("A init")

class B(A):
    def __init__(self):
        print("B before")
        super().__init__()
        print("B after")

class C(A):
    def __init__(self):
        print("C before")
        super().__init__()
        print("C after")

class D(B, C):
    def __init__(self):
        print("D before")
        super().__init__()
        print("D after")

Calling D().__init__() would output based on Python's MRO:

 D before
B before
C before
A init
C after
B after
D after

Each __init__ runs once and in the right order thanks to super() .
If you skipped super() in any of these classes, some initializations wouldn't happen at all.

So, in multiple inheritance cases, always use super() consistently across all __init__ methods involved.

That's how you handle parent class initialization in Python. Whether you go with super() or direct calls depends on your needs, but sticking with super() is usually the safer bet.

以上是如何在python中調(diào)用父班啟動？的詳細內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！