Python(11)---继承与多态

最新推荐文章于 2024-04-02 00:00:00 发布
最新推荐文章于 2024-04-02 00:00:00 发布
阅读量223 收藏 3
点赞数 1
分类专栏： # Python基础 文章标签： 类 多态 python class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46841376/article/details/115267753
版权

文章目录

一、继承的语法格式

称为类B继承类A，B类的对象可以使用A类的属性和方法
可以实现代码复用

class 类B(类A):
	pass

一个最基本的继承和方法调用

# 定义父类Animal
class Animal(object):
    def play(self):
        print("Animal's play method execute!")


# 定义Dog类，继承Animal类
class Dog(Animal):
    pass

dog = Dog()
# Animal's play method execute!
dog.play()

二、继承的分类

单继承，多继承，多层继承

三、子类重写父类的同名方法

# 定义父类Animal
class Animal(object):
    def play(self):
        print("Animal's play method execute!")


# 定义Dog类，继承Animal类
class Dog(Animal):
    def play(self):
        print("Dog's play method execute!")

animal = Animal()
# Animal's play method execute!
animal.play()
dog = Dog()
# Dog's play method execute!
dog.play()

四、子类调用父类的同名方法

# 定义父类Animal
class Animal(object):
    def play(self):
        print("Animal's play method execute!")


# 定义Dog类，继承Animal类
class Dog(Animal):
    def play(self):
        print("Dog's play method execute!")
    # 在子类中调用父类的play方法
    def executeAnimalPlay(self):
        # 方法一：父类.方法名(self,其它参数)
        # 使用类名.方法名()调用时，系统不会自动传递实参值self，需要手动传值，如果这里没有传入self参数，则会报错
        Animal.play(self)
        # 方法二：super(类A，self).方法名(参数)，会调用当前类A父类的方法
        super(Dog,self).play()
        # 方法三：方法二的简写，super().方法名(参数)
        super().play()

dog = Dog()
# Animal's play method execute!
dog.executeAnimalPlay()

五、继承中的__init__方法

# 继承中的__init__方法
class Animal(object):
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return f"name={self.name}"

class Dog(Animal):
    # 子类重写了父类的__init__方法，默认不再调用父类的__init__方法，需要手动调用父类的__init__方法
    # 给对象添加从父类继承的属性
    def __init__(self,name,age):
        super().__init__(name)
        self.age = age
    def __str__(self):
        return f"name={self.name},age={self.age}"


dog = Dog('zhangsan',10)
# name=zhangsan,age=10
print(dog)

六、多继承

# 多继承：如果一个类有两个以上父类，就把这种关系称为多继承
class A(object):
    def fun1(self):
        print("A's fun1 execute!")
    def Afun(self):
        print('Afun execute!')

class B(object):
    def fun1(self):
        print("B's fun1 execute!")
    def Bfun(self):
        print('Bfun execute!')

class C(A,B):
    pass


c = C()
# Afun execute!
c.Afun()
# Bfun execute!
c.Bfun()
'''
    两个父类中都有fun1()
    子类对象调用的是在声明时第一个父类的方法
    C(A,B)：在声明时第一个父类是A，因此调用A中的fun1方法
'''
# A's fun1 execute!
c.fun1()

七、多继承中调用指定父类的方法

# 多继承中调用指定父类的方法
# 多继承：如果一个类有两个以上父类，就把这种关系称为多继承
class A(object):
    def fun1(self):
        print("A's fun1 execute!")
    def Afun(self):
        print('Afun execute!')

class B(object):
    def fun1(self):
        print("B's fun1 execute!")
    def Bfun(self):
        print('Bfun execute!')

class C(A,B):
    def fun1(self):
        print("C's fun1 execute!")
        # 调用指定父类中的方法
        # 根据顺序链，调用类A的fun1方法
        # A's fun1 execute!
        super(C, self).fun1()
        # 根据顺序链，调用类B的fun1方法
        # B's fun1 execute!
        super(A, self).fun1()
    pass


