Python 学习笔记（十五）Python类拓展（一）继承

继承

继承（Inheritance）：是面向对象软件技术当中的一个概念。如果一个类别A "继承自" 另一个类B,就把这个A称为“B的子类”，而把B称为“A的父类”，也可以称“B是A的超类”。

　　　　　　　　　　重用代码

　　　　　　　　　　属性和方法的继承

单继承和super函数

示例1：子类调用父类update_web(),执行父类update_web()

#! /usr/bin/env python
# coding:utf-8

class Person(object): #新式类

    def __init__(self,web_site): #初始化方法
        self.web =web_site

    def update_web(self,site):
        self.web =site
        return self.web


class Cc(Person): #继承了Person类，子类继承了一个父类，叫单继承

      def about_me(self,name,site): #继承关系，调用父类update_web方法
          my_web =self.update_web(site)
          return {"name":name,"web":my_web}

   
    

if __name__ =="__main__":
    my =Cc("www.weibo.com")
    print my.about_me("cc","cc.blog.com")
    print my.web


#output
#{'web': 'cc.blog.com', 'name': 'cc'}
#cc.blog.com

示例2：子类重写父类update_web()方法，在子类中调用，执行子类的update_web()方法

#! /usr/bin/env python
# coding:utf-8

class Person(object): #新式类

    def __init__(self,web_site): #初始化方法
        self.web =web_site

    def update_web(self,site):
        self.web =site
        return self.web


class Cc(Person): #继承了Person类，子类继承了一个父类，叫单继承

    def update_web(self,site,lang="python"):#此处重写了父类的方法，或者是覆盖了父类的方法
         self.web =site
         self.lang =lang
         return self.web,self.lang

   
    def about_me(self,name,site): #继承关系，此处调用子类的方法
       my_web,my_lang=self.update_web(site)
       return {"name":name,"web":my_web,"lang":my_lang}
    

if __name__ =="__main__":
    my =Cc("www.weibo.com")
    print my.about_me("cc","cc.blog.com")
    
#output
#{'lang': 'python', 'web': 'cc.blog.com', 'name': 'cc'}

示例3：调用父类中被覆盖的方法，使用super()函数，或者父类.方法名

#! /usr/bin/env python
# coding:utf-8

class Person(object): #新式类

    def __init__(self,web_site): #初始化方法
        self.web =web_site

    def update_web(self,site):
        self.web =site
        return self.web


class Cc(Person): #继承了Person类，子类继承了一个父类，叫单继承

    def __init__(self,teacher,web_site):
        self.teacher =teacher
        #Person.__init__(self,web_site) #调用父类的init方法
        super(Cc,self).__init__(web_site) #调用父类中被覆盖的方法
        
    

    def update_web(self,site,lang="python"):#此处重写了父类的方法，或者是覆盖了父类的方法
         self.web =site
         self.lang =lang
         return self.web,self.lang

    def your_teacher(self):
        return self.teacher

   
    def about_me(self,name,site): #继承关系，此处调用子类的方法
       my_web,my_lang=self.update_web(site)
       return {"name":name,"web":my_web,"lang":my_lang}
    

if __name__ =="__main__":
    my =Cc("cclaoshi","cnblog.com")
    print my.your_teacher()
    print my.teacher
    print my.web

#output
#cclaoshi
#cclaoshi
#cnblog.com

 多重继承

示例：

#! /usr/bin/env python
# coding:utf-8

class Person(object): #新式类
    def eye(self):
        print "two eyes"

    def breast(self,n):
        print "The breast is:",n


class Girl(object):
    def __init__(self,age):
        self.age =age

    def color(self):
        print "The girl is white."


class BeaGirl(Person,Girl):#多继承，写入两个类的名字,将父类的所有方法继承过来
    pass




if __name__ =="__main__":
    kong = BeaGirl(28)
    kong.eye()
    kong.breast(90)
    kong.color()
    print kong.age


#output
#two eyes
#The breast is: 90
#The girl is white.
#28

示例：多重继承的执行顺序，广度优先

#! /usr/bin/env python
# coding:utf-8

class K1(object): #新式类
    def foo(self):
        print "K1-foo"



class K2(object):
    def foo(self):
        print "K2-foo"

    def bar(self):
        print "K2-bar"


class J1(K1,K2):#多继承，写入两个类的名字,将父类的所有方法继承过来
    pass


class J2(K1,K2):
    def bar(self):
        print "J2-bar"

class C(J1,J2):
    pass




if __name__ =="__main__":
    print C.__mro__
    m =C()
    m.foo()
    m.bar()

#这种继承顺序称为广度优先
#output
#(<class '__main__.C'>, <class '__main__.J1'>, <class '__main__.J2'>,
#  <class '__main__.K1'>, <class '__main__.K2'>, <type 'object'>)
#K1-foo
#J2-bar