封装、继承、重写、MRO、多态
本文是来源于上雷俊丽老师python课的课件。
9.封装
根据需求将属性和方法封装到一个抽象的类中。
在使用的时候，只要按照自己的需求去调用，不必了解实现的细节。
封装时面向对象编程的三大特征之一。
封装有两方面的含义：
- 将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
- 在类对象的内部通过访问控制把某些属性和方法隐藏起来，不允许在类对象的外部直接访问，而是在类对象的内部对外提供公开的接口方法（例如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之间")
s = Student()
s.get_score()
[out]: 90
s = Student()
s.set_score(88)
s.get_score()
[out]: 88
s.set_score(123)
[out]:
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-7-8bb9f4f15229> in <module>
----> 1 s.set_score(123)
<ipython-input-4-ad6ba7f2cf52> in set_score(self, score)
10 self.__score = score
11 else:
---> 12 raise ValueError('成绩必须在0~100之间')
ValueError: 成绩必须在0~100之间
10.继承
当几个类对象中有共同的属性和方法时，就可以把这些属性和方法抽象并提取到一个积累中，每个类对象特有的属性和方法还是在本类对象中定义，这样，只需要让每个类对象都挤成这个基类，就可以访问积累中的属性和方法了。继承基类的每个类对象被称为派生类。基类也被称为父类或超类，派生类也被称为子类。
Python中的所有类对象都继承自一个统一的基类：object。这就是为什么我们在定义类对象时要在类名后面添加（object）。
除了封装，继承也是面向对象编程的三大特征之一。继承是实现代码复用的重要手段。
class Animal(object):
def eat(self):
print("吃饭")
def drink(self):
print("喝水")
class Dog(Animal):
def swim(self):
print("游泳")
dog = Dog()
dog.eat()
dog.swim()
[out]: 吃饭
游泳
单继承
子类只有一个直接父类时成为单继承。
假设子类和父类分别为ChildClass和ParentClass，子类继承父类的语法格式为：
class ChildClass(ParentClass):
pass
多继承
子类有多个直接父类时成为多继承。
假设子类是ChildClass，直接父类是ParentClass1, ParentClass2, …… , ParentClassn
子类继承父类的语法格式为：
class ChildClass(ParentClass1, ParentClass2, ...... , ParentClassn):
pass
注：子类会继承所有父类（包括所有直接父类和所有间接父类）的所有属性和方法。
子类可以添加父类中没有的属性和方法。
11.重写 (overwriting)
如果子类对继承父类的某个属性或方法不满意，可以在子类中对其进行重写从而提供自定义的实现，重写的方式为：在子类中定义与父类中同名的属性或方法（包括装饰器）。
子类重写父类的属性后，通过子类或其实例对象只能访问子类中重写后的属性，而无法再访问父类中被重写的属性。
子类重写父类的方法后，通过子类或其实例对象只能调用子类中重写后的方法，而无法再调用父类中被重写的方法。
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()
print(ChildClass.ca)
print(cc.ca)
cc.im()
ChildClass.cm()
cc.cm()
[out]:
__init__()被调用了（子类）
ca(子类)
ca(子类)
im()(子类)
cm()(子类)
父类中被重写的名为xxx的方法，在子类重写后的方法中可以通过super().xxx()进行调用。
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):
super().__init__()
print("__init__()被调用了(子类)")
def im(self):
super().im()
print("im()(子类)")
@classmethod
def cm(cls):
super().cm()
print("cm()(子类)")
cc = ChildClass()
print(ChildClass.ca)
print(cc.ca)
cc.im()
ChildClass.cm()
cc.cm()
[out]:
__init__()被调用了(父类)
__init__()被调用了(子类)
ca(子类)
ca(子类)
im()(夫类)
im()(子类)
cm()(夫类)
cm()(子类)
cm()(夫类)
cm()(子类)
12.MRO (Method Resolution Order) 方法解析顺序
MRO的全称是Method Resolution Order(方法解析顺序)，它指的是对于一棵类继承树，当调用最底层类对象所对应实例对象的方法时，Python解释器在类继承树上搜索方法的顺序。
对于一棵类继承树，可以调用最底层类对象的方法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")
d = D()
d.f()
[out]: D.f
print(D.__mro__) #返回元组
print(D.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):
super().f()
d = D()
d.f()
[out]: B.f
class A(object):
def f(self):
print("A.f")
class B(A):
pass
class C(A):
def f(self):
print("C.f")
class D(B, C):
def f(self):
super().f()
d = D()
d.f()
[out]: C.f
class A(object):
def f(self):
print("A.f")
class B(A):
pass
class C(A):
pass
class D(B, C):
def f(self):
super().f()
d = D()
d.f()
[out]: A.f
在子类重写后的方法中通过super()调用父类中被重写的方法时，在父类中搜索方法的顺序基于以该子类为最底层类对象的类继承树的MRO。
如果想调用指定父类中被重写的方法，可以给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
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()
super(C, self).f()
d = D()
d.f()
[out]: A.f
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(A, self).f()
d = D()
d.f()
[out]:
AttributeError: 'super' object has no attribute 'f'
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(D, self).f()
d = D()
d.f()
[out]: B.f
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()
d = D()
d.f()
[out]: B.f
13.多态
——在不考虑对象类型的情况下使用对象
class ParentClass(object):
def do_sth(self):
print('do_sth() in ParentClass')
class ChildClass1(ParentClass):
def do_sth(self):
print('do_sth() in ChildClass1')
class ChildClass2(ParentClass):
def do_sth(self):
print('do_sth() in ChildClass2')
def f(parent):
parent.do_sth
f(ParentClass())
f(ChildClass1())
f(ChildClass2())
[out]: do_sth() in ParentClass
do_sth() in ChildClass1
do_sth() in ChildClass2
class SomeClass(objject):
def do_sth(self):
print("do_sth() in SomeClass")
f(SomeClass)
[out]: do_sth() in SomeClass
除了封装和继承，堕胎也是面向对象编程的三大特征之一。
简单的说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态地决定调用哪个对象中地方法。
如果子类中不存在指定名称的方法，回到父类中去查找，如果在父类中找到了，则调用父类中的方法。
class ChildClass3(ParentClass):
pass
f(ChildClass3())
[out]: do_sth() in ParentClass.
Python是动态语言，在调用函数时不会检查参数的类型。
我们并不关心变量parent所引用的对象是什么类型，到底是不是ParentClass或其子类类型，只关心变量parent所引用的对象是否有do_sth()这个方法。
不关注对象的类型，而是关注对象具有的行为。