[Python零基础入门篇③⑥] - 类的继承、多态与多重继承

原创

哈哥撩编程

发布于 2024-07-17 18:06:19

720

发布于 2024-07-17 18:06:19

🍊 类的继承

🍊 什么是继承？

举个生活中的例子：小明是人类，小明的爸爸也是人类。小明的爸爸会说话、会走路... 同样的小明也会说话、会走路。那么小明打爸爸与小明的这次关系就叫做 继承 ；小明的爸爸是小明的父亲(父类)，小明是爸爸的儿子(子类)；在扩大一个层面来说，小明和小明的爸爸都是人类，所以人类就是小明和小明爸爸的父类，而小明和小明爸爸就是人类的子类。(我也不明白我为啥要扯这种废话...)，结合这种关系，我们再来看看代码中类的继承关系

与前文我们在初识面向对象编程中提到的封装一样，继承也是面向对象编程三大特性之一
在编程中继承的关系是类与类的一种关系
当我们定义了一个新的类时，可以从当前存在的类通过继承的关系得到其功能、属性等；被继承的类我们就叫做父类(也可以叫做基类或者超类)，而新的类则叫做子类，且其具备父类的功能、属性与一些特性。

🍊 父类与子类

首先，子类继承了父类，那么子类就拥有了父类的所有属性、方法。实现了代码的重用，那么相同的代码不需要重复编写，极大的提高了代码的可扩展性和重用性
子类在通过继承拥有了父类的所有属性、方法后，也可以编写仅属于自己的新属性、新方法等，与父类并不冲突。父类不具备子类自有的属性与方法

🍊 如何使用继承

我们来看一个例子：

class Father(object):	# 定义一个 Father 类，有两个函数 talk() 与 run()

    def talk(self):
        print('会说话')

    def run(self):
        print('会跑步')


class Son(Father):		# 定义一个 Son 类，小括号内没有传入 object 通用类，传入的是 Father类
    					# 传入的 Father 类，就是要继承的类；也就是父类，也叫做基类(基础类的简称)
        				# object 为 类 继承的通用类

    def swim(self):
        print('\'Son\' 会游泳')


son = Son()
print(son.talk(), son.run(), son.swim())

# >>> 执行结果如下：
# >>> 会说话
# >>> 会跑步
# >>> 'Son' 会游泳


# >>> 思考一个问题：既然 Son 类 集成了 Father 类，那么 Father 类 是否可以调用 Son 类 的函数？

father = Father()
print(father.swim)

# >>> 执行结果如下：
# >>> AttributeError: 'Father' object has no attribute 'swim'

结合上面的示例我们得出以下结论：

定义子类时，我们需要将父类传入子类的参数内
子类实例化之后可以调用自己与父类的函数与变量
==父类则无法调用子类的独有函数与变量==

🍊 关于继承的小练习

下面我们根据上面的示例，做一个关于继承的小练习，加深我们对继承的理解。

class Father(object):

    def __init__(self, name, sex):
        self.name = name
        self.sex = sex

    def talk(self):
        return f'{self.name} 会说话'

    def is_sex(self):
        if self.sex == 'man':
            return f'{self.name} 是 男的。'
        else:
            return f'{self.name} 是 女的。'


class Son01(Father):

    def play_football(self):
        return f'{self.name} 会踢足球,'


class Son02(Father):

    def play_basketball(self):
        return f'{self.name} 会打篮球,'


son01 = Son01('蛋蛋', 'man')
result_son01 = son01.play_football()
print(result_son01, son01.is_sex())

son02 = Son02('花花', 'woman')
result_son02 = son02.play_basketball()
print(result_son02, son02.is_sex())

father = Father('蛋蛋与花花的爸爸', 'man')
result = father.is_sex()
print(result)

# >>> 执行结果如下：
# >>> 蛋蛋 会踢足球, 蛋蛋 是 男的。
# >>> 花花 会打篮球, 花花 是 女的。
# >>> 蛋蛋与花花的爸爸 是 男的。

🍊 拓展：继承的传递性

什么是传递性？

关于 继承的传递性 ，官方的解释为：子类拥有父类以及父类的父类，以及所有父类的父类的父类...中封装的所有属性、方法。

通俗的来说就是 A类被 B类继承， B类又被 C类继承，那么 C类就会拥有 A、B 类的所有属性和方法。

举一个生活中的真实场景：动物是一个大类，在动物大类之下有猫、狗等不同分类，猫又有橘猫、狸花猫、布偶猫等品种。狗也一样，有哈士奇、萨摩耶、吉娃娃等犬种。

现在我们定义一个哈士奇继承于狗类、狗类继承于动物类，且哈士奇拥有拉雪橇的方法。

代码示例如下：

class Animal(object):

    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f"{self.name} 会吃东西...")

    def drink(self):
        print(f"{self.name} 会喝水...")


