学习python课程第二十三天

 一.    组合 :

　　1. 什么是组合 ?

　　　　一个对象的属性是来自于另外一个类的对象, 称之为组合. (跟继承其实很相似.都是共用一个类里面的属性)

　　2. 为何用组合 ?

　　　　组合也是用来解决类与类代码冗余的问题.

　　3. 如何用组合 ?

　　

class Foo:
    aaa=1111
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def func1(self):
        print('Foo内的功能')


class Bar:
    bbb=2222
    def __init__(self, m, n):
        self.m = m
        self.n = n

    def func2(self):
        print('Bar内的功能')

obj1=Foo(10,20)
obj2=Bar(30,40)

obj1.xxx=obj2  (把两个类组合到了一起.)


print(obj1.x,obj1.y,obj1.aaa,obj1.func1)
print(obj1.xxx.m,obj1.xxx.n,obj1.xxx.bbb,obj1.xxx.func2)


　　

　　小练习 :

class OldboyPeople:
    school = 'Oldboy'
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

class OldboyStudent(OldboyPeople):
    def choose_course(self):
        print('%s is choosing course' %self.name)

class OldboyTeacher(OldboyPeople):
    def __init__(self, name, age, gender,level,salary):
        OldboyPeople.__init__(self, name, age, gender)
        self.level=level
        self.salary=salary

    def score(self,stu,num):
        stu.num=num
        print('老师%s给学生%s打分%s' %(self.name,stu.name,num))

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

    def tell_course(self):
        print('课程名:<%s> 价钱:[%s] 周期:[%s]' % (self.course_name, self.course_price, self.course_period))

python_obj=Course('python开发',3000,'5mons')
linux_obj=Course('linux运维',5000,'3mons')



stu1=OldboyStudent('egon',18,'male')
stu1.courses=[]
stu1.courses.append(linux_obj)
stu1.courses.append(python_obj)
stu1.courses[0].tell_course()


stu2=OldboyStudent('kevin',38,'male')





　　二. 封装 :
　　1. 什么是封装 ?
　　　　装,指的是把属性装进一个容器,
　　　　封,指的是隐藏的意思,但是这种隐藏是对外不对内的.


　　2. 为何要封装 ?
　　　　封装不是单纯意义的隐藏,
　　　　
　　　　封装数据属性的目的 : 将数据属性封装起来, 类外部的使用就无法直接操作该数据属性了.
　　　　需要类内部开一个接口给使用者,类的设计者可以在接口之上附加任意逻辑,从而严格控制使用者对属性的操作.

　　　　封装函数属性的目的 :隔离复杂度.


　　3. 如何封装 ?
　　　　只需要在属性前加上__开头,该属性就会被隐藏起来,该隐藏具备的特点 : 

　　　　1. 只是一种语法意义上的变形, 即__开头的属性会在检测语法时发生变形为 _类名__属性名的形式

　　　　2. 这种隐藏式对外不对内的, 因为在类内部检测语法时, 所有的代码统一都发生了变形.
　　
　　　　3. 这种变形只在检测语法时发生一次, 在类定义之后新增的__开头的属性并不会发生变形.

　　　　4. 如果父类不想让子类覆盖自己的属性, 可以在属性前加__开头

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



　　示例:
　　　　1. 封装数据 : 将数据隐藏起来并不是目的. 隐藏起来然后对外提供该数据的接口, 然后我们可以在接口附加上对该数据操作的
　　　　　　限制, 以此完成对数据属性操作的严格控制.

　　　　

　　　　class Teacher:
    　　　　def __init__(self,name,age):
        　　　　# self.__name=name
        　　　　# self.__age=age
        　　　　self.set_info(name,age)

    　　　　def tell_info(self):
        　　　　print('姓名:%s,年龄:%s' %(self.__name,self.__age))
    　　　　def set_info(self,name,age):
        　　　　if not isinstance(name,str):
            　　　　raise TypeError('姓名必须是字符串类型')
        　　　　if not isinstance(age,int):
            　　　　raise TypeError('年龄必须是整型')
        　　　　self.__name=name
        　　　　self.__age=age


　　　　t=Teacher('egon',18)
　　　　t.tell_info()

　　　　t.set_info('egon',19)
　　　　t.tell_info()

　　　　2. 封装函数 : 目的是隔离复杂度.
　　　　
　　　　提示 :在编程语言里, 对外提供的接口 (接口可理为一个入口), 可以是函数, 称为接口函数, 这与接口的概念还不一样,
　　　　接口代表一组接口函数的集合体.

　　　　
　　　　

　　　　#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
　　　　#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
　　　　#隔离了复杂度,同时也提升了安全性

　　　　class ATM:
    　　　　def __card(self):
        　　　　print('插卡')
    　　　　def __auth(self):
        　　　　print('用户认证')
    　　　　def __input(self):
        　　　　print('输入取款金额')
    　　　　def __print_bill(self):
        　　　　print('打印账单')
    　　　　def __take_money(self):
        　　　　print('取款')

    　　　　def withdraw(self):
        　　　　self.__card()
        　　　　self.__auth()
        　　　　self.__input()
        　　　　self.__print_bill()
        　　　　self.__take_money()

　　　　a=ATM()
　　　　a.withdraw()

　　封装与扩展性:

　　　　封装在于明确区分内外, 使得类实现者可以修改封装内的东西,而不是影响外部调用者的代码.  而外部使用者只知道一个接口
　　　　(函数), 只要接口(函数)名,参数不变,使用者的代码永远无需改变, 这就提供一个良好的合作基础, 或者说,只要这个基础约定
　　　　不变,则代码改变不足为虑




