Python基础之类的继承

Python基础之类的继承

面向对象的特征是封装、继承、多态。
封装便是将代码封装在类内部，实现代码规范及代码重用
多态指同一个方法，不同对象在调用时执行的结果不同
而继承则是三者中最重要的一部分，一种语言不支持继承，类就没有什么意义

---

##1.继承的语法
继承的语法格式
class 子类(父类)
定义一个子类，继承自某一个指定的父类。子类在继承父类时，会将父类所有的特征和行为全部继承

# 人类
class Person:
    def __init__(self,**kw):
        self.__name = kw['name']
        self.__sex = kw['sex']
        self.__age = kw['age']
        self.__height = kw['height']
        self.__weight = kw['weight']

    @property
    def name(self):
        return self.__name

    @property
    def age(self):
        return self.__age

    @property
    def sex(self):
        return self.__sex

    @property
    def height(self):
        return self.__height

    @property
    def weight(self):
        return self.__weight

    def introduce(self):
        print("我叫%s，今年%d岁，性别%s，身高%d，体重%.1fkg" % (self.__name, self.__age, self.__sex, self.__height, self.__weight))
    def talk(self):
        print("我们当前正在交谈")
        
# 学生类
class Student(Person):
    def __init__(self, **kw):
        Person.__init__(self, **kw)
        self.__sno = kw['sno']
        self.__classroom = kw['classroom']
        self.__major = kw['major']
        self.__school = kw['school']

# 创建学生对象
stu = Student(name="WXQ", age=23, sex="男", height=173, weight=65, sno="150906102", classroom="挖掘机一班", major="挖掘机", school="蓝翔")
stu.introduce()
# 我叫WXQ，今年23岁，性别男，身高173，体重65.0kg

子类从父类继承过来的所有行为主要有三种：
（1）照搬：直接通过子类对象调用从父类继承的方法
（2）重写（方法重载）：重新定义从父类继承的方法的实现，此过程可以实现面向对象的多态操作。多态：同一个方法，不同对象在调用时执行的结果不同，此过程称为多态
（3）添加：从父类继承的方法在调用时先通过父类调用该方法，之后再添加子类的具体操作

# 人类
class Person:
    def __init__(self,**kw):
        self.__name = kw['name']
        self.__sex = kw['sex']
        self.__age = kw['age']
        self.__height = kw['height']
        self.__weight = kw['weight']

    @property
    def name(self):
        return self.__name

    @property
    def age(self):
        return self.__age

    @property
    def sex(self):
        return self.__sex

    @property
    def height(self):
        return self.__height

    @property
    def weight(self):
        return self.__weight

    def introduce(self):
        print("我叫%s，今年%d岁，性别%s，身高%d，体重%.1fkg" % (self.__name, self.__age, self.__sex, self.__height, self.__weight))
    def talk(self):
        print("我们当前正在交谈")
# 学生类
class Student(Person):
    def __init__(self, **kw):
        Person.__init__(self, **kw)
        self.__sno = kw['sno']
        self.__classroom = kw['classroom']
        self.__major = kw['major']
        self.__school = kw['school']

    # 重写
    def introduce(self):
        print("我叫%s，今年%d岁，性别%s，身高%d，体重%.1fkg，就读于%s %s专业 %s，学号%s" % (self.name, self.age, self.sex, self.height, self.weight, self.__school, self.__major, self.__classroom, self.__sno))

    # # 添加（在原函数基础上重新添加一部分新功能）
    # def introduce(self):
    #     Person.introduce(self)
    #     print("就读于%s %s专业 %s，学号%s" % (self.__school, self.__major, self.__classroom,  self.__sno))


# 创建学生对象
stu = Student(name="WXQ", age=23, sex="男", height=173, weight=65, sno="150906102", classroom="挖掘机一班", major="挖掘机", school="蓝翔")
stu.introduce()
# 我叫WXQ，今年23岁，性别男，身高173，体重65.0kg  照搬结果
# 我叫WXQ，今年23岁，性别男，身高173，体重65.0kg，就读于蓝翔 挖掘机专业 挖掘机一班，学号150906102  重写结果
# 我叫WXQ，今年23岁，性别男，身高173，体重65.0kg
# 就读于蓝翔 挖掘机专业 挖掘机一班，学号150906102 添加结果

---

##2.多继承
多继承:子类可以同时拥有多个父类的现象称为多继承

多继承的优点：子类可以通过多继承的操作，获得比较丰富的属性和功能，同时多继承可以将父类中的代码进行分解，方便进行代码的维护

# 类如果继承object类称为新式类，没有继承object类称为经典类，开发中一般使用经典类
class Tool(object):
    def __init__(self, **kwargs):
        self.__name = kwargs['name']
        self.__weight = kwargs['weight']
        self.__speed = kwargs['speed']

    @property
    def name(self):
        return self.__name

