Python面向对象（二）之封装、继承、重写、MRO、多态

最新推荐文章于 2023-07-08 22:32:58 发布

Artoria____

最新推荐文章于 2023-07-08 22:32:58 发布

阅读量341

点赞数 4

分类专栏： Python

本文链接：https://blog.csdn.net/Artoria_QZH/article/details/90319579

版权

Python 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

面向对象编程有三大属性——封装、继承、多态

文章目录

一、封装

封装有两方面的含义：
1.将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度
2.在类对象的内部通过访问控制吧某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如getter和setter）以访问隐藏的信息。这样，就对隐藏的信息进行了保护

class Student(object):
    def __init__(self):
        self.__score = 90
    
    def get_score(self):
        return self.__score
    
    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError("成绩必须在0~100之间")

sd = Student()
sd.get_score()  #Out:90

sd = Student()
sd.set_score(88)
print(sd.get_score()) #Out: 88

sd.set_score(123)
print(sd.get_score())
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-8d836b44ffed> in <module>
----> 1 sd.set_score(123)
      2 print(sd.get_score())

<ipython-input-14-f4429ca851b6> in set_score(self, score)
     10             self.score = score
     11         else:
---> 12             raise ValueError("成绩必须在0~100之间")

ValueError: 成绩必须在0~100之间

二、继承

class Dog(object):
    def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")
    def swim(self):
        print("游泳")

class Bird(object):
    def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")
    def fly(self):
        print("飞翔")

可以看到，这两个类中都存在共同属性：eat、drink。因此，为简化代码，可以将这两个共同的属性抽象并提取到一个新的基类中，只需要在上述两个类中，都继承这个新的基类，就可以访问这个基类中的方法。

class Animal(object):
    def eat(self):
        print("吃饭")
    def drink(self):
        print("喝水")

class Dog(Animal):
    def swim(self):
        print("游泳")

class Bird(Animal):
    def fly(self):
        print("飞翔")

dog = Dog()
dog.eat()              #Out:吃饭
dog.drink()            #Out:喝水
dog.swim()             #Out:游泳

bird = Bird()
bird.eat()             #Out:吃饭
bird.drink()           #Out:喝水
bird.fly()             #Out:飞翔

继承一个叫单继承(有一个直接父类)
假设子类和父类分别为ChildClass和ParentClass,
子类继承父类的语法格式为：

class ChildClass(ParentClass): 
	pass

class Person(object):
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
        
    def print_title(self):
        if self.sex == "male":
            print("man")
        elif self.sex == "female":
            print("woman")

class Child(Person):                            # Child 继承 Person
    pass
            
May = Child("May","female")
Peter = Person("Peter","male")

print(May.name,May.sex,Peter.name,Peter.sex)    # 子类继承父类方法及属性
#Out: May female Peter male

继承有什么好处？
答：最大的好处是子类获得了父类的全部属性及功能。

继承多个叫多继承(有多个直接父类)
子类继承父类的语法格式为：(父类为ParentClass1, ParentClass2, …, ParentClassn)

class ChildClass(ParentClass1, ParentClass2, ..., ParentClassn): 
	pass

子类还可以添加父类中没有的属性

class Base(object):
	ca_base = 5
	
	def im_base(self):
		print("im_base()被调用了")

classSubClass(object):
	ca_sub = 8

	def im_sub(self):
		print("im_sub()被调用了")

通过print(dir(SubClass))可以看到：

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__',
 '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', 
 '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'ca_base', 
 'ca_sub', 'im_base', 'im_sub']

除了父类Base中已有的ca_base和im_base，子类SubClass中还有父类Base所没有的ca_sub和im_sub

三、重写

如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其进行重写从而提供自定义的实现

重写的方式为：
在子类中定义与父类中同名的属性或方法（包括装饰器）

子类重写父类的属性后，通过子类或其实例对象只能访问子类中重写后的属性，而无法再访问父类中被重写的属性；
子类重写父类的方法后，通过子类或其实例对象只能调用子类中重写后的方法，而无法再调用父类中被重写的方法

class ParentClass(object):
    ca = "ca(父类)"

    def __init__(self):
        print("__init__()被调用了(父类)")
     
    def im(self):
        print("im()被调用了(父类)")
        
    @classmethod
    def cm(cls):
        print("cm()被调用了(父类)")

class ChildClass(ParentClass):
    ca = "ca(子类)"
    
    def __init__(self):
        print("__init__被调用了(子类)")
        
    def im(self):
        print("im()被调用了(子类)")
        
    @classmethod
    def cm(cls):
        print("cm()被调用了(子类)")

cc = ChildClass()             #Out:__init__被调用了(子类)
print(ChildClass.ca)          #Out:ca(子类)
print(cc.ca)                  #Out:ca(子类)
cc.im()                       #Out:im()被调用了(子类)
ChildClass.cm()               #Out:cm()被调用了(子类)
cc.cm()                       #Out:cm()被调用了(子类)

可见，虽然子类继承自父类，但子类的属性与方法均是重写的，因此在调用时并没有调用父类中的属性和方法

而如果想要调用父类中的属性和方法，可通过super().xxx调用

