面向对象之进阶继承

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生或子类

Python中类的继承分为：单继承和多继承

在python3中，所有类默认继承boject

但凡是继承了object类的子类，以及该子类的子类，都称为新式类（在python3中所有的类都是 新式类）

没有继承objeck类的子类称为经典类（在python2中，没有继承objeck的类，以及它的子类，都是经典类）

 

# 经典类：深度优先

# 新生类：广度优先

# 继承顺序：从左往右，至下而上

 

继承是一种什么‘是’什么的关系

解决代码重用的问题，减少代码冗余

class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def walk(self):
        print('%s is walking' %self.name)
class Teacher(People):
    pass
class Student(People):
    pass
t=Teacher('egon',18)
print(t.name,t.age)
print(t.__dict__)
t.walk()

派生就是有自己独特的特征与技能

class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex                  #父类
    def walk(self):
        print('%s is walking' % self.name)
    def foo(self):
        print('from father %s' %self.name)

class Teacher(People):
    school='oldboy'
    def __init__(self,name,age,sex,level,salary):
        People.__init__(self,name,age,sex)
        self.level=level
        self.salary=salary
    def teach(self):
        print('%s is teacher' %self.name)
    def foo(self):
        People.foo(self)                 #继承与派生
        print('form teacher')
class Student(People):
    def __init__(self,name,age,sex,group):
        People.__init__(self,name,age,sex)
        self.group=group
    def study(self):
        print('%s is studying' %self.name)
t=Teacher('egon',18,'male',10,3000)
t.foo()
t.teach()
print(t.level)

多态 python天生支持多态

# 抽象类和接口类 归一化设计
    # 编程思想:为子类做规范
    # 归一化设计：几个类都实现了相同的方法
    # 抽象类：最好单继承，且可以简单的实现功能
    # 接口类：可以多继承，且最好不实现具体功能
    # 实现接口类和抽象类的语法
    # from abc import abstractmethod,ABCMeta
    # class 父类(metaclass=ABCMeta):
    #     @abstractmethod
    #     def func(self):pass

私有属性：

# 所有带双下划线的都是私有属性，在外面调用需要变形
示列（1）
class Teacher:
    __identifier = 'Teacher'  # 私有静态属性
    def __init__(self,name,pwd):
        self.name=name
        self.__pwd=pwd    # 私有属性
        self.__p()

    def __p(self):    # 私有方法
        # print(self.__pwd)
        return hash(self.__pwd)

    def login(self,password):
        return hash(password) == self.__p()

# print(Teacher._Teacher__identifier)
alex = Teacher("alex",3714)
ret = alex.login(3714)
print(ret)
示例（2）

# 例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
# 成人的BMI数值：
# 过轻：低于18.5
# 正常：18.5-23.9
# 过重：24-27
# 肥胖：28-32
# 非常肥胖, 高于32
# 　　体质指数（BMI）=体重（kg）÷身高^2（m）
# 　　EX：70kg÷（1.75×1.75）=22.86
class Person:
    def __init__(self,name,height,weight):
        self.name = name
        self.__height = height
        self.__weight = weight

    def get_bmi(self):
        return self.__weight / (self.__height*self.__height)

    def change_weight(self,new_weight):
        if new_weight > 20:
            self.__weight = new_weight
        else:
            print('体重过轻')
jinghong = Person('景弘',1.81,94)
print(jinghong.get_bmi())
jinghong.change_weight(88)
print(jinghong.get_bmi())

私有方法

class Foo:
    def __jinghong_sb(self):     #_Foo__jinghong_sb
        print('Foo')
class Son(Foo):
    # def __jinghong_sb(self):
    #     print('Son')
    def func(self):
        self.__jinghong_sb()     #_Son__jinghong_sb
son = Son()
son.func()
#私有方法
#1.有一些方法的返回值只是用来作为中间结果
#2.父类的方法不希望子类继承

拾遗（可命名元组）

from collections import namedtuple
Point = namedtuple('point',['x','y'])
t1 = Point(1,2)
print(t1.x)
print(t1.y)
#没有方法并且属性不会发生变化的类
    #定义简单
    #不能改变

property方法

房屋 ：
  业主 长 宽
  面积

class Host:
    def __init__(self,owner,length,width):
        self.owner = owner
        self.__length = length
        self.__width = width

    @property
    def area(self):
        return self.__length*self.__width

alex = Host("kaka",3,2)
print(alex.owner,alex.area)