Python 类的封装、继承、多态 3 大特性,前面章节已经详细介绍了 Python 类的封装,本节继续讲解 Python 类的继承机制。继承机制经常用于创建和现有类功能类似的新类,又或是新类只需要在现有类基础上添加一些成员(属性和方法),但又不想直接将现有类代码复制给新类。也就是说,通过使用继承这种机制,可以轻松实现类的重复使用。举个例子,假设现有一个 Shape 类,该类的 draw() 方法            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-10 10:17:07
                            
                                79阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            面向对象的编程带来的主要好处之一是代码的重用,实现各种重用的方法之一是通过继承机制。继承完全可以理解成类之间的父类和子类型关系。继承概念:继承是类与类的一种关系,是一种子类与父类的关系,即爸爸与儿子,爸爸生个儿子,儿子继承爸爸的属性和方法。如猫类,猫是动物;猫类继承于动物类,动物类为父类也是所有动物的基类;猫类是动物类的子类,也是动物类的派生类。Python有单继承与多继承。单继承即子类继承于一个            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-17 20:22:05
                            
                                56阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            class A:
    def test(self):
        print('A')
    # pass
class B(A):
    # def test(self):
    #     print('B')
    pass
class C(A):
    # def test(self):
    #     print('C')
    pass
class D(B):
             
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-05 21:50:27
                            
                                132阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            1.python可以继承多个类。2.python如果继承多个类,其寻找方法有两种:深度优先和广度优先。例:F继承D和F,D继承B,F继承C,B和C继承A。查找的顺序是F,D,B,E,C,A# -*- coding: utf-8 -*-
class A:
    def test(self):
        print('A')
class B(A):
    def test(self):            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-05-26 15:13:09
                            
                                99阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            类的继承顺序# 只要继承object类就是新式类