c = C()
# Afun execute!
c.Afun()
# Bfun execute!
c.Bfun()
# C's fun1 execute!
# A's fun1 execute!
# B's fun1 execute!
c.fun1()
# 类名.__mro__可以查看当前的继承顺序链，也就是同名方法的调用顺序（从左到右）
# (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
print(C.__mro__)

八、私有属性和私有方法

私有属性

# 私有属性和方法
'''
    私有属性和方法
        在属性和方法前加上两个下划线，该属性或方法变为私有
        私有属性不能在类外访问，只能在类内访问
        私有属性不能被继承
'''
class People(object):
    def __init__(self):
        '''
            定义__age为私有属性，类外无法访问，不能被继承
            python中私有的本质是修改属性的名字，在创建属性的时候，会自动修改属性名
            在属性名前加上"_类名"前缀
            比如这个属性实际上全名是：_People__age
        '''
        self.__age = 0


people = People()
# 代码报错
# print(people.__age)
# 通过__dict__可以查看对象具有的属性信息，类型是字典，字典的key是属性名，字典的value是属性值
# {'_People__age': 0}
print(people.__dict__)
# 注意：这里不是修改私有属性，而是定义了一个新的公有属性
people.__age = 100
# {'_People__age': 0, '__age': 100}
print(people.__dict__)

私有方法

# 私有方法
'''
    私有方法:在方法前加上'__'
    私有方法,不能在类外访问
    作用:一般作为类内部的方法使用,不让外部调用的时候去定义
'''
class Dog(object):
    def fun1(self):
        print('fun1 execute!')
        self.__fun2()
    def __fun2(self):
        print('fun2 execute!')


dog = Dog()
# fun1 execute!
# fun2 execute!
dog.fun1()

九、类属性

'''
    实例对象:通过class关键字定义的类创建的对象,即通过类实例化的
    实例对象定义的属性被称为实例属性,即通过self定义的属性都称为实例属性
    类对象:通过class定义的,python解释器在创建类的时候自动创建的
    类对象的作用:
        1.可以通过类对象定义实例对象
        2.类对象可以保存一些属性信息,称为类属性
    类属性的定义:
        在类内部,方法外部定义的属性就是类属性
'''
class Dog(object):
    # 定义类属性
    className = 'dog'
    def __init__(self,name,age):
        # 定义实例属性
        self.name = name
        self.age = age

dog = Dog('lisi',1)
# 打印dog对象具有的属性
# {'name': 'lisi', 'age': 1}
print(dog.__dict__)
# 类名.__dict__
# {'__module__': '__main__', 'className': 'dog', '__init__': <function Dog.__init__ at 0x000001C35EA5E5E0>, '__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>, '__doc__': None}
print(Dog.__dict__)
# 访问类属性
# dog
print(Dog.className)
# 修改类属性
Dog.className = 'Dog class'
# Dog class
print(Dog.className)
# 注意：如果不存在与实例属性名相同的类属性，则可以使用实例对象访问类属性的值
# 但如果重名，一定访问类属性
# Dog class
print(dog.className)

十、类方法，静态方法

类方法

'''
实例方法：类中默认的方法就是实例方法
    实例方法的第一个参数为self，表示实例对象

类方法：使用@classmethod装饰的方法，称为类方法，第一个参数为cls，代表类对象自己
如果一个方法使用了实例属性，则该方法一定要定义为实例方法
在不需要使用实例属性的前提下，需要使用类属性，可以将这个方法定义为类方法
'''
class Dog(object):
    className = 'dog'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 定义类属性
    @classmethod
    # cls是类方法的默认形参，在调用的时候，不需要手动传递，python解释器会自动传递
    def getClassName(cls):
        return cls.className


dog = Dog('lisi',2)
# dog
print(Dog.getClassName())

静态方法

'''
静态方法：
    使用@staticmethod装饰的方法，称为静态方法，对参数没有特殊要求
    当不需要使用实例属性，也不需要使用类属性的时候，可以将该方法定义为静态方法
'''
class Dog(object):
    className = 'dog'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 定义静态方法
    @staticmethod
    def show():
        print("the Dog class")


dog = Dog('lisi',2)
# 静态方法的调用
# 1.对象.方法名()
# the Dog class
dog.show()
# 2.类名.方法名()
# the Dog class
Dog.show()