class Ship(Tool):
    def __init__(self, **kwargs):
        # Tool.__init__(self, **kwargs)
        super().__init__(**kwargs)
        self.__waterP = kwargs['waterP']
        self.__waterE = kwargs['waterE']

    def float_move(self):
        print("轮船%s正在水上航行" % self.name)

    def move_wz(self):
        print("%s当前正在执行转移物资任务" % self.name)

class Plane(Tool):
    def __init__(self, **kwargs):
        # Tool.__init__(self, **kwargs)
        super().__init__(**kwargs)
        self.__flyH = kwargs['flyH']
        self.__company = kwargs['company']

    def fly_move(self):
        print("飞机%s正在执行飞行任务" % self.name)

class WaterPlane(Ship, Plane):
    def __init__(self, **kwargs):
        super(Plane, self).__init__(**kwargs)
        # Ship.__init__(self, **kwargs)
        # Plane.__init__(self, **kwargs)
        self.__power = kwargs['power']

# 创建水上飞机对象
wp = WaterPlane(name="蜡笔大新", weight="150吨", speed="60km/h", waterP="100000吨", waterE="10m", flyH="50m", company="大力神", power="5000kw")
wp.fly_move()
wp.float_move()
wp.move_wz()
# 飞机蜡笔大新正在执行飞行任务
# 轮船蜡笔大新正在水上航行
# 蜡笔大新当前正在执行转移物资任务

super():python内置的函数，主要应用于继承操作。
作用：获取当前所在类的对象；调用该对象，分别执行其父类的执行算法

super()在执行父级元素筛选时应遵循MRO算法（深度优先算法），在多继承中首先查找到该类最左边的父类，其次再查找该父类的父类，知道该父类的基类。接着再查找下一个父类，查找原则同上，直到找到所有父类。注意如果查找过程中有多个类型重复，则以最后查到的为准

---

##3. 枚举类
枚举类：定义一个类继承自Enum类，此时定义的类即为枚举类
枚举类可以版主开发人员定义对应的常量，为每一个常量设置一个易于理解的名字，方便开发人员识别
@unique用来装饰枚举类，避免枚举类中出现值的重复

from enum import Enum, unique

@unique
class Week(Enum):
    Sunday = 7
    Monday = 1
    Tuesday = 2
    Wednesday = 3
    Thursday = 4
    Friday = 5
    Satusday = 6

def outPut(week):
    if week == Week.Sunday:
        print("周日")
    elif week == Week.Monday:
        print("周一")
    elif week == Week.Tuesday:
        print("周二")
    elif week == Week.Wednesday:
        print("周三")
    elif week == Week.Thursday:
        print("周四")
    elif week == Week.Friday:
        print("周五")
    elif week == Week.Satusday:
        print("周六")

outPut(Week.Satusday)
# 周六

---

##4.例题

#  定义一个分数类，分别完成分数的加减乘除
class Fra(object):
    def __init__(self, fz = 0, fm = 1):
        self.__fz = fz
        if fm == 0:
            raise ValueError("分数中分母不能为0")
        else:
            self.__fm = fm

    @property
    def fm(self):
        return self.__fm
    @fm.setter
    def fm(self, fm):
        if isinstance(fm, int) and fm != 0:
            self.__fm = fm
        else:
            raise ValueError("分母值错误")
    @property
    def fz(self):
        return self.__fz
    @fz.setter
    def fz(self, fz):
        if isinstance(fz,int):
            self.__fz = fz
        else:
            raise ValueError("分子类型错误")
    # 将分子和分母转换成分数格式
    def changeFormat(self):
        minValue = min(self.__fm, self.__fz)
        maxValue = max(self.__fm, self.__fz)
        while maxValue % minValue != 0:
            temp = maxValue % minValue
            maxValue = minValue
            minValue = temp
        self.__fz //= minValue
        self.__fm //= minValue
        if self.__fm == 1:
            str = "{fz}".format(fz=self.__fz)
        else:
            str = "{fz}/{fm}".format(fz=self.__fz, fm=self.__fm)
        return str

# 定义一个计算类，专门进行分数的加减乘除
class Calculate(object):

    def adjust(self, fc1, fc2, sign="+"):
        sign = sign.strip(" ")
        if sign == '+':
            fz = fc1.fz * fc2.fm + fc2.fz * fc1.fm
        elif sign == '-':
            fz = fc1.fz * fc2.fm - fc2.fz * fc1.fm
        elif sign == '*':
            fz = fc1.fz * fc2.fz
        elif sign == '/':
            fz = fc1.fz * fc2.fm
        else:
            raise ValueError("暂不支持")

        if sign == "/":
            fm = fc1.fm * fc2.fz
        else:
            fm = fc1.fm * fc2.fm

        fc = Fra(fz, fm)
        return fc.changeFormat()


f1 = Fra(3, 10)
f2 = Fra(7, 15)
cl = Calculate()
print(cl.adjust(f1, f2, '*'))
# 7/50