1. <output id="hzk7v"><pre id="hzk7v"><address id="hzk7v"></address></pre></output>
      <output id="hzk7v"></output>
    2. <nav id="hzk7v"><i id="hzk7v"><em id="hzk7v"></em></i></nav>
    3. <listing id="hzk7v"><delect id="hzk7v"><em id="hzk7v"></em></delect></listing>

      Python面向对象程序设计类的封装与继承用法示例

       更新时间2019年04月12日 11:34:00   作者微信1257309054   我要评论

      这篇文章主要介绍了Python面向对象程序设计类的封装与继承用法,结合实例形式分析了Python面向对象程序设计中类的封装继承相关概念原理用法及操作注意事项,需要的朋友可以参考下

      本文实例讲述了Python面向对象程序设计类的封装与继承用法分享给大家供大家参考具体如下

      访问限制封装

      1概念

      面向对象语言的三大特征:封装, 继承, 多态

      广义的封装: 类和函数的定义本身就是封装的体现

      狭义的封装:一个类的?#25215;?#23646;性,不希望外界直接访问,而是把这个属?#36816;接?#21270;[只有当前类持有],然后暴露给外界一个访问的方法

      封装的本质:就是属?#36816;接?#21270;的过程

      封装的好处:提供了数据的复用性,保证了数据的安全性

      举例:插排

      2使用

      class Person(object):
       def __init__(self, name, age, height, weight, money):
        self.name = name
        self.__age__ = age
        self.weight = weight
        self.__money = money
        self.__height = height
       def run(self):
        print(self.__money)
       def eat(self):
        print("eat")
       # 通过内部方法,去修改获取?#25509;?#23646;性
       # 通过?#36828;?#20041;的方法实现对?#25509;?#23646;性的?#25345;?#19982;取值
       # set方法:setxxx
       def setMoney(self, money):
        # 数据的过滤
        if money < 0:
         money = 0
        self.__money = money
       # get方法:getXXX
       def getMoney(self):
        return self.__money
      per = Person("hanmeimei", 20, 170, 55, 10000)
      # 1.属性被?#25509;?#21270;之后的访问
      # 如果要让内部属性不被外部直接访问,在属性前加两个下划线(__),
      # 在python中如果在属性前面加两个下划线,name这个属性就变成了?#25509;?#23646;性[private]
      # ?#25509;?#23646;性的含义:在外界不能像以前那么直接访问
      # print(per.__money) #无法在外界直接访问
      per.run() # 内部可以访问
      # 2.解决办法: 如何对?#25509;?#23646;性取值和?#25345;?
      # 属性被?#25509;?#21270;之后,可以通过get/set的方法进行访问
      per.setMoney(10)
      print(per.getMoney())
      # 3.工作原理
      # 不能直接访问per.__money是因为python解释器把__money变成了_Person__money
      # 仍然可以使用_Person__money去访问,但是强烈不建议这么干,不同的解释器可能存在解释的变量名不一致的问题
      per._Person__money = 1
      print(per.getMoney())
      # 4.特殊情况
      # 在Python中 __xxx__ 属于特殊变量,将不再属于?#25509;?#21464;量,可以直接访问
      print(per.__age__)
      # 在python中 __xxx变量,这样的实例变量外部是可以访问的,但是,按照?#32423;?#30340;规则
      # 当我?#24378;?#21040;这样的变量时,意思虽然是"虽然我可以被访问,但是请把我视为?#25509;?#21464;量,不要直接访问我"
      print(per._Person__height)
      
      

      输出

      10000
      10
      1
      20
      170

      继承

      1概念

      如果两个或者两个以上的类具有相同的属性和方法,我们可以抽取一个类出来,

      在抽取的类中声明公共的部分

      ​ 被抽取出来的类 父类 超类 基类
      ​ 其他类 子类 派生类
      ​ 他们之间的关系 子类继承自父类

      2单继承

      简单来说,一个子类只有一个父类,被称为单继承

      演示:test.py 文件

      注意:在使用继承时,尽量一个类存在于一个模块中

      from person import Person
      from student import Student
      from worker import Worker
      per = Person("aa", 1, 2)
      stu = Student("tom", 18, 12345, 110)
      print(stu.name, stu.age)
      stu.run()
      print(stu.stuId)
      #?#25509;?#23646;性
      #print(stu.__money)
      print(stu.getMoney())#通过继承过来的共有方法访问?#25509;?#23646;性
      #stu.stuFunc()
      wor = Worker("lilei", 20, 111)
      print(wor.name, wor.age)
      wor.eat("apple")
      #子类对象调用父类同名的函数,则优先调用子类中的函数
      #本质是子类中的方法覆盖了父类中同名的函数
      wor.run()
      print(per.getMoney())
      #父类对象不能访?#39318;?#31867;特有的属性或方法
      #print(per.stuId)
      
      

      输出

      tom 18
      run
      110
      12345
      lilei 20
      eat apple
      子类中的run方法被调用了
      2

      person.py文件

      #以前的写法 class Person(object):
      #但是实质上,如果没有显示的写出父类,则这个类的父类默认为object
      #object是所有类的父类或者超类
      class Person(object):
       #构造方法
       def __init__(self, name, age, money):
        self.name = name
        self.age = age
        self.__money = money
        #get/set方法
       def setMoney(self, money):
        self.__money = money
       def getMoney(self):
        return self.__money
       def run(self):
        print("run")
       def eat(self, food):
        print("eat", food)
      
      
      #student.py文件
      from person import Person
      class Student(Person):
       def __init__(self, name, age, money, stuId):
        #调用父类中的构造方法
        #方法1 super(当前类,self).__init__(参数列表)
        #super(Student,self).__init__(name, age, money, stuId)
        #方法2 父类名.__init__(属性列表)
        Person.__init__(self, name, age, money)
        #子类可以有一些自己独有的属性
        self.stuId = stuId
       def setFunc(self):
        print(self.__money)
      
      
      #worker.py文件
      from person import Person
      class Worker(Person):
       def __init__(self, name, age, money):
        super(Worker,self).__init__(name, age, money)
       # 在子类中定义和一个父类中重名的函数
       def run(self):
        print("子类中的run方法被调用了")
      
      

      总结:

      继承的特点:

      a. 子类对象可以直接访问父类?#24418;此接?#30340;对象
      b. 子类对象可以调用父类中的方法
      c. 父类对象不能访?#39318;?#31867;中特有的属性或者方法

      优缺点:

      优点:

      1.可以简化代码,减少冗余
      2.提高代码的维护性
      3.提高了代码的安全性

      缺点:

      耦合和内聚被用来描述类与类之间的关系,耦合性越低,内聚性越高,说明代码越好
      但是,在继承关系中,耦合性相对比较高,如果修改父类,子类?#19981;?#38543;着变化

      3多继承

      顾名?#23478;?就是一个子类中可以有多个父类,比如一个孩子有一个爸爸一个妈妈

      from child import Child
      def main():
       c = Child(300, 100,"xiaoming")
       print(c.money, c.faceValue)
       c.play()
       c.eat()
       #注意:如果多个父类中的方法名相同,默?#31995;?#29992;的是子类括号中排前面的父类中的方法
       #此时调用的是Father中func方法
      if __name__ == "__main__":
       main()
      
      

      输出

      300 100
      play
      eat

      #father.py文件
      class Father(object):
       def __init__(self, money):
        self.money = money
       def play(self):
        print("play")
       def func(self):
        print("Father")
      
      
      #mother.py文件
      class Mother(object):
       def __init__(self, faceValue):
        self.faceValue = faceValue
       def eat(self):
        print("eat")
       def func(self):
        print("Mother")
      
      
      #child.py文件
      from father import Father
      from mother import Mother
      class Child(Father, Mother):
       def __init__(self, money, faceValue,name):
        #注意:分别调用各个父类中的构造方法
        Father.__init__(self, money)
        Mother.__init__(self, faceValue)
        #子类中同样可以有自己独有的特性
        self.name = name
      
      

      总结:

      子类可以从多个父类中继承属性和方法
      一个父类可以有多个子类
      一个子类可以有多个父类

      4函数重写

      4.1系统函数

      '''
      重写:将函数重写一遍
      __str__():在调用print打印对象时自动调用,是给用户用的,是一个描述对象的方法.
      __repr__():是给机器用的,在python解释器里面直接敲对象名在回车后调用方法
      注意:在没有str,且有repr时,str=repr
      '''
      class Animal(object):
       def __init__(self, name, age, height, weight):
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight
       def __str__(self):
        return "%s-%d-%d-%d"%(self.name, self.age, self.height, self.weight)
      ani = Animal("大黄", 5, 60, 25)
      #print(per.name, per.age, per.height, per.weight)
      #在打印ani时自动调用str函数
      print(ani)
      #优点或者使用时机:当一个对象的属性值很多,并且都需要打印,重写__str__方法后,简化了代码,方便查看.
      
      

      输出

      大黄-5-60-25

      5?#36828;?#20041;函数

      重写函数的时机:?#22791;?#31867;中函数的功能满足不了子类的需求时,就可以进行重?#30784;?br /> 演示:

      from smallAnimal import SmallAnimal
      from cat import Cat
      c = Cat()
      c.func()
      
      
      #smallAnimal.py文件
      class SmallAnimal(object):
       def func(self):
        print("wwww")
      
      
      #cat.py文件
      from smallAniml import SmallAnimal
      class Cat(SmallAnimal):
       def func(self):
        print("呵呵呵")
      
      

      更多关于Python相关内容?#34892;?#36259;的读者可查看本站专题Python面向对象程序设计入门与进阶教程Python数据结构与算法教程Python函数使用技巧总结Python字符串操作技巧汇总Python编码操作技巧总结Python入门与进阶经典教程

      希望本文所述对大家Python程序设计有所帮助

      相关文章

      • 对python捕获ctrl+c手工中断程序的两种方法详解

        对python捕获ctrl+c手工中断程序的两种方法详解

        今天小编就为大家分享一篇对python捕获ctrl+c手工中断程序的两种方法详解具有很好的参考价值希望对大家有所帮助一起跟随小编过来看看吧
        2018-12-12
      • python TKinter获取文本框内容的方法

        python TKinter获取文本框内容的方法

        今天小编就为大家分享一篇python TKinter获取文本框内容的方法具有很好的参考价值希望对大家有所帮助一起跟随小编过来看看吧
        2018-10-10
      • 深入了解Python数据类型之列表

        深入了解Python数据类型之列表

        下面小编就为大家带来一篇深入了解Python数据类型之列表小编觉得挺不错的现在就分享给大家也给大家做个参考一起跟随小编过来看看吧
        2016-06-06
      • wxPython实现窗口用?#35745;?#20570;背景

        wxPython实现窗口用?#35745;?#20570;背景

        这篇文章主要为大家详细介绍了wxPython实现窗口用?#35745;?#20570;背景具有一定的参考价值?#34892;?#36259;的小伙伴们可以参?#23478;?#19979;
        2018-04-04
      • Python完全新手教程

        Python完全新手教程

        Python完全新手教程...
        2007-02-02
      • python3去掉string中的标点符号方法

        python3去掉string中的标点符号方法

        今天小编就为大家分享一篇python3去掉string中的标点符号方法具有很好的参考价值希望对大家有所帮助一起跟随小编过来看看吧
        2019-01-01
      • Python常见工厂函数用法示例

        Python常见工厂函数用法示例

        这篇文章主要介绍了Python常见工厂函数用法,简单描述了工厂函数的功能定义并结合具体实例形式分析了Python常见工厂函数的相关使用技巧,需要的朋友可以参考下
        2018-03-03
      • 用Python的Django框架完成视频处理任务的教程

        用Python的Django框架完成视频处理任务的教程

        这篇文章主要介绍了用Python的Django框架完成视频处理任务的教程,包括用户的视频上传和播放以及下载功能的实现,需要的朋友可以参考下
        2015-04-04
      • ?#31243;PYTHON 关于文件的操作

        ?#31243;PYTHON 关于文件的操作

        这篇文章主要介绍了PYTHON 关于文件的操作文中通过示例代码介绍的非常详细对大家的学习或者工作具有一定的参考学习价值需要的朋友们下面随着小编来一起学?#25226;?#20064;吧
        2019-03-03
      • python 图像平移和旋转的实例

        python 图像平移和旋转的实例

        今天小编就为大家分享一篇python 图像平移和旋转的实例具有很好的参考价值希望对大家有所帮助一起跟随小编过来看看吧
        2019-01-01

      最新评论

      3dԻв

        1. <output id="hzk7v"><pre id="hzk7v"><address id="hzk7v"></address></pre></output>
          <output id="hzk7v"></output>
        2. <nav id="hzk7v"><i id="hzk7v"><em id="hzk7v"></em></i></nav>
        3. <listing id="hzk7v"><delect id="hzk7v"><em id="hzk7v"></em></delect></listing>

            1. <output id="hzk7v"><pre id="hzk7v"><address id="hzk7v"></address></pre></output>
              <output id="hzk7v"></output>
            2. <nav id="hzk7v"><i id="hzk7v"><em id="hzk7v"></em></i></nav>
            3. <listing id="hzk7v"><delect id="hzk7v"><em id="hzk7v"></em></delect></listing>