super()在Python中用於調(diào)用父類的方法，使代碼更易維護且減少耦合。 1. 它返回一個臨時的超類對象，允許你調(diào)用其方法，常用於子類重寫方法時仍執(zhí)行父類邏輯；2. 在單繼承中，使用super().method()即可調(diào)用父類方法，如在__init__或speak中擴展功能；3. 在多繼承中，super()遵循方法解析順序（MRO）依次調(diào)用父類方法，可通過ClassName.mro()查看順序；4. 若需指定調(diào)用某父類方法，可直接調(diào)用該類方法，但會增加耦合度；5. 常見錯誤包括遺漏參數(shù)和混用super()與顯式調(diào)用，建議統(tǒng)一使用super()並理解MRO以避免問題。

When you're working with inheritance in Python, super() is a handy tool that lets you call methods from a parent class without explicitly referring to the parent class name. This makes your code more maintainable and less prone to issues when class hierarchies change.

What does super() actually do?

At its core, super() returns a temporary object of the superclass, which allows you to call its methods. This is especially useful in cases where you're overriding a method in a child class but still want to use the logic from the parent class.

For example, if you have a Parent class with a method called __init__ , and a Child class that inherits from it, using super() inside the Child.__init__() method will let you run the Parent.__init__() method as well.

 class Parent:
    def __init__(self):
        print("Parent initialized")

class Child(Parent):
    def __init__(self):
        super().__init__()
        print("Child initialized")

Running Child() would output:

 Parent initialized
Child initialized

This helps avoid repeating code and keeps your inheritance chain clean.

How to use super() in single inheritance

In simple cases where one class inherits directly from another (single inheritance), using super() is straightforward. You just need to call super().method_name() inside the child class's corresponding method.

Here's a slightly more involved example:

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

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name) # Calls Animal's __init__
        self.breed = breed

    def speak(self):
        super().speak() # Calls Animal's speak()
        print(f"{self.name} barks!")

So when you create a Dog instance and call speak() , both the parent and child versions will execute:

 my_dog = Dog("Buddy", "Golden Retriever")
my_dog.speak()

Output:

 Buddy makes a sound.
Buddy barks!

• You can use super() in any method, not just __init__ .
• It ensures that the parent method gets called even if the parent class name changes later.

Using super() in multiple inheritance

Things get a bit trickier when dealing with multiple inheritance — when a class inherits from more than one parent. In this case, super() follows the Method Resolution Order (MRO) to decide which class's method to call.

Python determines MRO using the C3 linearization algorithm. You can check it by calling ClassName.mro() or help(ClassName) .

Let's look at an example:

 class A:
    def do_something(self):
        print("A")

class B:
    def do_something(self):
        print("B")

class C(A, B):
    def do_something(self):
        super().do_something()

If we call C().do_something() , it will print "A" because of MRO — it follows the order (C, A, B) .

But what if you want to call B's method specifically? Then you'd bypass super() and call it directly:

 class C(A, B):
    def do_something(self):
        B.do_something(self)

This gives you more control but also means tighter coupling — so only do it if necessary.

Common mistakes and tips

• ? Forgetting to pass arguments: If the parent method expects parameters (like __init__ ), make sure you include them when calling via super() .
• ? Use super() consistently: Mixing explicit parent calls ( Parent.method(self) ) and super() in the same hierarchy can lead to confusion or double-calls.
• ? Remember: super() isn't magic — it just follows the MRO. Understanding how MRO works will help you debug tricky inheritance issues.

That's basically how super() works in most everyday Python scenarios. It's powerful but easy to misuse if you're not careful — especially with multiple inheritance. But used correctly, it keeps your code DRY and easier to refactor.

以上是如何使用super（）調(diào)用python中的父方法？的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！