zoukankan      html  css  js  c++  java
  • Python(十九)

    一 继承与派生

    1.1 什么是继承

    继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类

    python中类的继承分为:单继承和多继承

    复制代码
    class ParentClass1: #定义父类
        pass
    
    class ParentClass2: #定义父类
        pass
    
    class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
        pass
    
    class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
        pass
    复制代码

    查看继承

    >>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类,__bases__则是查看所有继承的父类
    (<class '__main__.ParentClass1'>,)
    >>> SubClass2.__bases__
    (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

    提示:如果没有指定基类,python的类会默认继承object类,object是所有python类的基类,它提供了一些常见方法(如__str__)的实现。

    >>> ParentClass1.__bases__
    (<class 'object'>,)
    >>> ParentClass2.__bases__
    (<class 'object'>,)
     

    1.2 继承与抽象(先抽象再继承)

    抽象即抽取类似或者说比较像的部分。

    抽象分成两个层次: 

    1.将奥巴马和梅西这俩对象比较像的部分抽取成类; 

    2.将人,猪,狗这三个类比较像的部分抽取成父类。

    抽象最主要的作用是划分类别(可以隔离关注点,降低复杂度)

     

    继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。

    抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类

    1.3 继承与重用性

     

     在开发程序的过程中,如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时

    我们不可能从头开始写一个类B,这就用到了类的继承的概念。

    通过继承的方式新建类B,让B继承A,B会‘遗传’A的所有属性(数据属性和函数属性),实现代码重用

    复制代码
    class Hero:
        def __init__(self,nickname,aggressivity,life_value):
            self.nickname=nickname
            self.aggressivity=aggressivity
            self.life_value=life_value
    
        def move_forward(self):
            print('%s move forward' %self.nickname)
    
        def move_backward(self):
            print('%s move backward' %self.nickname)
    
        def move_left(self):
            print('%s move forward' %self.nickname)
    
        def move_right(self):
            print('%s move forward' %self.nickname)
    
        def attack(self,enemy):
            enemy.life_value-=self.aggressivity
    class Garen(Hero):
        pass
    
    class Riven(Hero):
        pass
    
    g1=Garen('草丛伦',100,300)
    r1=Riven('锐雯雯',57,200)
    
    print(g1.life_value)
    r1.attack(g1)
    print(g1.life_value)
    
    '''
    运行结果
    300
    243
    '''
    复制代码

    提示:用已经有的类建立一个新的类,这样就重用了已经有的软件中的一部分设置大部分,大大生了编程工作量,这就是常说的软件重用,不仅可以重用自己的类,也可以继承别人的,比如标准库,来定制新的数据类型,这样就是大大缩短了软件开发周期,对大型软件开发来说,意义重大.

    注意:像g1.life_value之类的属性引用,会先从实例中找life_value然后去类中找,然后再去父类中找...直到最顶级的父类。

    当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性(不会影响到父类),需要注意的是,一旦重新定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准了。

    class Riven(Hero):
        camp='Noxus'
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)

    在子类中,新建的重名的函数属性,在编辑函数内功能的时候,有可能需要重用父类中重名的那个函数功能,应该是用调用普通函数的方式,即:类名.func(),此时就与调用普通函数无异了,因此即便是self参数也要为其传值

    复制代码
    class Riven(Hero):
        camp='Noxus'
        def __init__(self,nickname,aggressivity,life_value,skin):
            Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
            self.skin=skin #新属性
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            Hero.attack(self,enemy) #调用功能
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)
    
    r1=Riven('锐雯雯',57,200,'比基尼')
    r1.fly()
    print(r1.skin)
    
    '''
    运行结果
    锐雯雯 is flying
    比基尼
    
    '''
    复制代码
     

    1.4 组合与重用性

    软件重用的重要方式除了继承之外还有另外一种方式,即:组合

    组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合

    其实早在3.5小节中我们就体会了组合的用法,比如一个英雄有一个装备

    复制代码
    >>> class Equip: #武器装备类
    ...     def fire(self):
    ...         print('release Fire skill')
    ... 
    >>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
    ...     camp='Noxus'
    ...     def __init__(self,nickname):
    ...         self.nickname=nickname
    ...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
    ... 
    >>> r1=Riven('锐雯雯')
    >>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
    release Fire skill
    复制代码

      

    组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同,

    1.继承的方式

    通过继承建立了派生类与基类之间的关系,它是一种'是'的关系,比如白马是马,人是动物。

    当类之间有很多相同的功能,提取这些共同的功能做成基类,用继承比较好,比如教授是老师

    复制代码
    >>> class Teacher:
    ...     def __init__(self,name,gender):
    ...         self.name=name
    ...         self.gender=gender
    ...     def teach(self):
    ...         print('teaching')
    ... 
    >>> 
    >>> class Professor(Teacher):
    ...     pass
    ... 
    >>> p1=Professor('egon','male')
    >>> p1.teach()
    teaching
    复制代码

    2.组合的方式

    用组合的方式建立了类与组合的类之间的关系,它是一种‘有’的关系,比如教授有生日,教授教python课程

    复制代码
    class BirthDate:
        def __init__(self,year,month,day):
            self.year=year
            self.month=month
            self.day=day
    
    class Couse:
        def __init__(self,name,price,period):
            self.name=name
            self.price=price
            self.period=period
    
    class Teacher:
        def __init__(self,name,gender):
            self.name=name
            self.gender=gender
        def teach(self):
            print('teaching')
    class Professor(Teacher):
        def __init__(self,name,gender,birth,course):
            Teacher.__init__(self,name,gender)
            self.birth=birth
            self.course=course
    
    p1=Professor('egon','male',
                 BirthDate('1995','1','27'),
                 Couse('python','28000','4 months'))
    
    print(p1.birth.year,p1.birth.month,p1.birth.day)
    print(p1.course.name,p1.course.price,p1.course.period)
    '''
    运行结果:
    1995 1 27
    python 28000 4 months
    '''
    复制代码

    当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好

    1.5 接口与归一化设计

    1.什么是接口

    =================第一部分:Java 语言中的接口很好的展现了接口的含义: IAnimal.java
    /*
    * Java的Interface很好的体现了我们前面分析的接口的特征:
    * 1)是一组功能的集合,而不是一个功能
    * 2)接口的功能用于交互,所有的功能都是public,即别的对象可操作
    * 3)接口只定义函数,但不涉及函数实现
    * 4)这些功能是相关的,都是动物相关的功能,但光合作用就不适宜放到IAnimal里面了 */
    
    package com.oo.demo;
    public interface IAnimal {
        public void eat();
        public void run(); 
        public void sleep(); 
        public void speak();
    }
    
    =================第二部分:Pig.java:猪”的类设计,实现了IAnnimal接口 
    package com.oo.demo;
    public class Pig implements IAnimal{ //如下每个函数都需要详细实现
        public void eat(){
            System.out.println("Pig like to eat grass");
        }
    
        public void run(){
            System.out.println("Pig run: front legs, back legs");
        }
    
        public void sleep(){
            System.out.println("Pig sleep 16 hours every day");
        }
    
        public void speak(){
            System.out.println("Pig can not speak"); }
    }
    
    =================第三部分:Person2.java
    /*
    *实现了IAnimal的“人”,有几点说明一下: 
    * 1)同样都实现了IAnimal的接口,但“人”和“猪”的实现不一样,为了避免太多代码导致影响阅读,这里的代码简化成一行,但输出的内容不一样,实际项目中同一接口的同一功能点,不同的类实现完全不一样
    * 2)这里同样是“人”这个类,但和前面介绍类时给的类“Person”完全不一样,这是因为同样的逻辑概念,在不同的应用场景下,具备的属性和功能是完全不一样的 */
    
    package com.oo.demo;
    public class Person2 implements IAnimal { 
        public void eat(){
            System.out.println("Person like to eat meat");
        }
    
        public void run(){
            System.out.println("Person run: left leg, right leg");
        }
    
        public void sleep(){
            System.out.println("Person sleep 8 hours every dat"); 
        }
    
        public void speak(){
            System.out.println("Hellow world, I am a person");
        } 
    }
    
    =================第四部分:Tester03.java
    package com.oo.demo;
    
    public class Tester03 {
        public static void main(String[] args) {
            System.out.println("===This is a person==="); 
            IAnimal person = new Person2();
            person.eat();
            person.run();
            person.sleep();
            person.speak();
            
            System.out.println("
    ===This is a pig===");
            IAnimal pig = new Pig();
            pig.eat();
            pig.run();
            pig.sleep();
            pig.speak();
        } 
    }
    java中的interface

    继承有两种用途:

    一:继承基类的方法,并且做出自己的改变或者扩展(代码重用)

    二:声明某个子类兼容于某基类,定义一个接口类Interface,接口类中定义了一些接口名(就是函数名)且并未实现接口的功能,子类继承接口类,并且实现接口中的功能

    复制代码
    class Interface:#定义接口Interface类来模仿接口的概念,python中压根就没有interface关键字来定义一个接口。
        def read(self): #定接口函数read
            pass
    
        def write(self): #定义接口函数write
            pass
    
    
    class Txt(Interface): #文本,具体实现read和write
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的读取方法')
    
    class Sata(Interface): #磁盘,具体实现read和write
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的读取方法')
    
    class Process(Interface):
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的读取方法')
    复制代码

    实践中,继承的第一种含义意义并不很大,甚至常常是有害的。因为它使得子类与基类出现强耦合。

    继承的第二种含义非常重要。它又叫“接口继承”。
    接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。

    归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样,所有东西都可以当文件处理,不必关心它是内存、磁盘、网络还是屏幕(当然,对底层设计者,当然也可以区分出“字符设备”和“块设备”,然后做出针对性的设计:细致到什么程度,视需求而定)。

    在python中根本就没有一个叫做interface的关键字,上面的代码只是看起来像接口,其实并没有起到接口的作用,子类完全可以不用去实现接口 ,如果非要去模仿接口的概念,可以借助第三方模块:

    http://pypi.python.org/pypi/zope.interface

    twisted的twistedinternetinterface.py里使用zope.interface

    文档https://zopeinterface.readthedocs.io/en/latest/

    设计模式:https://github.com/faif/python-patterns

    2. 为何要用接口

    接口提取了一群类共同的函数,可以把接口当做一个函数的集合。

    然后让子类去实现接口中的函数。

    这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,那么所有的这些类产生的对象在使用时,从用法上来说都一样。

    归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,这极大地降低了使用者的使用难度。

    比如:我们定义一个动物接口,接口里定义了有跑、吃、呼吸等接口函数,这样老鼠的类去实现了该接口,松鼠的类也去实现了该接口,由二者分别产生一只老鼠和一只松鼠送到你面前,即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸。

    再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,奥迪汽车的类,大众汽车的类,他们都实现了汽车接口,这样就好办了,大家只需要学会了怎么开汽车,那么无论是本田,还是奥迪,还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样

    1.6 抽象类

    1 什么是抽象类

        与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

    2 为什么要有抽象类

        如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类是从一堆中抽取相同的内容而来的,内容包括数据属性和函数属性。

      比如我们有香蕉的类,有苹果的类,有桃子的类,从这些类抽取相同的内容就是水果这个抽象的类,你吃水果时,要么是吃一个具体的香蕉,要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

        从设计角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的。

      从实现角度来看,抽象类与普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的,即将揭晓答案

    3. 在python中实现抽象类

    复制代码
    #_*_coding:utf-8_*_
    __author__ = 'Linhaifeng'
    #一切皆文件
    import abc #利用abc模块实现抽象类
    
    class All_file(metaclass=abc.ABCMeta):
        all_type='file'
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def read(self):
            '子类必须定义读功能'
            pass
    
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def write(self):
            '子类必须定义写功能'
            pass
    
    # class Txt(All_file):
    #     pass
    #
    # t1=Txt() #报错,子类没有定义抽象方法
    
    class Txt(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的读取方法')
    
    class Sata(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的读取方法')
    
    class Process(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的读取方法')
    
    wenbenwenjian=Txt()
    
    yingpanwenjian=Sata()
    
    jinchengwenjian=Process()
    
    #这样大家都是被归一化了,也就是一切皆文件的思想
    wenbenwenjian.read()
    yingpanwenjian.write()
    jinchengwenjian.read()
    
    print(wenbenwenjian.all_type)
    print(yingpanwenjian.all_type)
    print(jinchengwenjian.all_type)
    复制代码

    4. 抽象类与接口

    抽象类的本质还是类,指的是一组类的相似性,包括数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。

    抽象类是一个介于类和接口直接的一个概念,同时具备类和接口的部分特性,可以用来实现归一化设计 

  • 相关阅读:
    56. Merge Intervals
    Arpa’s letter-marked tree and Mehrdad’s Dokhtar-kosh paths CodeForces
    CodeForces 1328E-Tree Queries【LCA】
    2^x mod n = 1 HDU
    CodeForces 1327D
    CodeFoeces 1327E
    AtCoder Beginner Contest 159 E
    牛客14648-序列【莫比乌斯反演+容斥定理】
    完全平方数 HYSBZ
    MongoDB学习笔记(六、MongoDB复制集与分片)
  • 原文地址:https://www.cnblogs.com/guozhenle/p/7110741.html
Copyright © 2011-2022 走看看