class Cat(Animal):

    def miao(self):
        print(f"{self.name} 会喵喵叫...")


class Dog(Animal):

    def wang(self):
        print(f"{self.name} 会汪汪叫...")


class Husky(Dog):

    def work(self):
        print(f"{self.name} 会拉雪橇...")


husky = Husky('哈士奇')
husky.eat()                 # 调用 父类 的 父类 的 方法
husky.wang()                # 调用 父类 的方法
husky.work()                # 调用 自己独有 的方法

# print(husky.eat(), husky.wang(), husky.work())

# >>> 执行结果如下：
# >>> 哈士奇 会吃东西...
# >>> 哈士奇 汪汪叫...
# >>> 哈士奇 会拉雪橇...

husky 类拥有 Dog 类、Animal 类所有属性、方法
但它不会拥有 Cat 类的属性、方法，因为他们没有继承关系

🍊 类的多态

什么是类的多态？ ---> 虽然拥有相同的功能，但是却表现出了多种的状态。联想到类，虽然通过继承拥有了相同的函数，但是执行的结果却不尽相同。这就是类的多态。

==当子类继承了父类的函数，如何才能让子类的父类函数拥有自己的状态呢？答案很简单，那就是在子类中重写父类的方法。==

代码示例如下：

# 创建一个父类
class XiaoMing_Father(object):

    def talk(self):
        print('小明的爸爸发表了一个观点。')


# 创建一个子类继承了父类
class XiaoMing_Brother(XiaoMing_Father):

    def run(self):
        print('小明的哥哥不同意爸爸的观点，自己跑了。')


if __name__ == '__main__':
    xiaoming_brother = XiaoMing_Brother()
    xiaoming_brother.talk()
    
# >>> 执行结果如下：
# >>> 小明的爸爸发表了一个观点。

# >>> xiaoming_brother 实例化之后继承了 XiaoMing_Father 类 的 talk() 函数
# >>> 但是我们并不想要 XiaoMing_Father 类 的 talk() 函数的输出结果
# >>> 这个时候就用到了 '多态'，我们可以在 XiaoMing_Brother 类 中重写 talk() 函数
# >>> 这样就可以让 XiaoMing_Brother 类 虽然继承了 XiaoMing_Father 类 的 talk() 函数
# >>> 但是我们就拥有了自己的状态。示例如下：

# 创建一个父类
class XiaoMing_Father(object):

    def talk(self):
        print('小明的爸爸发表了一个观点。')


# 创建一个子类继承了父类
class XiaoMing_Brother(XiaoMing_Father):

    def run(self):
        print('小明的哥哥不同意爸爸的观点，自己跑了。')

    def talk(self):
        print('小明的哥哥不同意爸爸的观点，并发表了自己的不同观点')

        
# 再创建一个子类
class XiaoMing(XiaoMing_Father):

    def talk(self):
        print('小明的哥哥也不同意爸爸的观点，但也不支持哥哥的看法')
        

if __name__ == '__main__':
    xiaoming_father = XiaoMing_Father()
    xiaoming_father.talk()
    
    xiaoming_brother = XiaoMing_Brother()
    xiaoming_brother.talk()
    
    xiaoming = XiaoMing()
    xiaoming.talk()
    
# >>> 执行结果如下：
# >>> 小明的爸爸发表了一个观点。
# >>> 小明的哥哥不同意爸爸的观点，并发表了自己的不同观点
# >>> 小明的哥哥也不同意爸爸的观点，但也不支持哥哥的看法

# >>> 这里我们看到 xiaoming_brother、xiaoming 都继承了 XiaoMing_Father 类 的 talk() 函数
# >>> 虽然都拥有相同的 talk() 函数，但是他们返回的结果却是不同的。

这里我们思考一下，为什么要有多态，为什么要去继承父类？

其实这是为了使用已经写好的类中的函数，为了保留子类中某个和父类名称一样的函数的功能。这个时候就需要使用到类的多态了。

同时可以帮助我们保留子类中的函数功能。

🍊 Python 中的 supper 函数

supper() 函数的作用：在 Python 中，子类继承父类的方法而使用的关键字；当子类继承父类之后，就可以完全使用父类的方法了。

supper() 函数的用法：示例如下

class Father(object):
    
    def __init__(self):
        print('Hello,I\'m Father')
        
        
class Son(Father):
    
    def __init__(self):
        print('Hello,I\'m Son')
        super(Son, self).__init__()
        # 使用 supper() 函数 令 Son() 函数执行 Father 类的 构造函数
        # Son ：当前类
        # self ：类的实例
        # __init__ : 使用父类的方法
        # 在 Python 2.x 时代，supper() 函数内的两个参数是必须传入的；Python 3.x 时代之后可不传
        
        
if __name__ == '__main__':
    son = Son()
    
