组合

什么是组合

对象的某个属性是另一个类的对象

为什么使用组合

可以减少代码冗余

class Person:
    school = 'oldboy'
class Teacher(Person):
    def __init__(self,name,age,level,course):
        self.name=name
        self.age=age
        self.level=level
        #course是课程对象,表示老师教授的课程
        self.course=course

class Student(Person):
    # course=[]  #错误
    def __init__(self,name,age):
        self.name=name
        self.age=age
        # course是课程对象,表示学生选的课程
        self.course_list = []
    def choose_course(self,course):
        # self.course=[]  #错误
        #把课程对象追加到学生选课的列表中
        self.course_list.append(course)

    def tell_all_course(self):
        #循环学生选课列表,每次拿出一个课程对象
        for course in self.course_list:
            #课程对象.name  取到课程名字
            print(course.name)

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



course=Course('Python',20199,7)
stu1=Student('nick',19)
stu1.choose_course(course)
stu2=Student('王二丫',19)
stu2.choose_course(course)
stu2.choose_course(Course('linux',19999,5))

组合可以理解成多个人去造一个机器人，有的人造头、有的人造脚、有的人造手、有的人造躯干，大家都完工后，造躯干的人把头、脚、手拼接到自己的躯干上，因此一个机器人便造出来了

多态和多态性

多态

什么是多态?

一类事物的多种形态

比如:动物类:猪,狗,人

多态性

多态性是指在不考虑实例类型的情况下使用实例

好处

1.增加了程序的灵活性

2.增加了程序额可扩展性

多态性

什么是多态性

指在不考虑实例类型的情况下使用实例

约束代码

第一种方式:用abc实现接口统一化,约束代码(用的比较少)

import abc
#第一在括号中写metaclass=abc.ABCMeta
class Animal(metaclass=abc.ABCMeta):
    #第二在要约束的方法上,写abc.abstractmethod装饰器
    @abc.abstractmethod
    def speak(self):
        pass

第二种方式,用异常处理来实现(常用)

class Animal():
    def speak(self):
        #主动抛出异常
        raise Exception('你得给我重写它啊')

崇尚鸭子类型:只要走路像鸭子(对象中有某个绑定方法),那你就是鸭子

封装

封装是什么意思？

从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八，一起装进麻袋，然后把麻袋封上口子

隐藏

把东西包装进去之后，隐藏起来，外部访问不到

如何用代码实现隐藏

隐藏属性/隐藏方法隐藏之后，外部访问不到，只有内部能够访问
隐藏属性：通过 __变量名来隐藏
隐藏方法：通过 __方法名来隐藏

python 实际上是可以访问隐藏属性的

class Person:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    def get_name(self):
        # print(self.__name)
        return '[----%s-----]'%self.__name

p=Person('nick',89)
print(p._Person__name)

print(p.__dict__)
#通过变形隐藏了属性

隐藏方法

隔离复杂度

什么时候属性变形

只要再类内部，以__变量名命名的变量，都会被隐藏，会发生的变形，在外部放入的 __变量名属性是不隐藏的

#计算人的bmi指数
#property装饰器：把方法包装成数据属性
class Person:
    def __init__(self,name,height,weight):
        self.name=name
        self.height=height
        self.weight=weight
    @property
    def bmi(self):
        return self.weight/(self.height**2)

    
#property之setter和deleter:可以将包装后的数据进行更改

class Person:
    def __init__(self,name,height,weight):
        self.__name=name
        self.__height=height
        self.__weight=weight
    @property
    def name(self):
        return '[我的名字是：%s]'%self.__name
    #用property装饰的方法名.setter
    @name.setter
    def name(self,new_name):
        # if not isinstance(new_name,str):
        if type(new_name) is not str:
            raise Exception('改不了')
        if new_name.startswith('sb'):
            raise Exception('不能以sb开头')
        self.__name=new_name

    # 用property装饰的方法名.deleter
    @name.deleter
    def name(self):
        # raise Exception('不能删')
        print('删除成功')
        # del self.__name
    p=Person('lqz',1.82,70)
print(p.name)
p.name='pppp'
p.name='xxx'
#改不了，直接抛一异常
p.name=999
p.name='sb_nick'

print(p.name)

del p.name
print(p.name)

Python之浅谈多态和封装

组合