继承

最新推荐文章于 2024-02-03 14:26:48 发布
最新推荐文章于 2024-02-03 14:26:48 发布
阅读量110 收藏
点赞数
分类专栏： 业务 文章标签： 编程思想 面向对象 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46072106/article/details/110045868
版权
本文详细介绍了Python中的继承概念，包括单继承、多层继承和多继承，以及如何调用父类方法。同时，讲解了类的权限，强调了私有属性和方法的使用限制。通过实例展示了如何在子类中重写和调用父类方法，以及如何访问私有成员。此外，还探讨了继承中的方法调用顺序和权限控制。
摘要由CSDN通过智能技术生成

1. 简介

  • 单继承：子类只继承一个父类
  • 多层继承：继承关系为多层传递，如生活中的爷爷、父亲、儿子

1.1 定义

1.1 生活中的继承
在现实生活中，继承一般指的是子女继承父辈的财产，如下图：
生活中继承
1.2 程序中的继承
在程序中，继承描述的是指的是类与类之间的关系，如下如所示：
程序中继承

  • 站在父类的角度来看，父类派生出子类
  • 站在子类的角度来看，子类继承于父类
  • 父类也叫基类，子类也叫派生类

1.2 作用

  • 继承：子类直接具备父类的能力（属性和方法）
  • 作用：解决代码重用问题，提高开发效率

1.3 语法格式

继承的语法格式：

class 子类名(父类名)：
    pass

示例代码：

# 定义一个父类
class Father(object):
    # 添加一个属性， money
    def __init__(self):
        self.money = 9999999

    def print_info(self):
        print(self.money)


# 定义一个子类，继承与Father
class Son(Father):
    pass


# 子类创建对象
s = Son()
print(s.money)  # 子类私用继承过来的属性
s.print_info()  # 子类使用继承过来的方法

注意：

  • 子类对象调用方法有一个就近原则
    • 如果本类能找到方法，直接调用本类的方法
    • 如果本类找不到，则调用父类继承过来的方法

2. 分类

2.1 单继承

  • 单继承：子类只继承一个父类
# 定义一个父类， Animal
class Animal(object):
    def eat(self):
        print('吃东西')


# 定义一个子类，只有一个父类
class Dog(Animal):
    pass


# 创建一个子类对象
dog1 = Dog()
dog1.eat()

2.2 多层继承

  • 多层继承：继承关系为多层传递，如生活中的爷爷、父亲、儿子
# 定义一个爷爷类， Animal
class Animal(object):
    def eat(self):
        print('吃东西')


# 定义一个父亲类
class Dog(Animal):
    def drink(self):
        print('喝东西')


# 定义一个儿子类
class SuperDog(Dog):
    pass


# 创建对象
sd = SuperDog()
sd.eat()
sd.drink()

2.3 多继承

1. 简介

1.1 定义
  • 所谓多继承，即子类有多个父类，并且具有它们的特征。
    多继承
1.2 语法格式
class 子类名(父类1, 父类2, ……)：
    pass

示例代码：

# 定义2个类，它们没有继承关系，是平级的
class SmallDog(object):
    def eat(self):
        print('吃小东西')


# 再定义一个类
class BigDog(object):
    def drink(self):
        print('大口喝水')


# 定义一个子类，多继承于上面2个父类
class SuperDog(SmallDog, BigDog):
    pass


# 定义子类对象，调用方法
sd = SuperDog()
sd.eat()
sd.drink()

运行结果：

吃小东西
大口喝水

2. 操作

2.1查看类的继承顺序
  • 查看类的继承顺序：类名.__mro__
    示例代码：
# 定义2个类，它们没有继承关系，是平级的
class SmallDog(object):
    def eat(self):
        print('吃小东西')


# 再定义一个类
class BigDog(object):
    def drink(self):
        print('大口喝水')


# 定义一个子类，多继承于上面2个父类
class SuperDog(SmallDog, BigDog):
    pass


# 查看类的继承顺序
print(SuperDog.__mro__)

运行结果：

(<class '__main__.SuperDog'>, <class '__main__.SmallDog'>, <class '__main__.BigDog'>, <class 'object'>)
2.2 调用父类同名方法
1. 默认调用情况
  • 如果继承过来的2个父类的方法同名，默认调用先继承父类的同名方法
# 定义2个类，它们没有继承关系，是平级的
class SmallDog(object):
    def eat(self):
        print('吃小东西')


# 再定义一个类
class BigDog(object):
    def eat(self):
        print('啃大骨头')


# 定义一个子类，多继承于上面2个父类
class SuperDog(SmallDog, BigDog):
    pass


# 定义子类对象，调用方法
sd = SuperDog()
sd.eat()  # 默认先调用先继承的父类，即 SmallDog