十一、多态

'''
多态：
    在需要使用父类对象的地方传入子类对象，得到不同的结果
实现步骤:
    1.子类继承父类
    2.子类重写父类的同名方法
    3.定义一个共同的方法，参数为父类对象，在方法中调用子类和父类同名的方法
'''
class Animal(object):
    def __init__(self,name):
        self.name = name
    def play(self):
        print(f"(动物){self.name}在玩")
class Dog(Animal):
    # 定义play方法
    def play(self):
        print(f"(狗){self.name}在玩")

# 定义公共方法
def doPlay(obj):
    obj.play()

animal = Animal('zhangsan')
dog = Dog('zhangsan')
# (动物)zhangsan在玩
doPlay(animal)
# (狗)zhangsan在玩
doPlay(dog)
叶卡捷琳堡
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Python（白银时代）——继承与多态
qq_25702235的博客
03-21 1454
程序猿与投资生活实录已改名为 程序猿知秋，WX同款，欢迎关注！不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度。在 Python 中 super 是一个特殊的类。子类对象不能直接在自己的方法内部，访问父类的。实现代码的重用，相同的代码不需要重复的编写。使用的场景就是在 重写父类方法时，调用。就是使用super 类创建出来的对象。子类对象可以通过父类的公有方法。子类可以拥有多个父类，并具有。不同的子类对象，调用相同的。，封装子类特有的属性和方法。子类继承父类后，可以直接。重写之后，在运行时，
python的继承和多态
weixin_52599204的博客
08-05 2867
多态指的是一类实物有多种形态，定义 多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果；多态依赖继承子类方法必须要重写父类方法。首先定义一个父类，其可能拥有多个子类对象，当我们调用一个公共方法时，传递的对象不同，则返回的结果不同。好处，调用灵活，有了多台，可以更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化。、不同对象访问相同方法，返回不同结果 就是多态代码实现。多态可以基于继承，也可以不基于继承。...
Python学习之-继承和多态
最新发布
Summer的博客
04-02 1733
什么是继承？什么是多态？面向对象的三大特性：封装：根据 职责 将属性和方法封装到一个抽象类中继承： 实现代码的重用，相同的代码不需要重复的编写多态： 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度继承继承是一种机制，它使得一个类（称为子类或派生类）能够继承另一个类（称为父类或基类）的属性和行为（方法）。子类除了可以继承父类的功能外，还可以添加新的功能或重写某些功能。单继承: 当一个类仅继承自一个父类时。多继承: 当一个类继承自多个父类时。
Python面向对象的三大特性（继承和多态）
Dylan__D的博客
08-18 317
继承、继承的基本语法、单继承、多继承、super()方法、MRO属性或方法、多态、多态的好处、类属性、类方法、静态方法
Python面向对象之继承与多态
qq_65852978的博客
10-09 383
继承就是一种新建类的方式，新建出来的类我们称为是‘子类或者叫派生类’，被继承的类我们称为是‘父类或者基类’当然，出来的类子类可以遗传父类的所有属性class ParentClass1: #定义父类passclass ParentClass2: #定义父类passclass SubClass1(ParentClass1): #单继承passclass SubClass2(ParentClass1,ParentClass2): #多继承pass。
第十二章Python继承和多态习题与答案--中文
12-29
第十二章Python继承和多态习题与答案--中文
Python面向对象编程之继承与多态详解
09-20
主要介绍了Python面向对象编程之继承与多态,结合实例形式详细分析了Python面向对象编程中继承与多态的概念、使用方法及相关注意事项,需要的朋友可以参考下
Python类继承和多态原理解析
12-20
这篇文章主要介绍了python类继承和多态原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 现在属于是老年人的脑子，东西写着写着就忘了，东西记着记着就...
Python的继承多态
12-20
Python的继承多态 文章目录Python的继承多态一、私有属性和私有方法01. 应用场景及定义方式02. 伪私有属性和私有方法二、单例01. 单例设计模式单例设计模式的应用场景02. `__new__` 方法03. Python 中的单例只执行一...
python基础-类与对象（2）
12-21
pytyhon基础——类与对象（2） 四、类的继承与重写1.继承2.多重继承3.重写五、类的多态六、特殊方法七、属性和方法总结 四、类的继承与重写 1.继承 继承是面向对象三大特性之一 - 通过继承我们可以使用一个类获取到...
Python面向对象程序设计之继承、多态原理与用法详解
09-17
主要介绍了Python面向对象程序设计之继承、多态,结合实例形式分析了Python面向对象程序设计中继承、多态的相关概念、原理、用法及操作注意事项,需要的朋友可以参考下
【Python面向对象】封装、继承、多态
尹煜的博客
05-02 5132
面向对象有三个基本特征，分别是封装、继承和多态。其中，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用/调用！本文将利用Python语言进行简单举例，以帮助大家更好地理解这三个特征。
Python 类的继承和多态
weixin_52012241的博客
02-23 1001
Python 类的继承 在OOP（Object Oriented Programming）程序设计中，当我们定义一个class的时候，可以从某个现有的class 继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。 我们先来定义一个class Person，表示人，定义属性变量 name 及 sex （姓名和性别）； 定义一个方法print_title()：当sex是...
python类的继承和多态 ——简单学习与了解
qq_44728587的博客
02-24 741
1.继承 效果：子类获得父类的全部功能。 使用方法：在定义类的括号中(object)，object表示该类是从哪个类继承下来的，在object中填入需要继承的类（父类）的名字，就可以继承父类的全部功能了。 注意：如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。 具体实践： class Animal(object): def run(self): print('Animals is running...') class Dog(Animal):
python类的继承与多态
loner_fang的博客
07-03 8146
python继承的特点：总是从某个类继承。如果没有继承类，则继承自object类python继承的优点：减少代码量；拥有父类的所有功能，只需要编写子类附加的功能即可。python继承类Student类需要有name和gender属性，因为Person类中有所以直接继承即可。另外需要新增score属性。class Person(object): def __init__(self, name...
7. 吴恩达机器学习课程-作业7-Kmeans and PCA
wujing1_1的博客
02-22 986
fork了别人的项目，自己重新填写，我的代码如下 https://gitee.com/fakerlove/machine-learning/tree/master/code 代码原链接 文章目录7. 吴恩达机器学习课程-作业7-Kmeans and PCA7.1 k-means7.1.1 题目介绍7.1.2 算法流程7.1.3 实现k-means7.1.4 测试7.2 图像压缩与k-均值7.3 PCA7.3.1 题目介绍7.3.2 算法流程7.3.3 代码1) 示例数据集2) 实现PCA3) 脸图像数据集
算法提高分类学习刷题——1.动态规划——1.3背包模型
m0_51474171的博客
02-25 3350
（1）01背包 模型 题目介绍 有 N件物品和一个容量为 V 的背包，每件物品有各自的价值且只能被选择一次，要求在有限的背包容量下，装入的物品总价值最大。 「0-1 背包」是较为简单的动态规划问题，也是其余背包问题的基础。 动态规划是不断决策求最优解的过程，「0-1 背包」即是不断对第 i个物品的做出决策，「0-1」正好代表不选与选两种决定。 二维 （1）状态f[i][j]定义：前i个物品，背包容量j下的最优解（最大价值）： 当前的状态依赖于之前的状态，可以理解为从初始状态f[0][0] = 0开.
算法提高分类学习刷题——1.动态规划——1.2.最长上升子序列模型
m0_51474171的博客
02-21 1318
最长上升子序列模型 1.最长上升子序列 题目描述 给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。 输入格式 第一行包含整数 N。 第二行包含 N 个整数，表示完整序列。 输出格式 输出一个整数，表示最大长度。 数据范围 1≤N≤1000， −109≤数列中的数≤109 输入样例： 7 3 1 2 1 8 5 6 输出样例： 4 解题思路 因为以i结尾的子序列，一定是由前i-1个数结尾的子序列长度加一取max 比如一个子序列a[j]a[i] ,那么当a[j]<a[i
继承 多态 python
02-29
下面是一个简单的示例代码，演示了继承和多态在Python中的应用： ```python class Animal: def __init__(self, name): self.name = name def sound(self): pass class Dog(Animal): def sound(self): ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值