学习python课程第二十三天

Posted lvyipin1

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了学习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































































































































































































































































以上是关于学习python课程第二十三天的主要内容,如果未能解决你的问题,请参考以下文章

Python 学习第二十三天 django 知识

学习python的第二十三天(re模块)

2019课程设计 第二十三天

No_16_0324 Java基础学习第二十三天

python第二十三天-----作业中

Python 基础第二十三天(反射)