面向对象三大特征——封装，继承

把隐藏属性(私有属性)的书写方式与一般属性一致，达到语法规范化
@property 这个内置装饰器，在方法上面装就自动加入到property(fset=xxx)函数里面

class People:
    def __init__(self, name, age,height, face):
        self.name = name
        self.age = age
        self.height = height
        self.__face = face
    # # 我们要统一一个属性调用规范，注意我们的方法名要一致
    @property
    def face(self):
        return self.__face
    # 后面的装饰要用到@property装饰的方法名.setter或者.delter
    @face.setter
    def face(self, face):
        self.__face = face
    
    @face.deleter
    def face(self):
        del self.__face
    # 
    # def getFace(self):
    #     return self.__face
    # 
    # face = property(fget=getFace)
ziliang = People("梓良", 18, 180, "帅")
print(ziliang.face)
ziliang.face = "丑"
print(ziliang.face)
del ziliang.face
print(ziliang.__dict__)

段子：
猫儿子：爸，我为啥和你长的不一样。
猫爸爸：没有猫是一模一样的
猫儿子：王叔叔天天量我升高，天天给好吃，这又是为什么呢
猫爸爸：......，我去隔壁问问
其实和生物学是一样的道理，继承也是的道理，子类既可以继承父类的所有属性和方法（除了隐藏属性），但是属性和方法也可以重写，也可以改变的。单继承就是单亲家庭。父类自我繁殖了子类
子类copy父类的代码的意思，但是子类可以基因突变，也可以自我重构方法和数学，变成和父类不一样的子类
拓展
记住python创建的所有类都有一个祖宗：object基类
在python3都是自动基础基类的，可以省略不写

一个子类继承一个父类
隐藏属性，隐藏方法时不能继承

class GrandFather:
    def __init__(self):
        self.money = 100000000
        # 私房钱
        self.__privateMoney = 100000
    def house(self):
        print(f"北京四合院一套")
    def setInfo(self):
        print(f"爷爷的遗产：{self.money}")
    def __setPribateMoney(self):
        return self.__privateMoney
    def func(self):
        return self.__setPribateMoney()
class Father(GrandFather):
    def __init__(self):
        # super就是初始化父类Grandfather,从而拿到父类的属性值
        # 超级 -》 父类也叫超类，也就用这个super来初始化得到父类的属性值
        super(Father, self).__init__()
        self.__privateMoney = 10000
class Son(Father):
    def __init__(self):
        super(Son, self).__init__()
        self.__privateMoney = -2000
    def setInfo(self):
        # 因为父类没有你的对象地址
        Father.setInfo(self)
    def setHouse(self):
        GrandFather.house(self)
son1 = Son()
son1.setInfo()
son1.house()
print(son1.func())

class Father:
    def __init__(self, money, house):
        self.money = money
        self.house = house
        self.__privateMoney = 100000
        
    def gethouse(self):
        print(f"{self.house}")
        
    def setInfo(self):
        print(f"父类的工资：{self.__privateMoney}")
        
class Son(Father):
    def __init__(self, money, house, privateMoney, name):
        super(Son, self).__init__(money, house)
        self.__privateMoney = privateMoney
        self.name = name
    # 重写就是借用父类的方法名或者属性名，设置不一样的代码
    def gethouse(self):
        print(f"子类的工资为{self.__privateMoney}")
father = Father("10000000", "北京四合院")
son = Son("1000000", "200平方米的小房子", "10000", "Lady 丹青")
father.gethouse()
print(father.money, father.house)
son.gethouse()
print(son.money, son.house, son.name)

多层继承就是还有爷爷类
就是超过2层继承就是多层继承

class GrandFather:
    def __init__(self):
        self.money = 100000000
        # 私房钱
        self.__privateMoney = 100000
    def house(self):
        print(f"北京四合院一套")
    def setInfo(self):
        print(f"爷爷的遗产：{self.money}")
    def __setPribateMoney(self):
        return self.__privateMoney
    def func(self):
        return self.__setPribateMoney()
class Father(GrandFather):
    def __init__(self):
        # super就是初始化父类Grandfather,从而拿到父类的属性值
        # 超级 -》 父类也叫超类，也就用这个super来初始化得到父类的属性值
        super(Father, self).__init__()
        self.__privateMoney = 10000
class Son(Father):
    def __init__(self):
        super(Son, self).__init__()
        self.__privateMoney = -2000
    def setInfo(self):
        # 因为父类没有你的对象地址
        Father.setInfo(self)
    def setHouse(self):
        GrandFather.house(self)
son1 = Son()
son1.setInfo()
son1.house()
print(son1.func())

就是一个儿子有很多个老爸
吕布

# 多继承
class DingYuan:
    def __init__(self):
        self.fatherName = "丁原义父"  # 1
    def setOffices(self):
        print("升官主簿")
class Dongzhuo:
    def __init__(self):
        self.fatherName = "董卓义父"  # 2
    def setOffice(self):
        print("送赤兔马")
class WangYun:
    def __init__(self):
        self.fatherName = "王允义父"  # 3
    def setOffice(self):
        print("送貂蝉")
class LvBu(WangYun, Dongzhuo, DingYuan):
    def __init__(self):
        super(LvBu, self).__init__()
    def setOffices(self):
        WangYun.setOffice(self)
        Dongzhuo.setOffice(self)
        DingYuan.setOffices(self)
lvbu = LvBu()
lvbu.setOffices()
# 同一个属性名遵守就近原则
print(lvbu.fatherName)
# 只看父类属性
print(LvBu.__bases__)
# mro 就是看继承顺序
print(LvBu.__mro__)
print(Dongzhuo.__mro__)