super()核心作用是调用父类的属性/方法
Python 子类继承父类知识汇总
核心：子类通过 class 子类名(父类名): 继承父类属性和方法，支持单继承、多继承，可重写/扩展父类逻辑。
1. 基础继承语法（单继承）
class 父类:
def 父类方法(self):
print("父类方法执行")class 子类(父类): # 括号中指定父类
passobj = 子类()
obj.父类方法() # 子类实例直接调用父类方法
2. 构造方法继承与重写
- 子类无构造方法时，自动调用父类 __init__ ；
- 子类有构造方法时，需用 super() 显式调用父类构造（避免覆盖）。
class 父类:
def __init__(self, name):
self.name = nameclass 子类(父类):
def __init__(self, name, age):
super().__init__(name) # 调用父类构造，初始化name
self.age = age # 子类新增属性obj = 子类("张三", 20)
print(obj.name, obj.age) # 输出：张三 20
3. 方法重写与扩展
子类定义与父类同名的方法，实现自定义逻辑；用 super().方法名() 可保留父类功能。
class 父类:
def show(self):
print("父类展示")class 子类(父类):
def show(self):
super().show() # 执行父类show方法
print("子类扩展展示") # 新增子类逻辑obj = 子类()
obj.show() # 输出：父类展示 → 子类扩展展示
4. 多继承（多个父类）
语法： class 子类(父1, 父2, ...): ，按MRO（方法解析顺序） 查找属性/方法（从左到右）。
class 父1:
def func(self):
print("父1方法")class 父2:
def func(self):
print("父2方法")class 子类(父1, 父2): # 优先继承父1
passobj = 子类()
obj.func() # 输出：父1方法（遵循MRO顺序）
5. 访问控制（父类私有成员）
- 父类中 __属性名 （双下划线开头）为私有成员，子类无法直接访问；
- 可通过父类提供的公有方法间接访问，或用 _父类名__属性名 强制访问（不推荐）。
python
class 父类:
def __init__(self):
self.__私有属性 = "私有值" # 私有属性
def get_私有属性(self): # 公有方法暴露私有属性
return self.__私有属性
class 子类(父类):
def get_val(self):
return self.get_私有属性() # 通过父类公有方法访问
obj = 子类()
print(obj.get_val()) # 输出：私有值
6. 核心关键字
- super() ：调用父类的方法/构造，无需显式写父类名（多继承更友好）；
- isinstance(实例, 类) ：判断实例是否属于某个类（子类实例也属于父类）；
- issubclass(子类, 父类) ：判断类是否为另一个类的子类。
super() 核心作用是调用父类的属性/方法，避免硬编码父类名，适配单继承/多继承，以下是3个高频场景举例：
1. 单继承：调用父类构造方法（最常用）
class Animal:
def __init__(self, name):
self.name = name # 父类初始化属性
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # 调用父类__init__，传入name参数
self.breed = breed # 子类新增属性
dog = Dog("旺财", "中华田园犬")
print(dog.name, dog.breed) # 输出：旺财 中华田园犬
2. 单继承：调用父类普通方法
class Parent:
def eat(self):
print("父类：吃饭")
class Child(Parent):
def eat(self):
super().eat() # 先执行父类的eat方法
print("子类：加个蛋") # 再补充子类逻辑
c = Child()
c.eat()
# 输出：
# 父类：吃饭
# 子类：加个蛋
3. 多继承：按MRO顺序调用父类（Python 3默认）
class A:
def run(self):
print("A的run方法")
class B(A):
def run(self):
print("B的run方法")
class C(A):
def run(self):
print("C的run方法")
class D(B, C): # 继承顺序：D→B→C→A（MRO顺序）
def run(self):
super().run() # 调用MRO中下一个类（B）的run
super(B, self).run() # 跳过B，调用C的run
super(C, self).run() # 跳过C，调用A的run
d = D()
d.run()
# 输出：
# B的run方法
# C的run方法
# A的run方法
综合实战案例：学生管理系统（继承+重写+多继承+访问控制）
场景：设计「人员基类」→「学生子类」「教师子类」，学生额外继承「成绩管理类」，实现信息展示、成绩录入/查询，同时保护敏感信息（如密码）。
python
# 1. 基类：所有人员的公共属性和方法
class Person:
def __init__(self, name, id_card, password):
self.name = name # 公有属性
self.id_card = id_card # 公有属性
self.__password = password # 私有属性（敏感信息，禁止直接访问）
# 公有方法：暴露私有密码（模拟登录验证场景）
def verify_password(self, input_pwd):
return input_pwd == self.__password
# 基类方法：信息展示（子类将重写）
def show_info(self):
return f"姓名：{self.name}，身份证号：{self.id_card}"
# 2. 多继承的混入类：成绩管理功能（可被学生复用）
class ScoreManager:
def __init__(self):
self.scores = {} # 存储科目-分数映射
# 新增/修改成绩
def set_score(self, subject, score):
if 0 <= score <= 100:
self.scores[subject] = score
print(f"{subject}成绩录入成功：{score}分")
else:
print("分数必须在0-100之间！")
# 查询单科目成绩
def get_score(self, subject):
return self.scores.get(subject, f"未录入{subject}成绩")
# 查询所有成绩
def show_all_scores(self):
if self.scores:
return f"所有成绩：{self.scores}"
else:
return "暂无成绩记录"
# 3. 子类1：学生（继承 Person + ScoreManager 多继承）
class Student(Person, ScoreManager):
def __init__(self, name, id_card, password, student_id):
# 调用多个父类的构造方法（super() 适配多继承，按 MRO 顺序执行）
super().__init__(name, id_card, password)
ScoreManager.__init__(self) # 显式调用混入类构造
self.student_id = student_id # 学生特有属性
# 重写父类 show_info 方法：扩展学生专属信息
def show_info(self):
# 保留父类 Person 的信息，新增学生ID和成绩
base_info = super().show_info()
score_info = self.show_all_scores()
return f"【学生信息】{base_info}，学号：{self.student_id}，{score_info}"
# 4. 子类2：教师（仅继承 Person，无成绩管理功能）
class Teacher(Person):
def __init__(self, name, id_card, password, subject_teach):
super().__init__(name, id_card, password)
self.subject_teach = subject_teach # 教师特有属性：授课科目
# 重写父类 show_info 方法：扩展教师专属信息
def show_info(self):
base_info = super().show_info()
return f"【教师信息】{base_info}，授课科目：{self.subject_teach}"
# ------------------- 测试代码 -------------------
if __name__ == "__main__":
# 1. 创建学生实例（多继承+属性/方法复用）
student = Student(
name="张三",
id_card="110101201001011234",
password="student123",
student_id="2024001"
)
# 2. 学生操作：录入成绩（继承 ScoreManager 方法）
student.set_score("数学", 95)
student.set_score("英语", 88)
student.set_score("语文", 105) # 非法分数，会提示错误
# 3. 学生操作：验证密码（继承 Person 私有属性的访问逻辑）
print("密码验证结果：", student.verify_password("student123")) # True
# print(student.__password) # 报错！无法直接访问私有属性
# 4. 展示学生完整信息（重写后的 show_info）
print(student.show_info())
# 5. 创建教师实例（单继承）
teacher = Teacher(
name="李老师",
id_card="110101198001015678",
password="teacher456",
subject_teach="数学"
)
# 6. 展示教师信息（重写后的 show_info）
print(teacher.show_info())
案例核心知识点覆盖
1. 单继承：Teacher 仅继承 Person，复用密码验证、基础信息展示功能；
2. 多继承：Student 同时继承 Person（人员信息）和 ScoreManager（成绩管理），实现功能复用；
3. 方法重写：Student 和 Teacher 都重写了 show_info ，在父类基础上扩展专属信息；
4. 访问控制：Person 的 __password 为私有属性，只能通过 verify_password 方法访问，保护敏感数据；
5. super() 用法：子类构造中通过 super() 调用父类构造，多继承场景下无需显式写父类名；
6. 混入类设计：ScoreManager 作为独立功能类，被 Student 继承，实现功能模块化复用。
单继承示例（子类无 init）
python
class Parent: # 父类
def __init__(self):
self.name = "父类实例"
def show(self):
print(self.name)
class Child(Parent): # 子类继承父类，无自己的__init__
pass
# 调用：子类自动复用父类构造
c = Child()
c.show() # 输出：父类实例
单继承示例（子类有 init）
python
class Parent:
def __init__(self):
self.age = 30 # 父类初始化属性
class Child(Parent):
def __init__(self):
super().__init__() # 显式调用父类构造，否则age属性不存在
self.name = "子类实例" # 子类自己的属性
c = Child()
print(c.age, c.name) # 输出：30 子类实例
多继承示例（多个父类，显式调用构造）
python
class Father:
def __init__(self):
self.family_name = "张"
class Mother:
def __init__(self):
self.hair_color = "黑色"
class Child(Father, Mother): # 多继承，父类用逗号分隔
def __init__(self):
super().__init__() # 按继承顺序调用第一个父类（Father）构造
Mother.__init__(self) # 手动调用第二个父类（Mother）构造
self.age = 5
c = Child()
print(c.family_name, c.hair_color, c.age) # 输出：张 黑色 5