类的继承和组合

目录

• 类的组合
• 抽象类
• super函数
• 封装
  • 属性的隐藏
  • 封装的意义
  • 神奇的property

• 类的继承: 什么是什么, 比如人是动物, 所以人就属于动物类

• 类的组合: 什么有什么, 比如老师有名字, 老师有年龄, 老师有课程, 所以名字, 年龄, 课程这些属性类就可以组合到老师类

类的组合

class Teacher:
    def __init__(self,name:str,age,sex,level:int,salary):
        self.name=name
        self.age=age
        self.sex=sex
        self.level=level
        self.salary=salary

class Course:
    def __init__(self,course_name,course_price,course_period):
        self.course_name=course_name
        self.course_price=course_price
        self.course_period=course_period

python=Course('python',1000,'1mons')

teacher1=Teacher('ross',18,'male',10,3000)
teacher2=Teacher('joey',28,'male',20,3000)

teacher1.course=python  #不需要改动Teacher类的代码就可以直接组合课程属性到对象teacher1
teacher2.course=python

print(teacher1.course.course_name)

抽象类

抽象类, 如下图, 每种动物都有行走的方法, 但是定义了不同的方法名字, 很不友好, 如果解决这个问题就可以使用抽象类

class People:
    def walk(self):
        print('people is walking')

class Pig:
    def run(self):
        print('pig is running')

peo1=People()
pig1=Pig()

peo1.walk()
pig1.run()

# people is walking
# pig is running

通过抽象类规范子类的方法, 抽象类只能被规范, 不能被实例化

引入模块`abc`, 下面的代码中父类Animal通过abc模块的abstractmethod的装饰器装饰了方法run和eat, 所以在子类People和Pig中必须要有被装饰的这两个方法run和eat, 如果子类中没有这两个方法, 则会报错如下

TypeError: Can't instantiate abstract class People with abstract methods eat, run

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def run(self):
        pass
    @abc.abstractmethod
    def eat(self):
        pass

class People(Animal):
    def run(self):
        print('people is walking')
    def eat(self):
        print('people is eating')

class Pig(Animal):
    def run(self):
        print('pig is running')

    def eat(self):
        print('pig is eating')

peo1=People()
pig1=Pig()

def func(obj):
    obj.run()

func(peo1)
func(pig1)

super函数

​ 通常情况下, 我们在子类中定义了和父类同样的方法名, 那么子类的方法就会覆盖父类的方法, 而super关键字实现了对父类方法的改写(增加了功能，增加的功能写在子类中，父类方法中原来的功能得以保留)。也可以说，super关键字帮助我们实现了在子类中调用父类的方法

class Animals(object):
    def __init__(self,name):
        self.name=name
    def greet(self):
        print('hello, I am %s' %self.name)

class Dog(Animals):
    def greet(self):
        super().greet()
        print('wangwang')

dog=Dog('dog')
dog.greet()

print(Animals.mro())

# 输出结果
# hello, I am dog
# wangwang
# [<class '__main__.Animals'>, <class 'object'>]

​ python对于每一个类都有一个mro列表, 可以通过mro()方法直接查看, 例如class.mro()

class BaseClass(object):
    def __init__(self):
        print('enter BaseClass')
        print('leave BaseClass')

class A(BaseClass):
    def __init__(self):
        print('enter A')
        super().__init__()
        print('leave A')

class B(BaseClass):
    def __init__(self):
        print('enter B')
        super().__init__()
        print('leave B')

class C(B,A):
    def __init__(self):
        print('enter C')
        super().__init__()
        print('leave C')

print(C.mro())
# 输出结果
# [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.BaseClass'>, <class 'object'>]

c=C()
# 输出结果
# enter C
# enter B
# enter A
# enter BaseClass
# leave BaseClass
# leave A
# leave B
# leave C

如果不使用super函数

class BaseClass(object):
    def __init__(self):
        print('enter BaseClass')
        print('leave BaseClass')

class A(BaseClass):
    def __init__(self):
        print('enter A')
        # super().__init__()
        BaseClass().__init__()
        print('leave A')

class B(BaseClass):
    def __init__(self):
        print('enter B')
        # super().__init__()
        BaseClass().__init__()
        print('leave B')

class C(B,A):
    def __init__(self):
        print('enter C')
        # super().__init__()
        B().__init__()
        A().__init__()
        print('leave C')

