一、组合

什么是组合？

就是一个类的属性 的类型 是另一个自定义类的 类型，也可以说是某一个对象拥有一个属性，该属性的值是另一个类的对象。

通过为某一个对象添加属性（这里的属性是另一个类的对象）的方式，间接将两个类关联整合，从而减少类与类之间的代码冗余

class A:    passclass B:    passb = B()b.a=A()

借用之前的代码进行改进：

class OldboyPeople:    school = 'Oldboy'    def __init__(self,name,age,sex):        self.name = name        self.age = age        self.sex = sexclass OldboyStudent(OldboyPeople):    def __init__(self,name,age,sex,score=0):        OldboyPeople.__init__(self,name,age,sex)        self.score = score        self.courses=[]    def choose(self):        print('%s choosing course' % self.name)    def tell_all_course(self):        print('学生[%s]选修的课程如下'%self.name)        for obj in self.courses:            obj.tell_info()class OldboyTeacher(OldboyPeople):    def __init__(self,name,age,sex,level):        OldboyPeople.__init__(self,name,age,sex)        self.level = level        self.courses = []    def score(self,stu,num):        stu.score = num    def tell_all_course(self):        print(('老师[%s]教授的课程如下'%self.name).center(50,'*'))        for obj in self.courses:            obj.tell_info()        print('*'*60)class Coures:    def __init__(self,c_name,c_price,c_period):        self.c_name = c_name        self.c_perice = c_price        self.c_period = c_period    def tell_info(self):        print('

二、多态

多态指的是同一种类或者事物的不同形态

　　多态性：在多态的背景下，可以在不用考虑对象具体类型的前提下直接使用对象

　　多态性的精髓：统一

人，狗，猪都是同属于动物的，他们都具有说和跑的特点，将共同的特点剥离出来组成父类

import abcclass Animal(metaclass=abc.ABCMeta):    @abc.abstractmethod    def speak(self):        pass    @abc.abstractmethod    def run(self):        pass# Animal() # 父类只是用来建立规范的,不能用来实例化的,更无需实现内部的方法class People(Animal):    def speak(self):        print('say hello')    def run(self):        passclass Dog(Animal):    def speak(self):        print('汪汪汪')    def run(self):        passclass Pig(Animal):    def speak(self):        print('哼哼哼')    def run(self):        passobj1=People()obj2=Dog()obj3=Pig()

这里涉及到了抽象类，我们导入了abc模块，abc.ABCMeta 是一个metaclass，用于在Python程序中创建抽象基类。

在相应的方法之前一行加上@abstractmethod之后，从新的一行开始定义相应的方法。实现的方法就是一个抽象的方法，子类继承之后，如果需要用到的这个方法则必须用新的方法将其实现

总结一句话就是，抽象类不能实例化，子类必须实现（抽象）父类的所有抽象方法

Python崇尚鸭子类型：“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的

class Disk:    def read(self):        print('Disk read')    def write(self):        print('Disk write')class Memory:    def read(self):        print('Mem read')    def write(self):        print('Mem write')class Cpu:    def read(self):        print('Cpu read')    def write(self):        print('Cpu write')obj1=Disk()obj2=Memory()obj3=Cpu()obj1.read()obj2.read()obj3.read()

三、封装

封：代表将存放于名称空间中的名字给藏起来，这种隐藏对外不对内

装：往容器/名称空间里存放名字

封装：将类的属性与方法私有化，形成对内可见对外不可见

如何封装？

　　在类内定义的属性前加_开头（没有_结尾）

class Foo:    # part1    # __num = 1000    # part2    # def __init__(self, name):    #     self.__name = name    # part3    def __test(self): # 变形成_Foo_test        print("test")# part1# foo = Foo()# print(foo.__num)# part2# foo = Foo("*****")# print(foo.__name)foo = Foo()foo._Foo__test()

想要访问被私有化的属性，需要在要访问的对象前面加_类名。方法名

注：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。

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

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

四、property

property装饰器是用来将类内的函数属性伪装成数据属性的，里面有getter，setter、（deleter）方法

class Car:    def __init__(self, name, type):        self.__name = name        self.__type = type    def __str__(self):        return ">> " + self.__name + "【" + self.__type + "】<<"    # __name对外不可见，但外界需要访问，所以通过方法对外界间接性提供__name    # 完成这类功能的方法称之为接口    @property # name() => name    def name(self):        # 可以做一系列安全操作        return self.__name    # @name.getter    # def name(self):    #     return self.__name    # @name.setter    # def set_name(self, name):    #    self.__name = name    @name.setter    def name(self, name):       self.__name = namecar = Car("宝马", "7系")# >> 宝马【7系】<

 

还要继续努力