运行结果：

吃小东西
2. 子类重写父类同名方法
  • 父类的方法不能满足子类的需要，可以对父类的方法重写，重写父类方法的目的是为了给他扩展功能
  • 在子类中定义了一个和父类同名的方法(参数也一样)，即为对父类的方法重写
  • 子类调用同名方法，默认只会调用子类的
    示例代码：
# 定义一个父类， Animal
class Animal(object):
    # 添加一个type属性
    def __init__(self):
        print('Animal类中的__init__')
        self.type = '动物'

    # 设计一个方法，打印属性
    def print_type(self):
        print('Animal类中的print_type = ', self.type)


# 定义一个子类，继承与Animal
class Dog(Animal):
    # __init__和父类的同名，重写父类同名方法
    def __init__(self):
        print('Dog类中的__init__')
        self.type = '可爱的小狗'

    # print_type和父类的同名，重写父类同名方法
    def print_type(self):
        print('Dog类中的print_type = ', self.type)


# 定义一个子类对象
dog1 = Dog()  # 调用子类的__init__
dog1.print_type()  # 调用子类的print_type()

运行结果：

Dog类中的__init__
Dog类中的print_type =  可爱的小狗
3. 子类调用父类同名方法
  • 子类调用父类同名方法：
    • 父类名.同名方法(self, 形参1, ……)：调用指定的父类
    • super(类名, self).同名方法(形参1, ……)：调用继承顺序中类名的下一个类的同名方法
    • super().同名方法(形参1, ……)：调用先继承父类的同名方法(是方法2的简写，比较推荐）
      示例代码：
# 定义2个类，它们没有继承关系，是平级的
class SmallDog(object):
    def eat(self):
        print('吃小东西')


# 再定义一个类
class BigDog(object):
    def eat(self):
        print('啃大骨头')


# 定义一个子类，多继承于上面2个父类
class SuperDog(SmallDog, BigDog):
    def eat(self):
        print('吃蟠桃')
        print('='*20)

        # 子类调用父类同名方法：
        # 1. 父类名.同名方法(self, 形参1, ……)
        SmallDog.eat(self)  # 调用SmallDog的eat()
        print('=' * 20)

        # 2. super(类名, self).同名方法(形参1, ……)：调用继承顺序中类名的下一个类的同名方法
        # 继承顺序中，SmallDog的下一个类是BigDog,所以，调用BigDog的eat()
        super(SmallDog, self).eat()
        print('=' * 20)

        # 3. super().同名方法(形参1, ……) ：调用先继承父类的同名方法
        super().eat()


# 定义子类对象，调用方法
sd = SuperDog()
sd.eat()

运行结果：

吃蟠桃
====================
吃小东西
====================
啃大骨头
====================
吃小东西

示例代码：

# 定义一个父类， Animal
class Animal(object):
    # 添加一个type属性
    def __init__(self):
        print('Animal类中的__init__')
        self.type = '动物'

    # 设计一个方法，打印属性
    def print_type(self):
        print('Animal类中的print_type = ', self.type)


# 定义一个子类，继承与Animal
class Dog(Animal):
    # __init__和父类的同名，重写父类同名方法
    def __init__(self):
        print('Dog类中的__init__')
        self.type = '可爱的小狗'

    # print_type和父类的同名，重写父类同名方法
    def print_type(self):
        print('Dog类中的print_type = ', self.type)
        print('='*20)

        # 调用父类同名函数
        # 方法1： 父类名.同名方法(self, 形参1, ……)
        Animal.__init__(self)
        Animal.print_type(self)
        print('=' * 20)

        # 方法2：super(子类名, self).同名方法(形参1, ……)
        super(Dog, self).__init__()
        super(Dog, self).print_type()
        print('=' * 20)

        # 方法3：super().同名方法(形参1, ……) # 是 4.2 方法的简写
        # 推荐使用的方法
        super().__init__()
        super().print_type()


# 定义一个子类对象
dog1 = Dog()  # 调用子类的__init__
dog1.print_type()  # 调用子类的print_type()

运行结果：

Dog类中的__init__
Dog类中的print_type =  可爱的小狗
====================
Animal类中的__init__
Animal类中的print_type =  动物
====================
Animal类中的__init__
Animal类中的print_type =  动物
====================
Animal类中的__init__
Animal类中的print_type =  动物

3.私有和继承

3.1 权限

权限有属性权限和方法权限

1. 私有属性

  • 如果在属性名前面加了2个下划线’__’，则表明该属性是私有属性，否则为公有属性
  • 私有属性只能在类的内部访问
"""
私有属性：
    1. __(2个下划线)开头的属性，就是私有属性
    2. 只能在本类的内部访问，在类的外面无法直接访问
"""
class Dog(object):
    # 添加属性
    def __init__(self):
        self.__baby_count = 0   # 私有属性，以__(2个下划线)开头的属性
        self.age = 1    # 公有属性

    def print_info(self):
        print(self.__baby_count)


# 类的外部
# 创建对象
dog1 = Dog()
# print(dog1.__baby_count) # err, 私有属性，在类的外面无法直接访问
print(dog1.age)

dog1.print_info()

2. 私有方法

  • 私有方法和私有属性类似，在方法名前面加了2个下划线’__’，则表明该方法是私有方法
  • 私有方法只能在类内部使用
"""
私有方法：
    1. __(2个下划线)开头的方法，就是私有方法
    2. 只能在本类的内部访问，在类的外面无法直接访问
    3. 在类的内部调用实例方法的语法格式：self.方法名()
"""


class Dog(object):
    def __init__(self):
        self.__baby_count = 0 # 私有属性，以__(2个下划线)开头的属性
        self.age = 1

    def print_info(self):
        print(self.__baby_count)
        self.__leave()

    # 定义一个私有方法
    def __leave(self):
        print('休产假了')


dog1 = Dog()
dog1.print_info()
# AttributeError: 'Dog' object has no attribute '__leave'
# dog1.__leave() # err, 外部不能访问私有方法

3.2 关系

  • 父类中的私有方法、属性不能直接继承使用
  • 可以通过调用继承的父类的共有方法，间接的访问父类的私有方法、属性
# 定义一个父类， Animal
class Animal(object):
    # 添加一个type属性
    def __init__(self):
        self.__type = '动物'  # 私有

    def __leave(self):  # 私有
        print('休产假3个月')

    # 通过公有方法，间接访问私有元素
    def use_private(self):
        print(self.__type)
        self.__leave()


# 定义一个子类
class Dog(Animal):
    def test(self):
        # print(self.__type) # err，私有不能直接继承使用
        # self.__leave() # err，私有不能直接继承使用
        pass


# 创建子类对象
dog1 = Dog()
dog1.use_private()
adamyoungjack
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day21 面对对象(二)
abc____123的博客
05-10 220
应用:存放家具# 定义一个home类 class Home: def __init__(self, area): self.area = area #房间剩余的可用面积 # self.light = 'on' #灯默认是亮的 self.containsItem = [] def __str__(self): msg...
程序设计中“继承”的含义？
weixin_30530939的博客
11-07 735
引自：http://baike.baidu.com/view/125322.htm 1.【Java继承】(Java inheritance)　　 Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫车，车有以下属性...
C++继承总结
小白的Coding之旅
09-03 211
主要内容： 继承的概念及定义 基类和派生类对象赋值转换 继承中的作用域 派生类的默认成员函数 继承与友元 继承与静态成员 复杂的菱形继承及菱形虚拟继承 继承的总结和反思 继承的概念及定义 继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层...
c++：继承（超详解）
热门推荐
qq_62718027的博客
07-22 7万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
C++中的继承
编程鸟
07-26 1万+
1、继承的相关概念： 继承是不修改已存在的类，而是采取这个已存在类的形式，并将代码加入其中的方法，是面向对象复用的重要手段。继承的语法是：在代码中和原来一样给出该类的名字，但是在左括号的前面加一个冒号和基类的名字（对于多重继承，要给出多个基类名，用逗号隔开）。（1）派生类将继承基类的数据和函数 【例】class A //基类（父类） { public: void Func1(void)
C++继承
最新发布
Wzs040810的博客
02-03 1458
C++继承
图解Java继承内存分配
01-20
继承的基本概念： 　（1）Java不支持多继承，也是说子类至多只能有一个父类。 　（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法。 　（3）子类中定义的成员变量和父类中定义...
Java继承详解
01-20
什么是继承？ 　多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。 　多个类可以称为子类，单独这个类称为父类、超类或者基类。 　子类...
Javascript 继承实现例子
10-29
在真正的Web站点和应用程序中，几乎不可能创建名为ClassA和ClassB的类，更可能的是创建表示特定事物（如形状）的类。考虑本章开头所述的形状的例子，Polygon、Triangle和Rectangle类就构成了一组很好的探讨数据。
JavaScript 继承的实现
10-29
JavaScript 继承的实现是JavaScript开发中的核心概念之一，因为JavaScript并不像其他传统的面向对象语言如C++、C#或Java那样拥有内置的类和继承机制。JavaScript是一种基于对象的语言，它采用了一些独特的机制来模拟...
C++中继承与组合的区别详细解析
09-05
在C++编程语言中，继承和组合是两种重要的面向对象设计原则，它们分别提供了不同的方式来实现代码的重用和类之间的关系。了解这两种机制的区别对于编写高效、可维护的代码至关重要。 首先，继承是一种机制，它允许...
面向对象三大特性之一——继承详解
weixin_59371851的博客
07-22 1214
hello，小伙伴们大家好。相信对面向对象有一定了解的小伙伴都知道面向对象的三大特性为封装、继承、多态。封装特性我们已经在类和对象中体验到了，那么今天我们就来接着学习面向对象的继承特性。一、继承的概念与定义下面我们看到的Person是父类，也称为基类。Student是子类，也成为派生类。继承后父类的Person成员（成员变量和成员函数）都会成为Student的一部分。{public{}protected//姓名//年龄};{protectedint_stuid;......
继承的详解
Rinki123456的博客
07-21 959
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类，而原有类被称为基类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次上的复用。1.2.1继承的定义格式1.2.2继承关系和访问限定符publicprotectedprivate1.2.3继承基类成员访问方式的变化类成员public继承在派生类中不可见。...
程序中的继承(单继承,多继承)简单的介绍
晓江的博客
10-01 1599
程序中的继承 在程序中，继承描述的是多个类之间的所属关系。 如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。 那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。 单继承：子类只继承一个父类 故事情节：煎饼果子老师傅在煎饼果子界摸爬滚打几十年，拥有一身精湛的煎饼果子技术，并总结了一套"古法煎饼果子配方"。 可是老师傅年迈已久，在嗝屁之前希望把...
flask+Gunicorn(gevent)高并发的解决方法探究
weixin_46072106的博客
11-15 9916
1. 协程定义 概念：协程就是协同工作的程序，不是进程也不是线程 理解成–不带返回值的函数调用。 Coroutine：协程，又称微线程，纤程。 协程的这种“挂起”和“唤醒”机制实质上是将一个过程切分成了若干个子过程，给了我们一种以扁平的方式来使用事件回调模型。优点：共享进程的上下文，一个进程可以创建百万，千万的coroutine。 python中的yield和第三方库greenlet，都可以实现协程。 greenlet 提供了在协程中直接切换控制权的方式，比生成器(yield)更加灵活、简洁。 G
RFM会员价值度模型
weixin_46072106的博客
12-14 3150
1. 简介 1.1 作用 会员价值度用来评估用户的价值情况，是区分会员价值的重要模型和参考依据，也是衡量不同营销效果的关键指标之一。 1.2 定义 价值度模型一般基于交易行为产生，衡量的是有实体转化价值的行为。常用的价值度模型是RFM RFM模型是根据会员 最近一次购买时间R（Recency） 购买频率F（Frequency） 购买金额M（Monetary）计算得出RFM得分 通过这3个维度来评估客户的订单活跃价值，常用来做客户分群或价值区分 RFM模型基于一个固定时间点来做模型分析，不同时间计算的
Celery异步任务
weixin_46072106的博客
11-07 1583
1. 简介 Celery 是一个异步任务队列。你可以使用它在你的应用上下文之外执行任务。总的想法就是你的应用程序可能需要执行任何消耗资源的任务都可以交给任务队列，让你的应用程序自由和快速地响应客户端请求。 使用 Celery 运行后台任务并不像在线程中这样做那么简单。但是好处多多，Celery 具有分布式架构，使你的应用易于扩展。 1.1 定义 Celery是一个基于Python开发的分布式异步消息任务队列，它非常易于使用。通过它可以轻松的实现任务的异步处理， 如果你的业务场景中需要用到异步任务，就可以考虑
状态保持与身份认证
weixin_46072106的博客
10-20 1226
1、登录接口实现的业务逻辑 在整个登录接口实现中，除了检查用户名和密码以外，我们需要通过某种方式来记住用户身份（状态保持），还有用户认证。 2、状态保持（用户认证） 1、cookie cookie是一种技术 cookie弊端：1、明文；2、长度限制；3、浏览器端（客户端）不安全 2、 session session是一种机制 session机制优点：1、存储空几间大；2、服务器端（安全）； session机制缺点： 记录用户数据使用的session缓存必须“共享”，限制了集群服务器横向拓展； 数据
金融风控
weixin_46072106的博客
12-14 1068
一 金融风控相关业务介绍 学习目标 知道常见信贷风险 知道 知道信贷领域常用术语含义 1. 信贷简介 1.1 定义 信贷业务，就是贷款业务，是商业银行和互联网金融公司最重要的资产业务和主要赢利手段 通过放款收回本金和利息，扣除成本后获得利润。 贷款平台预测有信贷需求用户的还款情况，然后将本金借贷给还款概率大的用户 1.2 风险 信用风险：借款人的的还款能力和还款意愿在贷款后出现问题的风险 欺诈风险：借款人压根没想还钱，以诈骗为目的 2. 风控简介 2.1 定义 信贷业务中，使用信用来预支金
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值