print(C.mro())

# 输出结果:
# [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.BaseClass'>, <class 'object'>]

c=C()
# 输出结果:
enter C
enter B
enter BaseClass
leave BaseClass
enter BaseClass
leave BaseClass
leave B
enter B
enter BaseClass
leave BaseClass
enter BaseClass
leave BaseClass
leave B
enter A
enter BaseClass
leave BaseClass
enter BaseClass
leave BaseClass
leave A
enter A
enter BaseClass
leave BaseClass
enter BaseClass
leave BaseClass
leave A
leave C

封装

属性的隐藏

在需要隐藏的属性前加上双下划线__

class A:
    __x=1                      # 外部调用时会变形为_A__x
    def __init__(self,name):
        self.__name=name       # 外部调用时会变形为_A__name
    def __foo(self):           # 外部调用时会变形为_A__foo
        print('run foo')       

这种变形的特点:

• 在类外部无法直接调用obj.__AttrName
• 在类内部可以直接调用obj.__AttrName
• 子类无法覆盖父类__开头的属性

这种变形需要注意的问题是:

• 这种机制也并没有真正意义上限制我们从外部直接访问属性, 知道了类名和属性名就可以拼出名字

• 变形过程只在类的定义时发生一次, 在定义后的赋值操作, 不会变形

  

• 在继承中, 父类如果不想让子类覆盖自己的方法, 可以将方法定义为私有的

下列代码子类的属性会覆盖同名的父类属性

class A:
    def foo(self):
        print('A.foo')
    def bar(self):  
        print('A.bar')
        self.foo()

class B(A):
    def foo(self):
        print('B.foo')
b=B()
b.bar()

# 输出结果
# A.bar   因为class B中没有bar这个方法, 所以会去父类当中找, 所以输出了A.bar
# B.foo   由于bar这个方法中有self.foo, 而B类中有这个方法, 所以就是输出B.foo, 子类的方法是可以覆盖父类的方法的

如果就是想要使用父类的方法, 而不是子类的方法, 这时候就会用到隐藏属性了

class A:
    def __foo(self): #_A__foo
        print('A.foo')
    def bar(self):   #_A__bar
        print('A.bar')
        self.__foo() #_A__foo

class B(A):
    def __foo(self): #_B__foo
        print('B.foo')
b=B()
b.bar()

# 输出结果
# A.bar
# A.foo

封装的意义

封装数据属性, 明确的区分内外, 控制外部对隐藏的属性的操作行为

class People:
    def __init__(self,name,age):     #隐藏name和age属性, 通过tell_info和set_info两个接口调用或者修改这两个属性,
        self.__name=name             #避免外部直接操作这两个属性
        self.__age=age

    def tell_info(self):
        print('Name:<%s> Age:<%s>' %(self.__name,self.__age))

    def set_info(self,name,age):
        if not isinstance(name,str):
            print('名字必须是字符串')
            return
        if not isinstance(age,int):
            print('名字必须是数字类型')
            return
        self.__name=name
        self.__age=age

p=People('ross',12)
p.tell_info()
p.set_info('van',18)
p.tell_info()

class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('认证')
    def __input(self):
        print('输入取款金额')
    def __print(self):
        print('打印账单')
    def __take(self):
        print('取款')
    def with_draw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print()
        self.__take()

a=ATM()
a.with_draw()  #对于外部调用来说, 只有with_draw一个接口, 隔离复杂度

神奇的property

​ property装饰器就是把方法变成属性调用的, 调用方法的时候不需要加括号

​ @property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作, 可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2015 - self._birth

stu=Student()
stu.birth=1999
print(stu.age)

上面的birth是可读写属性，而age就是一个只读属性，因为age可以根据birth和当前时间计算出来。

class Screen:
    @property
    def width(self):
        pass
    @width.setter
    def width(self,width):
        if not isinstance(width,int):
            print('wrong value type')
            return 2
        self.__width=width
    @width.getter
    def width(self):
        print(self.__width)
    @width.deleter
    def width(self):
        print('你们不要再打啦')
        
    @property
    def height(self):
        pass
    @height.setter
    def height(self,height):
        if not isinstance(height,int):
            print('wrong value type')
            return 2
        self.__height=height
    @property
    def resolution(self):
        return self.__width*self.__height

s = Screen()
s.width = 1024
s.height = 768
s.width
print('resolution =', s.resolution)