# >>> 执行结果如下：
# >>> Hello,I'm Son
# >>> Hello,I'm Father

# >>> 可以看到除了执行 Son() 类的自身的构造函数之外，同时也执行了 Father() 类的构造函数
# >>> 这就是 supper() 函数的使用方法

那么我们能够利用 supper() 函数做什么呢？其实继承了父类函数之后，也会继承父类构造函数的初始化值，接下来我们来看看 supper() 函数如何来传值。

class Father(object):

    def __init__(self, father_name):
        print('Hello,I\'m Father %s' % father_name)


class Son(Father):

    def __init__(self, son_name, father_name):
        print('Hello,I\'m Son %s' % son_name)
        super(Son, self).__init__(father_name)
        # 使用 supper() 函数 令 Son() 函数执行 Father 类的 构造函数
        # Son ：当前类
        # self ：类的实例
        # __init__ : 使用父类的方法
        # 在 Python 2.x 时代，supper() 函数内的两个参数是必须传入的；Python 3.x 时代之后可不传


if __name__ == '__main__':
    son = Son('Neo', 'Neo\'s_father')
    
# >>> 执行结果如下：
# >>> Hello,I'm Son Neo
# >>> Hello,I'm Father Neo's_father

上面的演示案例是基于 Python 2.x 时代，supper() 函数内的两个参数是必须传入的方式实现的，我们再看看Python 3.x 时代之后实现的方式

class Father(object):

    def __init__(self, father_name):
        print('Hello,I\'m Father %s' % father_name)


class Son(Father):

    def __init__(self, son_name):
        print('Hello,I\'m Son %s' % son_name)
        super().__init__('Neo\'s_father')


if __name__ == '__main__':
    son = Son('Neo')
    
# >>> 执行结果如下：
# >>> Hello,I'm Son Neo
# >>> Hello,I'm Father Neo's_father

# >>> 执行结果得出：supper() 函数 很好的兼容了 Python 2.x 与 Python 3.x 的版本。

🍊 类的多重继承

什么是多重继承？为什么使用多重继承？

继承一词我们已经不陌生了，通过继承父类，我们可以在子类中使用父类的属性和方法。而多重继承，可以让子类同时继承多个父类，在实际工作中很多我们需要使用的函数、方法被分散放在多个类中。

如果想要在同一个类中使用这些被分散的各个方法，就需要在子类中继承多个父类，这样的话，我们就可以集中在一个子类中使用多个父类的方法了。

🍊 多重继承的使用方法

使用方法示例如下：

class Son(Father01, Father02, Father03... )

# >>> 将被继承的多个父类放入子类小括号的参数位，每个父类使用逗号隔开
# >>> 继承顺序，从左向右依次继承的

演示案例如下：

# 定义两个父类： Father() 类 与 Mother() 类
class Father(object):

    def play_game(self):
        print('爸爸喜欢打游戏')

    def bodybuilding(self):
        print('爸爸喜欢的健身项目是跑步')


class Mother(object):

    def buy(self):
        print('妈妈喜欢逛淘宝')

    def bodybuilding(self):
        print('妈妈喜欢的健身项目是瑜伽')


# 继承 Father() 类 与 Mother() 类 的子类，使用 pass 做占位，不做具体业务处理
class Son(Father, Mother):
    pass


if __name__ == '__main__':
    son = Son()
    son.play_game()
    son.buy()
    son.bodybuilding()
    
# >>> 执行结果如下：
# >>> 爸爸喜欢打游戏
# >>> 妈妈喜欢逛淘宝
# >>> 爸爸喜欢的健身项目是跑步

# >>> 从执行结果来看，Son类 继承了 Father类与Mather类 后，可以同时使用 Father类 与 Mather类 的函数
# >>> 同时我们也发现，Father类与Mather类都具有相同的函数 bodybuilding() ，当我们的 Son类执行 bodybuilding() 函数时，
# >>> 优先执行的是第一个传入父类 Father类 的 bodybuilding() 函数，
# >>> 说明继承的多个父类中存在相同函数时，是按照顺序从左向右依次继承,其中最左侧的类中的函数才会发生作用。

🍊 v拓展：如何查看类的继承顺序

内置函数： __mro__

class Father(object):

    def play_game(self):
        print('爸爸喜欢打游戏')

    def bodybuilding(self):
        print('爸爸喜欢的健身项目是跑步')


class Mother(object):

    def buy(self):
        print('妈妈喜欢逛淘宝')

    def bodybuilding(self):
        print('妈妈喜欢的健身项目是瑜伽')


class Son(Father, Mother):
    pass


if __name__ == '__main__':
    print('Son类的继承顺序为：', Son.__mro__)
    
# >>> 执行结果如下：
# >>> Son类的继承顺序为：(<class '__main__.Son'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class 'object'>)

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python