class ChildClass(ParentClass):
    ca = "ca(子类)"
    
    def __init__(self):
        super().__init__()
        print("__init__被调用了(子类)")
        
    def im(self):
        super().im()
        print("im()被调用了(子类)")
        
    @classmethod
    def cm(cls):
        super().cm()
        print("cm()被调用了(子类)")

cc = ChildClass()             #Out:__init__()被调用了(父类)
								   __init__被调用了(子类)
print(ChildClass.ca)          #Out:ca(子类)
print(cc.ca)                  #Out:ca(子类)
cc.im()                       #Out:im()被调用了(父类)
								   im()被调用了(子类)
ChildClass.cm()               #Out:cm()被调用了(父类)
								   cm()被调用了(子类)
cc.cm()                       #Out:cm()被调用了(父类)
								   cm()被调用了(子类)

四、MRO(Method Resolution Order(方法解析顺序))

MRO就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

python支持多继承，多继承的语言往往会遇到以下两类二义性的问题：

有两个基类A和B，A和B都定义了方法f()，C继承A和B，那么调用C的f()方法时会出现不确定。
有一个基类A，定义了方法f()，B类和C类继承了A类（的f()方法），D类继承了B和C类，那么出现一个问题，D不知道应该继承B的f()方法还是C的f()方法。

在Python中，可以通过调用最底层类对象的方法mro()或访问最底层类对象的特殊属性__mro__，获得这棵树的MRO

class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    def f(self):
        print("B.f")
        
class C(A):
    def f(self):
        print("C.f")
        
class D(B, C):
    def f(self):
        print("D.f")

print(D.mro())       #或print(D.__mro__)
                     #区别在于：mro()输出的为列表；__mro__输出的为元组
#Out:[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

通过输出的MRO结果，有以下顺序：
一般为从下到上，从左到右
在这里插入图片描述
还可以通过添加pass改变顺序

class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    pass
        
class C(A):
    pass
        
class D(B, C):
    pass

d = D()
d.f()            #Out:A.f

当调用D时pass，由MRO顺序看向B，而B也pass，再看C，C也pass，看向A，输出A.f

如果想调用指定父类中被重写的方法，可以给super()传入两个实参：super(a_type, obj), 其中第一个实参a_type是个类对象，第二个实参obj是个实例对象
这样，被指定的父类是：
obj所对应类对象的MRO中，a_type后面的那个类对象

class A(object):
    def f(self):
        print("A.f")
        
class B(A):
    def f(self):
        print("B.f")
        
class C(A):
    def f(self):
        print("C.f")
        
class D(B, C):
    def f(self):
        #super().f()
        super(B, self).f()

d = D()
d.f()              #Out:C.f

由于顺序是D->B->C->A->Object，在调用D()时，存在super(B,self).f()因此找B后面的那个类对象（即为C），然后调用C()中的.f()，故最后输出为C.f

注意：在MRO中，假设顺序为D->B->C->A->Object，调用D()而BCA都pass，Object不存在，此时会出现AttributeError

五、多态

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。

Python是动态语言，动态语言的多态崇尚“鸭子类型”：当看到一只鸟走起来像鸭子，游泳起来像鸭子，叫起来也像鸭子，那么这只鸟就可以被称为鸭子

class ParentClass(object):
    def do_sth(self):
        print("do_sth in ParentClass")
     
class ChildClass1(ParentClass):
    def do_sth(self):
        print("do_sht in ChildCLass1")
            
class ChildClass2(ParentClass):
    def do_sth(self):
        print("do_sht in ChildCLass2")
            
def f(parent):
        parent.do_sth()

f(ParentClass())   #Out:do_sth in ParentClass
f(ChildClass1())   #Out:do_sht in ChildCLass1
f(ChildClass2())   #Out:do_sht in ChildCLass2

就上述例子简单理解，不考虑其他任何因素，类对象ParentClass、ChildClass1、ChildClass2中均存在do_sth，因此，在通过f调用类对象中的do_sth方法时，均会输出这三个类的do_sth方法

class SomeClass(object):
	def do_sth():
		print("do_sth() in SomeClass")

f(SomeClass())
#Out: do_sth in SomeClass

因此，若再添加一个类对象，会有如上类似的输出

当然，如果不存在do_sth这个方法，会报错

class SomeClass1(object):
    def do_sth1():
        print("do_sth() in SomeClass")

f(SomeClass1())
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-10-1128cdf29b82> in <module>
----> 1 f(SomeClass1())

<ipython-input-5-c84c73b197d0> in f(parent)
     12 
     13 def f(parent):
---> 14         parent.do_sth()

AttributeError: 'SomeClass1' object has no attribute 'do_sth'

如果子类中不存在指定名称的方法，回到父类中查找，如果在父类中找到了，则调用父类中的方法

class ChildClass3(ParentClass):
	pass

f(ChildClass3())
#Out: do_sth() in ParentClass

Artoria____

关注

4
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Python面向对象（二）之封装、继承、重写、MRO、多态

面向对象编程有三大属性——封装、继承、多态一、封装封装有两方面的含义：1.将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度2.在类对象的内部通过访问控制吧某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如getter和setter）以访问...
复制链接

扫一扫