python的类、继承和多态

1.类

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。而在类中定义的函数则成为方法。
下面是定义类。

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

输出的结果为：
MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

如果我们选择小汽车和客车为对象，使用类实现它们的属性和方
法（汽车的重量属性，驾驶的方法），并打印属性的话，则这样写

class car:       #定义一个车类
    method = ''  #定义驾驶方法
    height = 0   #定义车的重量
    def __init__(self, m, h):   #定义构造方法
        self.method = m         #定义车的驾驶方法属性
        self.height = h         #定义车的重量属性

    def stamp(self):            #定义打印方法
        print("驾驶方法: %s,车的重量: %d。" % (self.method, self.height))#打印出车的驾驶方法和车的重量
coach = car('客车司机', 1000)#定义客车驾驶方法为客车司机驾驶，客车重量为1000
car = car('汽车司机', 500)   #定义汽车驾驶方法为汽车司机驾驶，汽车重量为500
coach.stamp()    #打印客车信息
car.speak()      #打印汽车信息

最终的输出结果为：
驾驶方法: 客车司机,车的重量: 1000。
驾驶方法: 汽车司机,车的重量: 500。

2.继承

一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
比如，使用公交车继承客车的属性和方法，输入的名字为：“东风路28路公交车”，并打印（也包括属性和驾驶的方法）

class car:       #定义一个车类
    method = ''  #定义驾驶方法
    height = 0   #定义车的重量
    def __init__(self, m, h):   #定义构造方法
        self.method = m         #定义车的驾驶方法属性
        self.height = h         #定义车的重量属性

    def stamp(self):            #定义打印方法
        print("驾驶方法: %s,车的重量: %d。" % (self.method, self.height))#打印出车的驾驶方法和车的重量

class bus(car):#定义bus类继承父类car
    information = ''  # 定义车辆信息
    def __init__(self, m, h, i):#定义构造方法
        car.__init__(self, m, h)#调用父类的方法
        self.information = i    #定义车辆信息属性

    def stamp(self):    #重写父类的方法
        print("驾驶方法: %s,车的重量: %d,车辆信息：%s。" % (self.method, self.height, self.information))  # 打印出车的驾驶方法、车的重量、车辆信息
b = bus('公共汽车司机', 1000, '东风路28路公交车')#定义公交车驾驶方法为公交车司机驾驶，公交车重量为1000，公交车信息为东风路28路公交车

b.stamp()      #打印公交车信息

3.多态

面向对象的三大特征：封装，继承，多态
而多态的概念:(以封装和继承为前提)不同的子类调用相同的方法，产生不同的结果.
而使用多态，必须满足以下 2 个前提条件：
1.继承：多态一定是发生在子类和父类之间；
2.重写：子类重写了父类的方法。
比如：

class CLanguage:
    def say(self):
        print("赋值的是 CLanguage 类的实例对象")
class CPython:
    def say(self):
        print("赋值的是 CPython 类的实例对象")
a = CLanguage()
a.say()
a = CPython()
a.say()

这不是多态，因为a 被先后赋值为 CLanguage 类和 CPython 类的对象。
再看接下来这个代码：

class CLanguage:
    def say(self):
        print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
    def say(self):
        print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
    def say(self):
        print("调用的是 CLinux 类的say方法")
a = CLanguage()
a.say()
a = CPython()
a.say()
a = CLinux()
a.say()

可以看到，CPython 和 CLinux 都继承自 CLanguage 类，且各自都重写了父类的 say() 方法。从运行结果可以看出，同一变量 a 在执行同一个 say() 方法时，由于 a 实际表示不同的类实例对象，因此 a.say() 调用的并不是同一个类中的 say() 方法，这就是多态。

看下面代码，通过多态实现28路、906路、B32路公交车的驾驶方法并打印

class car:       #定义一个车类
    method = ''  #定义驾驶方法
    def __init__(self, m):   #定义构造方法
        self.method = m         #定义车的驾驶方法属性

    def stamp(self):            #定义打印方法
        print("28路公交车驾驶方法: %s。" % (self.method))#打印出车的驾驶方法

class car1(car):#定义car1类继承父类car
    def __init__(self, m):  # 定义构造方法
        self.method = m  # 定义车的驾驶方法属性

    def stamp(self):  # 定义打印方法
        print("906路公交车驾驶方法: %s。" % (self.method))  # 打印出车的驾驶方法

class car2(car):#定义car2类继承父类car
    def __init__(self, m):  # 定义构造方法
        self.method = m  # 定义车的驾驶方法属性

    def stamp(self):  # 定义打印方法
        print("B32路公交车驾驶方法: %s。" % (self.method))  # 打印出车的驾驶方法

a=car('手动驾驶')   #实例化对象a
a.stamp()         #打印a公交车信息
b=car1('自动挡驾驶')#实例化对象b
b.stamp()         #打印b公交车信息
c=car2('自动驾驶')  #实例化对象c
c.stamp()         #打印c公交车信息