Python教程

python面向对象之二(类的继承、类的多态)

本文主要是介绍python面向对象之二(类的继承、类的多态),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

一、类的继承

(一)、父类与子类

父类:被继承的类,子类继承父类后,会继承父类里面所有的属性(数据属性&实例属性)以及方法

子类:继承其他的类,子类继承父类后,能够继承父类里面所有的方法以及属性,当然也可以调用

实例

class Persion(object):
    city='xian'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def show(self):
        print('my name is {name},and my age is {age}'.format(
            name=self.name,age=self.age))

class Student(Persion):
    def __init__(self,name,age,score):
        #子类继承父类的实例属性
        Persion.__init__(self,name,age)                
        self.score=score

    def info(self):
        print('my name is {name},and my age is {age},and my score is {score},'
              'and my city is {city}'.format(
            name=self.name,age=self.age,score=self.score,city=self.city))
        print('子类调用父类的方法输出结果:\n')
        self.show()

stu=Student('wuya',18,90)
stu.info()
print(stu.city)       

   

(二)、原则

继承的N个原则:
1、子类可以继承N个父类,但是建议不要超过两个,最多两个
2、山下原则》》》如果子类没有重写父类的方法,那么使用的是上下原则
  A、如果子类没重写父类的方法,调用父类的方法,输出的结果是父类里面方法的输出结果
  B、如果子类重写了父类里面的方法,那么调用该重写的方法,输出的结果是子类里面方法的输出结果
3、从左到右原则:一个子类继承多个父类,那么调用方法后,从左到右按线性的方式(找到满足的不找了)寻找
方法重写:子类重写了父类里面的方法。重写的目的是父类的方法没有办法满足子类的需求,那么就会重写

上下原则:

①、方法重写的
class Persion(object):
    city='xian'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def show(self):
        print('my name is {name},and my age is {age}'.format(
            name=self.name,age=self.age))                       

class Student(Persion):
    def __init__(self,name,age,score):
        Persion.__init__(self,name,age)                         

self.score=score

    def info(self):
        print('my name is {name},and my age is {age},and my score is {score},'
              'and my city is {city}'.format(
            name=self.name,age=self.age,score=self.score,city=self.city))
    def show(self):
        print('我是子类的show method')              
stu=Student('wuya',18,90)
stu.info()
stu.show()                                        

 

②、方法未重写的

class Persion(object):
    city='xian'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def show(self):
        print('my name is {name},and my age is {age}'.format(
            name=self.name,age=self.age))                       

class Student(Persion):
    def __init__(self,name,age,score):
        Persion.__init__(self,name,age)                         

self.score=score

    def info(self):
        print('my name is {name},and my age is {age},and my score is {score},'
              'and my city is {city}'.format(
            name=self.name,age=self.age,score=self.score,city=self.city))          
stu=Student('wuya',18,90)
stu.info()
stu.show()  

 

从左到右原则:

class A(object):
    def show(self):
        print('this is A')

class B(object):
    def show(self):
        print('this is B')

class C(A,B):
    pass                  

c=C()                      
c.show()                  

 

(三)、继承中常见的错误日志

class A(object):
    def show(self):
        print('this is A')

class B(A):
    def show(self):
        print('this is B')

class C(A,B):
    pass

c=C()
c.show()

 

(四)、继承的原理

所以在Python中,基于MRO的解析顺序规则,就会从左到右开始查找基类,如果找到第⼀个匹配的属性类,就会停⽌查找,如果没有,那就继续查找,直到查找到符合要求的为⽌。MRO其实就是通过⼀个C3线性化算法来实现
的,它的核⼼思想为:
1、⼦类会优先于⽗类检查
2、多个⽗类会根据它们在列表中的顺序被依次检查
3、如果对下⼀个类存在两个合法的选择,只能选择第⼀个

class A(object):
    def show(self):
        print('this is A')

class B(object):
    def show(self):
        print('this is B')

class C(A,B):
    pass

c=C()
print(C.mro())
c.show()

 

(五)、java与python继承的区别

Java是单继承的,而python是多继承的,当然不建议超过两个

(六)、python2余python3的查找区别

把Python2的类叫经典类,Python3的类叫新式类,其实在Python2中,多个类的继承算法叫深度优先,⽽Python3叫⼴度优先

演示python3的继承查找流程
class A(object):
    def show(self):
        print('A')

class B(A):
    def show(self):
        print('B')

class C(A):
    def show(self):
        print('C')

class D(B,C):
    pass

obj=D()
print(D.mro())

 

结果:python2中的结果是D,B,A,C,object   python3是D,B,C,A,object

二、类的多态

(一)、优势

1、增加了持续的灵活性

2、增加了持续的额外扩展的功能

(二)、一切皆对象
name='wuya'

def func():
    print('hello word')

class Person(object):
    def show(self):
        print('This Is A Class')

obj1=name
print(obj1)     

obj2=func
obj2()                

obj3=Person
obj3().show()       

 

(三)、鸭子类型

在Python⾥⾯,所谓鸭⼦类型就是指“如果看起来像,叫声像⽽且⾛路起来像鸭⼦,那么它就是鸭⼦”。

class Animal(object):
    def talk(self):
        print('动物会叫')

class Cat(Animal):
    def talk(self):
        print('猫也是会叫的')

class Dog(Animal):
    def talk(self):
        print('狗也是会叫的')

def func(animal):
    animal.talk()

cat=Cat()
func(animal=cat)
dog=Dog()
func(animal=dog)

 

这篇关于python面向对象之二(类的继承、类的多态)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!