Python类学习(1)——未完待续_python 子类-优快云博客

Python中子类、父类的继承、调用、传参
本文详细介绍了Python中的继承机制，包括子类如何继承父类的属性和方法，如何在子类中扩展功能，以及使用super()调用父类函数和传递参数。通过实例演示了如何在类间传递参数和确保构造函数的正确调用顺序。

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 类的参数。

python继承父类的调用

class BaseRequest:
    pass
 
class RequestHandler(BaseRequest):
    def process_request(self):
        print("RequestHandler.process_request")
 
    def serve_forever(self):
        print("RequestHandler.serve_forever")
class Minx:
    def process_request(self):
        print("minx.process_request")
class Son(Minx,RequestHandler):
    pass
 
obj=Son()
obj.process_request()

在这里插入图片描述
3. Python:类的继承，调用父类的属性和方法基础详解
4. python-类以及如何访问类中的属性
5. python如何在一个类里面调用另一个类里面的东西？
6. python中在一个类中调用另一个类的方法
7. python一个类调用另一个类的方法_python中同一个类下面的不同方法内的变量的调用…
8. Python基础篇（14）：Python中不同类之间调用方法的四种方式
9. python中在一个类下的函数，向另一个类下的函数传递参数并运行另一个类下的函数…

在 Python 中，可以通过实例化类对象，在一个类的方法中调用另一个类的方法并传递参数，从而运行另一个类的方法。具体步骤如下：首先，在一个类的方法中实例化另一个类的对象，例如：

class ClassA:
    def method_a(self, arg):
        class_b = ClassB()
        result = class_b.method_b(arg)
        return result