# 不继承object类的都是经典类
# python3 所有的类都继承object类,都是新式类
# 在py2中 不继承object的类都是经典类
#          继承object类的就是新式类了
# 经典类 :在py3中不存在,在py2中不主动继承object的类
# 在py2中
# class A:pass         # 经            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-05-27 10:14:27
                            
                                84阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            目录:子类调用方法时的寻找机制子类调用父类方法的两种方式使用super的注意事项本文中写的方法,即python中的函数1、子类调用方法时的寻找机制python支持多继承,在继承时遵循“先来后到”原则 即区分继承的父类顺序,以左边的父类为先子类对象调用方法时,寻找顺序为==》 先子类,后父类 在父类中寻找方法时,寻找顺序为从左到右,如 class C(A,B),会先在A类中寻找,后在B类中寻找cla            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-11 21:47:00
                            
                                82阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            python的类分为两种类型: 经典类(python2的默认类)和新式类(python3的默认类),经典类在继承的时候采用深度优先的顺序,而新式类的继承顺序则采用广度优先(从左到右)的顺序。在python3中继承可以直接写成 super().方法名(参数)而在python2继承必须写成 super(父类,self).方法名(参数)这里我们重点讨论新式类的继承顺序,先看一个简单的例子: 新建四个类(            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-12 20:30:32
                            
                                138阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            ## Python多类继承顺序
### 流程图
```mermaid
flowchart TD;
    A[创建类A]-->B[创建类B];
    A-->C[创建类C];
    B-->D[创建类D];
    C-->D;
    D-->E[创建类E];
    D-->F[创建类F];
    E-->G[创建类G];
    F-->G;
    G-->H[创建类H];            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-11-24 05:02:11
                            
                                19阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            python的类分为两种类型: 经典类(python2的默认类)和新式类(python3的默认类),经典类在继承的时候采用深度优先的顺序,而新式类的继承顺序则采用广度优先(从左到右)的顺序。在python3中继承可以直接写成 super().方法名(参数)而在python2继承必须写成 super(父类,self).方法名(参数)这里我们重点讨论新式类的继承顺序,先看一个简单的例子: 新建            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-20 17:40:15
                            
                                43阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            python 面向对象之继承顺序发布时间:2018-04-06 20:36:03编辑:admin阅读(1999)先来看一个经典类class A:def __init__(self):
print('A')
class B(A):
def __init__(self):
print('B')
class C(A):
def __init__(self):
print('C')
class            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-26 08:02:55
                            
                                21阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            Python支持多继承,而任何实现多继承的语言都需要处理潜在的命名冲突,这种命名冲突是由不相关的祖先类实现同名方法引起,这种冲突就被称为 菱形问题。需要声明的是,在 Python3 中多继承的搜索顺序为:从左至右,广度优先;Python2采用的多继承搜索顺序为:从左至右,深度优先。一、首先,先来看一下菱形问题 它的继承关系、代码实现和运行结果如下图所示:class A:
    def show(            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-25 10:45:31
                            
                                12阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            俗话说,“虎父无犬子”,“龙生龙,凤生凤,老鼠的儿子会打洞”,这在一定程度上说明了继承的重要性—优秀的特性要留给后辈。在面向对象程序设计中,继承(Inheritance)是软件复用的关键技术。通过继承,子类可以复用父类的优秀特性,同时还可进一步扩充新的特性,适应新的需求。在已有类的基础上新增自己的特性,继而产生新类的过程,称为派生。我们把既有的类称为基类(Base Class)、超类(Super            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-18 18:57:25
                            
                                111阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            俗话说"龙生龙凤生凤老鼠的孩子会打洞",每种动物都有各自的特性,比如老鼠会打洞猫会爬树鲨鱼会游泳不同种类有不同的天性。而在程序员的思维中, 动物是对象, 天性是这个类方法或者属性。再延伸一下,比如Python是面向对象编程语言。有List、Str、Dict、Tuple等数据类型,这些数据类型也是对象,比如List类可以有count方法,我们可以通过count方法统计列表中各个元素的数量。            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-07-04 10:52:01
                            
                                25阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            类的继承是类使用的灵魂,没有继承的类是不完整的,继承也是面对对象类语言的一个显著特点。python中支持多级继承,即类继承是可以一级一级地传递的,在多级继承的过程中依照的顺序是MRO(Method resolution order)顺序来进行继承属性和方法的,不过本文不会涉及到那么复杂的多级继承啦。本文就简单介绍一下类继承的使用方式就好了! 文章目录继承是什么?子类对父类属性和方法的继承和发扬!叮            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-24 21:12:54
                            
                                49阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            在Python中,经典类(class Person:)和新式类(class Person(object):)的主要区别就是体现在多继承的顺序上。Python 2.x中默认都是经典类,只有显式继承了object才是新式类;Python 3.x中默认都是新式类,不必显式地继承object。假设现在有一个D类继承了B类和C类,B类和C类又分别继承了A类。在Python2.7中分别执行如下经典类代码:            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-22 12:31:52
                            
                                34阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            (完整学习过程屏幕记录视频地址在文末,手写笔记在文末)python中定义的类可以继承自其它类,所谓继承的概念,我的理解 是,就是一个类B继承自类A,意味着类B的内部代码块中就算不写任何代码,类B仍然拥有类A的所有公开的属性和方法。这个优势非常方便于我们在要创建一个在原有类的基础上只是稍微有所变化 的类时,可以只通过继承一个类之后,再作属性和方法增改即可完成,大大的减轻了代码工作量。在类的继承活动中            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-02-19 12:27:48
                            
                                54阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            类的继承  1.在python3中,只有新式类,新式类的继承方式为:广度优先。而python2中,经典类的继承方式为:深度优先。那么我们来看看深度优先和广度优先的区别吧  如下图,为类之间的继承关系。B,C继承A,D继承B,E继承C,F继承D,E                           深度优先: class A:
    # def foo(self):
    #            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-30 09:26:02
                            
                                260阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            1.###继承
"""
(1)单继承
至少2个类,子类 和父类
一个类继承另外一个类,当前类是子类(衍生类)
被继承的这个类是父类,(基类和超类)
Python所有类的父类都是object
"""
#1.子类继承后,子类可以使用父类的公有方法
class Father():
   skin="黑色的"
   __sex="man"
   def hobby(self):
      print(            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-10-25 23:31:50
                            
                                9阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Python类(4)类的继承类的继承格式class 子类(基类):pass基类(父类): 被继承者(先辈)子类:继承者(后辈)如果没有基类,就用object比如,我们前面几节课的内容,都是直接继承自object这个基类的.理论上,所有的类都是object的子类可以用base属性查看子类的父类查看子类的父类class 子类(object):
pass
print(子类.__base__)输出:在这里            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-10 10:46:39
                            
                                87阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            多重继承 即一个类继承自多个类,之后该类就可以拥有其父类的属性了 class Person(object):
    def __init__(self):
        print 'person'
class Teacher(Person):
    def __init__(self):
        super(Teacher, self).__init__()            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-04 19:02:30
                            
                                75阅读