Python 类继承介绍，以及实现 Python 类继承，多重继承，方法重写

继承 Python 类

Python 支持类的继承，你可以定义一个从基类派生的类，其语法的基本形式如下。

class <classname>(<baseclass>):
    <block>

classname 部分

classname为派生类的名称，他需要符合 Python 的标识符规范，不能使用 Python 关键字或保留关键字。

baseclass 部分

baseclass是一个返回基类的表达式，其返回的基类应是可访问的，这与使用其他 Python 模块特性（比如，变量，函数）类似。

block 部分

block为派生类的主体代码，需要使用某种空白字符进行缩进，以表示其归属于派生类。

# 一个关于人的类
class Person:
	title = '该如何称呼哪？'


	def __init__(self, name, age):
		# 定义类的实例变量 name，age
		self.name = name
		self.age = age


# 表示好人的类，从 Person 继承
class GoodMan(Person):
	pass

判断 Python 对象的类型是否为某个类或其派生类

使用函数isinstance，你可以判断一个 Python 对象（实例）的类型，是否为某个 Python 类（包括抽象类）或其派生类（子类），或者是否为一组 Python 类中的某个类（包括抽象类）或其派生类（子类），返回True表示对象的类型是某个类或其派生类，返回False表示不是。

isinstance(object, classinfo, /)

object 参数

object参数为需要判断类型的 Python 对象。

classinfo 参数

classinfo参数为某个 Python 类，包含 Python 类的元组，或 Python 类的联合类型对象（需要 Python 3.10 或更高版本），联合类型（UnionType）对象可通过运算符|组合多个 Python 类获得。

# …
# 创建 GoodMan 的实例
goodman = GoodMan('好心人', 40)


# 判断实例 goodman 的类型是否为 Person 或 int
print(isinstance(goodman, (Person, int)))
# 判断实例 goodman 的类型是否为 int，float，str 中的一个
print(isinstance(goodman, int | float | str))

True
False

判断 Python 类是否为某个类的派生类

使用函数issubclass，你可以判断一个 Python 类，是否为某个 Python 类（包括抽象类）的派生类（子类），或者是否为一组 Python 类中的某个类（包括抽象类）的派生类（子类），返回True表示类是派生类，返回False表示不是。需要指出的是，issubclass会将一个 Python 类视为其自身的派生类。

issubclass(class, classinfo, /)

class 参数

class参数为需要判断是否为派生类的 Python 类。

classinfo 参数

classinfo参数为某个 Python 类，包含 Python 类的元组，或 Python 类的联合类型对象（需要 Python 3.10 或更高版本），联合类型（UnionType）对象可通过运算符|组合多个 Python 类获得。

# …
# 判断类 GoodMan 是否为 object 的子类
print(issubclass(GoodMan, object))
# 判断类 GoodMan 是否为 str 或 Person 的子类
print(issubclass(GoodMan, str | Person))
# 判断类 GoodMan 是否为 GoodMan 的子类
print(issubclass(GoodMan, GoodMan))

True
True
True

搜索 Python 继承链中的特性

如果对象对应的 Python 类中不存在想要访问的特性，可以是指实例特性或类特性，那么 Python 将在继承链的一个或多个基类中搜索，直至此特性被找到，或整个继承链被搜索完毕。对于读取操作（包括调用方法），未搜索到特性会引发异常，对于写入操作，未搜索到特性会导致新的特性被加入 Python 对象。

继承链中 Python 类和其基类之间的搜索顺序，需要通过 Python 的方法解析顺序（Method Resolution Order，MRO）来确定，Python 对象实际对应的类一般处于该顺序的首位。

当然，通过 Python 类访问类特性，与通过 Python 对象访问实例特性或类特性具有类似的搜索机制，只不过其搜索不涵盖 Python 类的实例特性。

# 一个关于植物的类
class Plant:
	# 类变量 variety
	variety = '未知种类'
	def __init__(self, name):
		# 实例变量 name
		self.name = name


# 继承自 Plant 类的类
class Tree(Plant):
	# 显示信息的方法
	def show(self):
		print(self.name)


tree = Tree('大树')
tree.show()
print(f'Tree 是什么种类？{Tree.variety}')


# age 并不存在，写入操作等于为 tree 增加实例变量
tree.age = 100
print(tree.age)
# ERROR 类变量 name 并不存在，读取操作将导致异常
print(Tree.name)

大树
Tree 是什么种类？未知种类
100
…
AttributeError: type object 'Tree' has no attribute 'name'

重写 Python 类的方法

基于上面描述的继承链搜索方式，你可以将 Python 类中定义的所有方法都视为虚方法（Virtual Method），这表示他们可以被重写（Override），如果访问级别允许的话。与模块中定义的 Python 函数一样，Python 类的方法签名默认仅包含名称信息，因此，派生类中定义的方法可以重写基类的同名方法，而不必在意参数的情况。

事实上，重写可针对 Python 类的任意特性，比如变量或属性，而不是仅限于方法。