　　三.  特性(property)装饰器:

　　　　什么是特性property
　　　　　　property是一种特殊的属性,访问它时会执行一段功能(函数) 然后返回值



　　　　为什么要用property :
　　　　　　将一个类的函数定义后,对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的,
　　　　　　这种特性的使用方式遵循了统一访问的原则


　　　　property 下面还有装饰器. @setter.(可以修改属性)    @deleter.(可以删除属性)


　　　　示例 :
　　　　　　

　　　　　　BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性,更

　　　　　　便于理解)

　　　　成人的BMI数值：

　　　　过轻：低于18.5

　　　　正常：18.5-23.9

　　　　过重：24-27

　　　　肥胖：28-32

　　　　非常肥胖, 高于32

　　　　　　体质指数（BMI）=体重（kg）÷身高^2（m）

　　　　class People:
    　　　　def __init__(self,name,weight,height):
    　　　　    self.name=name
        　　　　self.weight=weight
       　　　　 self.height=height
    　　　　@property
  　　　　  def bmi(self):
      　　　　  return self.weight / (self.height**2)

　　　　p1=People('egon',75,1.85)
　　　　print(p1.bmi)

　　property 的两种使用方法.

　　

　　　　class People:
    　　　　def __init__(self,name):
        　　　　self.__name=name

   　　　　 @property
   　　　　 def name(self):
      　　　　  return '<name:%s>' %self.__name

   　　　　 @name.setter
   　　　　 def name(self,new_name):
     　　　　   if type(new_name) is not str:
  　　　　          print('名字必须是str类型')
    　　　　        return
  　　　　      self.__name=new_name

 　　　　   @name.deleter
 　　　　   def name(self):
　　　　        del self.__name
　　　　
　　　　obj=People('egon')
　　　　print(obj.name)

　　　　del obj.name
　　　　print(obj.__dict__)

　　　　class People:
　　　　    def __init__(self,name):
　　　　        self.__name=name

　　　　    def xxx_name(self):
　　　　        return '<name:%s>' %self.__name

　　　　    def yyy_name(self,new_name):
　　　　        if type(new_name) is not str:
　　　　            print('名字必须是str类型')
　　　　            return
　　　　        self.__name=new_name

　　　　    def zzz_name(self):
　　　　        del self.__name

　　　　    name=property(xxx_name,yyy_name,zzz_name)

　　　　obj=People('egon')
　　　　print(obj.name)

　　　　del obj.name
　　　　print(obj.__dict_

　　四. 多态性.

　　　　多态性分为静态多态性与动态多态性.

　　　　　　静态多态性 :如任何类型都可以用运算符进行运算.

　　　　　　动态多态性 : 如下
　　　　

　　　　　　　　peo=People()
　　　　　　　　dog=Dog()
　　　　　　　　pig=Pig()

　　　　　　　　#peo、dog、pig都是动物,只要是动物肯定有talk方法
　　　　　　　　#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
　　　　　　　　peo.talk()
　　　　　　　　dog.talk()
　　　　　　　　pig.talk()

　　　　　　　　#更进一步,我们可以定义一个统一的接口来使用
　　　　　　　　def func(obj):
    　　　　　　　　obj.talk()

　　　　多态性的好处 :

　　　　　　1, 增加了程序的灵活性 :
　　　　　　　　　　以不变应万变,不论对象千变万化,使用者都是同一种形式去调用, 如func(animal)

　　　　　　2, 增加了程序的可扩展性
　　　　　　　　　　通过集成animal类创建了一个新的类, 使用者无需更改自己的代码. 还是用func(animal)去调用


　　　　示例:
　　　　　　

　　　　　　class Cat(Animal): #属于动物的另外一种形态：猫
　　　　　　　　def talk(self):
　　　　　　　　　　print('say miao')
　　　　　　
　　　　　　def func(animal): #对于使用者来说，自己的代码根本无需改动
　　　　　　　　animal.talk()
　　　　　　
　　　　　　cat1=Cat() #实例出一只猫
　　　　　　func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
　　　　　　say miao


　　　　　　这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。
　　　　　　使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)

　　鸭子类型 :
　　
　　　　　　Python崇尚鸭子类型,即如果看起来像,叫声像而且走起路来像鸭子, name它就是鸭子,
　　　　　　python程序员通常根据这种行为来编写程序, 例如,如果想编写现有对象的自定义版本,可以继承该对象也可以
　　　　　　创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度.


　　　　　　示例一 :
　　　　　　　　　　利用标准库中定义的各种'与文件类似'的对象, 尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法.


　　　　　　　　　　　　　

　　　　　　　　#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
　　　　　　　　class TxtFile:
    　　　　　　　　def read(self):
        　　　　　　　　pass

    　　　　　　　　def write(self):
       　　　　　　　　 pass

　　　　　　　　class DiskFile:
　　　　　　　　    def read(self):
　　　　　　        pass
　　　　　　    def write(self):
　　　　　　        pass



　　　　　　示例二. :
　　　　　　　　　　其实大家一直在享受着多态性带来的好处,比如Python的序列类型有多种形态:字符串,列表,元组. 多态性体现如下

　　　　　　　　#str,list,tuple都是序列类型
　　　　　　　　s=str('hello')
　　　　　　　　l=list([1,2,3])
　　　　　　　　t=tuple((4,5,6))

　　　　　　　　#我们可以在不考虑三者类型的前提下使用s,l,t
　　　　　　　　s.__len__()
　　　　　　　　l.__len__()
　　　　　　　　t.__len__()

　　　　　　　　len(s)
　　　　　　　　len(l)
　　　　　　　　len(t