Python学习笔记 | 类的继承和定制

基于Python3版本的学习。

初识类的继承和定制

在Python中，我们的习惯表述是：A类是B类的子类，而B类是A类的父类（或超类）。
所以，类的继承，让子类拥有了父类拥有的所有属性和方法。

子类也可以在继承的基础上进行个性化的定制，包括：（1）创建新属性、新方法；（2）修改继承到的属性或方法。
简而言之：类的定制，不仅可以让子类拥有新的功能，还能让它有权修改继承到的代码。

类的继承

基础语法：

class A(B):

# A 为子类名，B 为父类名

子类继承的属性和方法，也会传递给子类创建的实例。

class Chinese:
    eye = 'black'

    def eat(self):
        print('吃饭，选择用筷子。')

class Cantonese(Chinese):  
# 通过继承，Chinese类有的，Cantonese类也有
    pass

# 验证子类可以继承父类的属性和方法，进而传递给子类创建的实例
yewen = Cantonese()  
# 子类创建的实例，从子类那间接得到了父类的所有属性和方法
print(yewen.eye)  
# 子类创建的实例，可调用父类的属性
yewen.eat()  
# 子类创建的实例，可调用父类的方法

在类的继承中，不仅子类属于父类，子类所创建的实例实际上也同时属于父类。
理论上，父类可以被无限个子类所继承（这一点好比类的属性方法可以传递给无限个实例）。

拓展知识：

函数isinstance() ：可以用来判断某个实例是否属于某个类。

具体用法是输入两个参数（第一个是实例，第二个是类或类组成的元组），输出是布尔值（True 或 False）。

print(isinstance(1,int))
# 判断1是否为整数类的实例
print(isinstance(1,str))

print(isinstance(1,(int,str)))
# 判断实例是否属于元组里几个类中的一个

#运行结果：
True
False
True

类的继承之多层继承（深度扩展）

继承不仅可以发生在两个层级之间（即父类-子类），还可以有父类的父类、父类的父类的父类……
语法为：
class B(A):
class C(B):

class Earthman:
    eye_number = 2

# 中国人继承了地球人
class Chinese(Earthman):
    eye_color = 'black'

# 广东人继承了中国人，同时也继承了地球人。
class Cantonese(Chinese):
    pass

yewen = Cantonese()
print(yewen.eye_number)
print(yewen.eye_color)

类的继承之多重继承（宽度扩展）

一个类，可以同时继承多个类，语法为：class A(B,C,D):

class Su:
    born_city = 'Jiangsu'
    wearing = 'thick'  # 穿得较厚

    def diet(self):
        print('我们爱吃甜。')

class Yue:
    settle_city = 'Guangdong'
    wearing = 'thin'  # 穿得较薄

    def diet(self):
        print('我们吃得清淡。')

class Yuesu(Yue,Su):
    pass

xiaoming = Yuesu()
print(xiaoming.wearing)
print(xiaoming.born_city)
xiaoming.diet()

就近原则： 越靠近子类（即越靠左）的父类，越亲近，越优先考虑。子类调用属性和方法时，会先在靠左的父类里找，找不到才往右找。

---

类的定制

定制，可以新增代码： 可在子类下新建属性或方法，让子类可以用上父类所没有的属性或方法。

class Chinese:
    eye = 'black'

    def eat(self):
        print('吃饭，选择用筷子。')

class Cantonese(Chinese):  # 类的继承
    native_place = 'guangdong'  # 类的定制

    def dialect(self):  # 类的定制
        print('我们会讲广东话。')

yewen = Cantonese()
print(yewen.eye)
# 父类的属性能用
print(yewen.native_place)
# 子类的定制属性也能用
yewen.eat()
# 父类的方法能用
yewen.dialect()
# 子类的定制方法也能用

定制，也可重写代码： 重写代码，是在子类中，对父类代码的修改。

class Chinese:

    def land_area(self,area):
        print('我们居住的地方，陆地面积是%d万平方公里左右。'% area)

class Cantonese(Chinese):
    # 间接对方法进行重写
    def land_area(self, area, rate = 0.0188):
        Chinese.land_area(self, area * rate)
        # 直接继承父类方法，再调整参数。

gonger = Chinese()
yewen = Cantonese()
gonger.land_area(960)
yewen.land_area(960)

子类继承父类方法的操作是：在def语句后接父类.方法（参数）。
如：Chinese.land_area(self, area * rate)

---

案例：

class Student:
    def __init__(self, name, job=None, time=0.00, time_effective=0.00): 
        self.name = name     # 只有加了self前缀的才能进行调用，否则只能在该方法下使用
        self.job = job
        self.time = time
        self.time_effective = time_effective

    def count_time(self, hour, rate):
        self.time += hour
        self.time_effective += hour * rate

class Programmer(Student):    # 解释1
    def __init__(self, name):    # 解释2
        Student.__init__(self, name, job='programmer', time=0.00, time_effective=0.00)

    def count_time(self, hour, rate=1):    # 解释3
        Student.count_time(self, hour, rate)

student1 = Student('韩梅梅')    # 解释4
student2 = Programmer('李雷')
print(student1.job)
print(student2.job)
student1.count_time(10, 0.8)
student2.count_time(10)

print(student1.time_effective)     # 解释5
print(student2.time_effective)

代码解释：
1、子类Programmer()继承了父类Student()，并进行了类方法的重写（定制）。
2、子类重写初始化函数，修改了原参数中job的默认值，并在函数下调用了父类的初始化函数。
3、子类重写count_time()方法，修改了原参数中rate的默认值。
4、创建实例student1和student2，分别调用count_time()方法。
5、在实例调用某个属性时，格式是：实例名.属性名。此时不用加self。