# 一个游戏单位
class Unit:
	# 用于发起攻击的方法
	def attack(self):
		print('Unit 发起攻击')


class Hero(Unit):
	# 该方法将被之后定义的 attack 覆盖
	def attack(self, times):
		while times > 0:
			print('Hero 发起攻击')
			times -= 1


	# 将重写 Unit 的 attack 方法，并覆盖之前定义的 attack
	def attack(self, times):
		print(f'Hero 将发起 {times} 次攻击')


Unit().attack()
Hero().attack(5)
# ERROR 无法调用 Unit 类定义的 attack 方法
Hero().attack()

Unit 发起攻击
Hero 将发起 5 次攻击
…
TypeError: Hero.attack() missing 1 required positional argument: 'times'

多重继承 Python 类

Python 允许类的多重继承，你可以为一个 Python 类指定多个基类，只需要在定义类的语法中，让baseclass部分包含使用,分隔的多个基类即可。

class A:
	name = 'A'
	def show(self):
		print('调用 A 的 show 方法')


class B1(A):
	pass


class B2(A):
	def show(self):
		print('调用 B2 的 show 方法')


class C(B1, B2):
	pass


# 不会产生多义性问题，因为类 A 仅被搜索一次
print(C.name)
c = C()
# 调用 B2 的 show 方法，而不是 A 的 show 方法
c.show()

A
调用 B2 的 show 方法

调用 Python 基类中的方法

如果某个 Python 类重写了基类中的方法，并且希望继续使用基类所实现的功能，那么可以在重写的方法中，使用super类来调用基类的方法，该类实现了一种访问的代理功能，你可以像通过 Python 实例或类访问特性一样，通过super类的实例（对象）来访问特性，只不过super类需要指定特性的搜索起点，以实现对特定基类的访问。

super()
super(type, object_or_type=None, /)

type 参数

type参数是一个 Python 类，在方法解析顺序中，位于该 Python 类之后的第一个类将成为特性的搜索起点。

object_or_type 参数

object_or_type参数为需要搜索特性的 Python 实例或类，他们应该是type参数所表示的 Python 类或其派生类，或者是type参数所表示的 Python 类或其派生类的实例。如果忽略该参数，那么得到的super对象将处于未绑定状态，他可能无法完成你的预期目标。

对于不带有参数的super类的构造器，仅能在 Python 类的实例方法或类方法中使用，他的效果等同于书写super(type,self)，super(type,cls)，其中type为当前类，self为实例方法的self参数，cls为类方法的cls参数。

对于带有参数的super类的构造器，可以在 Python 类的方法或其他位置使用，如果是类的静态方法，那么需要采用形式为super(type,class)的表达式，其中type为用于指示搜索起点的 Python 类（方法解析顺序中，排在type对应的类之后的第一个类将作为搜索起点），class为当前类。由于指定了特性的搜索起点，因此，该构造器可实现更为细致的基类访问。

当然，不仅是基类中的方法，通过super类访问其他特性也是可行的，比如变量，属性。

class Animal:
	@staticmethod
	def show():
		print('这里是 Animal！')


	@classmethod
	def eat(cls, something):
		print(f'Animal 吃点 {something}')


	def run(self):
		print('Animal 奔跑起来了！')


class Cat(Animal):
	@staticmethod
	def show():
		print('Cat 调用 Animal 的静态方法 show')
		super(Cat, Cat).show()


	@classmethod
	def eat(cls, something):
		print('Cat 调用 Animal 的类方法 eat')
		super().eat(something)


	def run(self):
		print('Cat 调用 Animal 的实例方法 run')
		# 相当于 super(Cat, self).run()
		super().run()


class Dog(Animal):
	def run(self):
		print('Dog 奔跑起来了！')


class BigDog(Dog):
	def run(self):
		print('BigDog 调用 Animal 的 run 方法')
		super(Dog, self).run()


Cat.show()
Cat.eat('小鱼干')
Cat().run()
dog = BigDog()
dog.run()
# 调用 Dog 中的 run 方法
super(BigDog, dog).run()

Cat 调用 Animal 的静态方法 show
这里是 Animal！
Cat 调用 Animal 的类方法 eat
Animal 吃点 小鱼干
Cat 调用 Animal 的实例方法 run
Animal 奔跑起来了！
BigDog 调用 Animal 的 run 方法
Animal 奔跑起来了！
Dog 奔跑起来了！

# 一个表示商店的类
class Store:
	def __getitem__(self, key):
		print(f'想获得物品？{key}')
		return key


# 一个表示应用商店的类
class AppStore(Store):
	pass


store = AppStore()
# 可以对实例使用 [] 运算符
x = store['x']
# 对 super 需要使用 . 运算符
y = super(AppStore, store).__getitem__('y')
# ERROR 对 super 使用 [] 运算符，将导致异常
z = super(AppStore, store)['z']

想获得物品？x
想获得物品？y
…
TypeError: 'super' object is not subscriptable

源码

src/zh/classes·codebeatme/python·GitHub