Python中子类、父类的继承、调用、传参_csdn 子类 python

1.继承

        在Python中，子类和父类之间的关系是通过继承来实现的。继承允许子类继承父类的属性和方法，并且还可以在子类中添加新的属性和方法，或者重写父类的方法。

        下面是一个简单的示例，展示了如何创建一个父类和一个子类，并在子类中继承和扩展父类的功能：

# 定义一个父类
class Animal:
    def __init__(self, name):
        self.name = name
 
    def speak(self):
        print(f"{self.name}发出了声音。")
 
# 定义一个子类，继承自Animal类
class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类的构造函数
        super().__init__(name)
        self.breed = breed
 
    def speak(self):
        # 调用父类的方法
        super().speak()
        print("汪汪汪！")
 
    def fetch(self):
        print(f"{self.name}正在追逐球。")
 
# 创建一个父类的实例
animal = Animal("动物")
animal.speak()
 
# 创建一个子类的实例
dog = Dog("小狗", "柯基")
dog.speak()
dog.fetch()

 2.调用

         在子类中调用父类的函数，可以使用 super() 来访问和调用父类的方法。以下是一个示例：

class Parent:
    def __init__(self):
        self.name = "Parent"
 
    def greet(self):
        print("Hello from", self.name)
 
class Child(Parent):
    def __init__(self):
        super().__init__()
        self.name = "Child"
 
    def greet(self):
        super().greet()
        print("Nice to meet you!")
 
# 创建子类实例
child = Child()
child.greet()

        输出：

Hello from Child
Nice to meet you!

        在上述示例中，Child 类继承自 Parent 类。子类 Child 中的 __init__ 方法使用 super().__init__() 调用了父类 Parent 的构造函数，以初始化 name 属性。

        在子类 Child 中的 greet 方法中，我们首先使用 super().greet() 调用父类 Parent 的 greet 方法，从而打印出 "Hello from Child"。然后，我们在子类的 greet 方法中添加了额外的打印语句，输出 "Nice to meet you!"。

        通过使用 super()，我们可以在子类中调用父类的函数。这样可以实现在子类中扩展父类方法的功能，或者在子类中使用父类的方法进行特定的操作。在示例中，子类 Child 在调用父类的 greet 方法后，添加了自己的额外打印语句。

3.传参

        有两个类 FasterRCNNBase 和 FasterRCNN，其中 FasterRCNN 是 FasterRCNNBase 的子类。如果要在 FasterRCNN 的构造函数中调用父类 FasterRCNNBase 的构造函数，将 backbone、rpn、roi_heads 和 transform 作为参数传递给父类。代码示例如下：

class FasterRCNNBase(nn.Module):
    def __init__(self, backbone, rpn, roi_heads, transform):
        super(FasterRCNNBase, self).__init__()
        # 在父类构造函数中执行初始化或其他操作
        # ...
 
 
class FasterRCNN(FasterRCNNBase):
    def __init__(self, backbone, num_classes=None):
        super(FasterRCNN, self).__init__(backbone, rpn, roi_heads, transform)
        # 在子类构造函数中进行额外的初始化或其他操作
        # ...

        在 FasterRCNN 的构造函数中，我们使用 super(FasterRCNN, self).__init__(backbone, rpn, roi_heads, transform) 的方式调用了父类 FasterRCNNBase 的构造函数，并将 backbone、rpn、roi_heads 和 transform 作为参数传递给父类的构造函数。

        这样，当你实例化 FasterRCNN 类时，父类 FasterRCNNBase 的构造函数将会被调用，其中的初始化操作将会执行，同时子类 FasterRCNN 的构造函数也可以在需要时进行额外的初始化或其他操作。

        将 super(FasterRCNN, self).__init__(backbone, rpn, roi_heads, transform) 改为 super().__init__(backbone, rpn, roi_heads, transform) 不会有实质性的不同，因为 FasterRCNN 类没有多重继承。

        在单一继承的情况下，super().__init__(...) 会自动确定父类并调用其构造函数，而不需要显式指定父类的名称。因此，super(FasterRCNN, self).__init__(backbone, rpn, roi_heads, transform) 和 super().__init__(backbone, rpn, roi_heads, transform) 在这种情况下是等价的。

        在多重继承的情况下，super() 的使用会有所不同。当一个类有多个父类时，super() 用于指定在继承链中的下一个类，并调用该类的方法。

        在多重继承中，每个父类都可以通过 super() 调用其在继承链中的下一个父类的方法。这样可以确保方法按照正确的顺序被调用，避免重复调用或遗漏调用。

        以下是一个多重继承的示例，展示了 super() 在多重继承中的作用：

class ParentA:
    def __init__(self):
        print("ParentA")
 
class ParentB:
    def __init__(self):
        print("ParentB")
 
class Child(ParentA, ParentB):
    def __init__(self):
        super().__init__()  # 调用下一个父类的构造函数
        print("Child")
 
# 创建子类实例
child = Child()

        输出：

ParentB
ParentA
Child

        在上述示例中，Child 类同时继承了 ParentA 和 ParentB 两个父类。在子类 Child 的构造函数中，我们使用 super().__init__() 的方式调用了下一个父类 ParentB 的构造函数，然后再调用父类 ParentA 的构造函数。

        通过使用 super()，确保了父类构造函数的正确调用顺序，即使在多个父类的继承链中也能正确地传递参数和执行初始化操作。

        需要注意的是，多重继承中使用 super() 时，方法的调用顺序取决于类的定义顺序。在上述示例中，Child 类首先继承了 ParentA，然后是 ParentB。因此，首先调用的是 ParentB 的构造函数，然后是 ParentA 的构造函数，最后是 Child 类自身的构造函数。

        要在多重继承中使用 super() 并传递参数给 ParentA，可以通过在 super() 调用中传递参数来实现。以下是一个示例：

class ParentA:
    def __init__(self, param_a):
        print("ParentA:", param_a)
 
class ParentB:
    def __init__(self):
        print("ParentB")
 
class Child(ParentA, ParentB):
    def __init__(self, param_a, param_b):
        super().__init__(param_a)  # 传递参数给 ParentA
        print("Child:", param_b)
 
# 创建子类实例
child = Child("Hello", "World")

        输出：

ParentB
ParentA: Hello
Child: World

        在上述示例中，ParentA 类的构造函数接受一个参数 param_a，我们希望在子类 Child 的构造函数中传递该参数给 ParentA。为此，我们可以在 super() 调用中传递参数 param_a。

        在子类 Child 的构造函数中，我们使用 super().__init__(param_a) 的方式调用了下一个父类 ParentA 的构造函数，并将 param_a 作为参数传递给它。

        这样，在创建 Child 类的实例时，我们可以同时为 ParentA 和 Child 类传递所需的参数。在上述示例中，我们通过 Child("Hello", "World") 创建了一个实例，将字符串 "Hello" 作为 ParentA 的参数，将字符串 "World" 作为 Child 类的参数。