Python之继承与多态

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

1、在子类中调用父类方法

  • super（）.方法名（）

  • 类名.方法名（self）

  • spuer（要从哪一个类的上一级类开始查找， self）.方法名（）

  • 子类调用父类方法时，一般都是想对父类方法进行扩展

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def driver(self):
        print('开车太好玩了 ,10迈,太快了')


class Father(Person):
    # 如果我们现在想在原有父类方法基础上扩展,例如我们现在需要重写一个init方法
    # 可以接收 name, age ,gender三个属性
    def __init__(self, name, age, gender):
        # 在父类方法中已经添加了name,和age我们可不可以直接使用呢???
        super().__init__(name, age)
        # 在父类方法的基础上我们在添加一个子类方法独有的功能
        self.gender = gender

    def driver(self):
        print('我要去天安门玩')

    def __str__(self):
        return f'我的姓名是{self.name},我的年龄是{self.age},我的性别是{self.gender}'

class Son(Father):
    def driver(self):
        # 调用Person中的dirver
        # TypeError: driver() missing 1 required positional argument: 'self'
        # Person.driver()
        Person.driver(self)
        # 从Father类的上一级类开始查找方法,并进行调用
        super(Father,self).driver()

        # 调用Father中的dirver
        super().driver()
        # 格式:super(从哪个类的上一级开始查找,self).方法名()
        # 如果类名是当前类,可以省略括号内的内容
        super(Son, self).driver()
        # 书写特有功能


# 所有的参数都传递到了Father类中,并且添加为当前对象的属性
print(Father('Jack', 28, '男'))
s1 =Son('xiaoming', 12, '男')
s1.driver()

# 子类中调用父类方法的三种方式:
# super().方法名()   # 只能调用当前类的上一级类中的方法或函数
# 类名.方法名(self)  # 所使用的类名,必须在当前类的继承关系中  这种方法可以调用不在类中的类方法，但是不能使用self作为对象出现
# super(要从哪一个类的上级类开始查询,self).方法名()  # 类名必须在继承关系内,如果类名是当前所在的类,则可以将括号内内容省略,就是第一中方式

2、多态

  • 在继承链条中，子类重写父类方法，即多个子类和父类中都拥有同名方法，将其对象传入函数或方法内部，执行相同方法后，所展示的效果完全不同，这种现象叫做多态

class Person(object):

    def driver(self):
        print('开车太好玩了 ,10迈,太快了')


class Father(Person):

    def driver(self):
        print('我要去天安门完,不让我进')


class Mother(Person):
    def driver(self):
        print('我会开小汽车,嘟嘟嘟')


class Son(Father):
    def driver(self):
        print('我会骑自行车,真好玩')


def go_shopping(Driver):
    Driver.driver()
    print('很快就到超市了,真好呀')

class Monkey(object):
    def driver(self):
        print('我在骑自行车')


# 在我调用go_shopping时,可以将什么对象传进来???

p1 = Person()
f1 = Father()
s1 = Son()
m1 = Mother()

# 多态: 在继承链条中,无论是多级继承还是多继承,不同的类同种方法会进行重写,重写后在函数或者方法中传入不同的子类创建的对象,调用相同方法所展示的效果完全不同
go_shopping(p1)
go_shopping(f1)
go_shopping(s1)
go_shopping(m1)

# 如果创建一个Monkey对象,能否传入go_shopping并正确执行???
# 如果一个没有继承关系的类,也存在指定方法,也可以进行对象的传递,并在方法或函数内部使用,但是逻辑会有偏差,这种语法没有问题,但是逻辑上有严重偏差的方式叫做"鸭子类型"(扩展,不要求掌握)
# monkey1 = Monkey()
# go_shopping(monkey1)

3、类属性

  • 类属性，就是所有的对象所共有的属性，在对其修改够，所有对象的类属性放生了改变

  • 实例属性，每个对象所独有的，对象被创建后，添加修改实例属性，对其他对象不产生影响

# 类属性 ,有些地方也叫类变量  就是在类中创建的属于所有对象的属性

class Chinese(object):
    # 类属性是所有对象所共有的
    color = 'yellow'
    def __init__(self, name):
        self.name = name


c1 = Chinese('xiaohong')
c2 = Chinese('xiaohuang')
c3 = Chinese('xiaolv')

# 上述三个对象拥有的实例属性是什么???  name
# 他们每个人的实例属性相同么???之间有联系么???  不相同,每个对象间的实例属性互不相关
# 但是三个对象的类属性是完全相同的
print(c1.color)
print(c2.color)
print(c3.color)
# 类属性的获取方式
# 格式1:对象名.类属性名  在实例属性中,不能有与类属性同名的属性,否则类属性不能通过这种方式提取
# 格式2:类名.类属性名  (推荐)

# 修改类属性
# 格式:类名.类属性名 = 值
Chinese.color = 'orange'
# 注意:修改类属性不能使用  对象名.属性名 = 值  这种方式会添加一个实例属性
print(c1.color)
print(c2.color)
print(c3.color)

# 类属性使用场景:
# 可以进行计数
# 可以控制或者包含多个对象
class Apple(object):
    apple_list = []
    def __init__(self):
        Apple.apple_list.append(self)

    count = 10
    def eat(self):
        Apple.count -= 1

a1 = Apple()
a2 = Apple()
a3 = Apple()
a4 = Apple()

a1.eat()
a2.eat()
a3.eat()
a4.eat()
print(Apple.count)
print(Apple.apple_list)

4、类方法

  • 如果在方法内部不需要使用实例属性和实例方法，但是需要使用类属性或者类方法我们就定义类方法

  • 定义方式：需要在方法上方写@classmethod

  • 在类方法中会自动传入cls，这个参数代表的是当前类本身

class Apple(object):
    num = 10
    def __init__(self):
        self.eat_num = 0

    def eat(self):
        # 每次吃苹果,当前的食用数量加1
        self.eat_num += 1
        # 每次吃苹果,让苹果总数 -1
        Apple.num -= 1
    # 当方法中不适用实例属性和实例方法,只会使用到类属性和类方法的时候我们就选择类方法
    # 因为类方法,不需要创建实例去进行调用,可以直接使用类名调用
    @classmethod
    def eat_apple_num(cls):
        # 在类方法中传入的cls即为当前类的类名
        print(f'一共被吃了{10-cls.num}个,还剩{cls.num}个')

# 类方法的调用
# 格式: 类名.类方法名
Apple.eat_apple_num()

# 创建对象
a1 = Apple()
a2 = Apple()
a3 = Apple()
a4 = Apple()
# 吃苹果
a1.eat()
a2.eat()
a3.eat()
a4.eat()
a4.eat()

# 调用类方法
Apple.eat_apple_num()

# 查看每人吃了几个苹果
print(a1.eat_num)
print(a2.eat_num)
print(a3.eat_num)
print(a4.eat_num)

# 类方法可以使用对象调用么?
# a1.eat_apple_num()  不推荐这样使用

5、静态方法

  • 既不依赖于实例，也不依赖于类，这种方法我们就可以定义为静态方法

class Person(object):
    # 在静态方法中,不会传入self, 也不会传入cls 所以在我们使用静态方法时,最好再静态方法中不要使用类或对象的属性或者方法
    # @classmethod  类方法修饰

    @staticmethod
    def func():
        print('我是一个静态方法')

# def func():
#     print('我是一个静态方法')
# 一般能够定义为函数的内容,都可以改写为静态方法,理论静态方法不依赖与类和对象,但是为了更好的封装,我们会将其写到类中
Person.func()


# 静态方法就是一个普通函数,放到类内部就是为了封装,方便我们去继承和导入模块

6、异常捕获

  • 使用try和except可以捕获异常，也就是在出现异常后不会将代码终止运行，而是执行except中的代码处理异常

# 异常捕获:通过代码将可能出现异常的文件放入try中,然后如果出现异常就执行except中的命令
'''
格式:
try:
    可能出现异常的代码
except:
    如果出现了异常,就执行其中的代码
'''

# 需求:读取文件,如果文件不存在,则以写入方式打开
# 如果我们try中的代码出现了异常,则执行except中的命令
# 如果我们try中的代码没有出现异常,则不会执行
try:
    file = open('test.py', 'r')
except:
    file = open('test.py', 'w')

# 在正常的Python开发中基本每个函数中都要出现一次异常捕获
# 代码健壮性:代码抵御异常的能力

7、捕获指定类型的异常

  • 在except后边添加异常类型，就可以捕获指定类型的异常

  • 如果我们想要捕获多种异常

    • 可以在except后边添加多个异常类型，中间用逗号隔开，但是需要用括号包裹，变成一个元组

    • 可以书写多个except

  • 如果所有的异常类型都无法捕获到该异常， 或者我们需要捕获未知类型的异常，可以使用Exception

# try:
#     # NameError: name 'a' is not defined
#     # 如果先出现NameError  我们的后边一句没有办法执行  ZeroDivisionError没有办法捕捉到
#     # print(a)
#     print(1/0)
# # 如果想要捕获指定异常,就在except 后边添加异常的类型
# except ZeroDivisionError: # 这种方式只能捕获指定异常
#     print('出现异常了!!!')

# 在出现异常后, NameError和 ZeroDivisionError  之类的Error就是异常类型
# ZeroDivisionError: division by zero
# print(1/0)
# NameError: name 'a' is not defined
# print(a)


# 能不能同时捕获多种异常呢?  可以
# 方法一:在except后边添加多个异常名称
# try:
#     # NameError: name 'a' is not defined
#     # 如果先出现NameError  我们的后边一句没有办法执行  ZeroDivisionError没有办法捕捉到
#     # print(a)
#     print(1 / 0)
# # 如果想要捕获指定异常,就在except 后边添加异常的类型
# except (ZeroDivisionError, NameError):  # 这种方式只能捕获指定异常
#     print('出现异常了!!!')

# 方法二: 在try后边书写多个except
# try:
#     # NameError: name 'a' is not defined
#     # 如果先出现NameError  我们的后边一句没有办法执行  ZeroDivisionError没有办法捕捉到
#     # 在出现异常之后,后续代码将不会继续执行
#     print(a)
#     print(1 / 0)
# # 如果想要捕获指定异常,就在except 后边添加异常的类型
# except ZeroDivisionError:
#     print('出现ZeroDivisionError异常了!!!')
# except  NameError:
#     print('出现NameError异常!!')

# 如果我们想要展示异常信息怎么办?
# 异常信息就是异常类型冒号之后的注释
# 可以通过获取异常对象,并对异常对象进行打印,得到异常信息
# try:
#     print(a)
#     print(1 / 0)
# # 如果想要捕获指定异常,就在except 后边添加异常的类型
# # 在异常类型之后添加上个as  变量名  这时候 变量就是异常对象,打印该对象就可以出现错误信息
# except ZeroDivisionError as error:
#     print(error)  # division by zero
# except  NameError as error:
#     print('出现NameError异常!!', error)

# 如果我们不知道异常类型是什么怎么办?

# 可以使用Exception进行捕获,Exception是所有异常类的父类,可以捕获所有异常类型

try:
    print('2' + 1)
    print(a)
    print(1 / 0)
except ZeroDivisionError as error:
    print(error)  # division by zero
except NameError as error:
    print('出现NameError异常!!', error)
except Exception:
    print('出现了未知异常')

8、else和finally

  • else： try中控制的代码没有出现异常，则执行该结构内的代码

'''
格式:
try:
    可能会出现异常的代码
except:
    在出现异常后执行该命令处理异常
else:
    当没有出现异常时,执行该代码
'''

try:
    a = 1
    print(a)
except:
    print('出现异常了')
else:
    # try中的代码正常执行没有任何异常,则执行else里边的代码
    print('没有异常,虚惊一场')

  • finally：无论出现什么情况都会执行finally里边的代码，哪怕程序崩溃

'''
try:
    可能出现异常的代码
except:
    代码出现异常后执行该代码处理异常
else:
    如果try中的代码不出现异常,则执行其中的代码
finally:
    无论如何都会执行finally中的代码
'''

# 无论任何情况,finally中的代码都要被执行
try:
    a = 1
    print(a)
    print(1/0)
except NameError:
    print('出现异常了')
else:
    print('没有出现异常')
finally:
    print('出现不出现异常都要执行')
# 代码写到finally中,哪怕程序报错终止,代码依旧需要执行完成,但是写到try结构之外,程序报错终止将不会继续执行外部代码
print('try结构之外书写内容')

9、自定义异常抛出

  • 自定义异常一定要继承自Exception

  • 自定义异常可以使用raise抛出，可以进行捕获或者导致程序终止

  • raise可以抛出系统异常，也可以抛出自定义异常

# 自定义异常的逻辑
# 在自定义异常时,只要继承自Exception就可以当做异常抛出
# 继承后要重写 Exception方法,添加我们需要的内容

class PassWorldError(Exception):
    error_count = 0

    def __init__(self, str):
        super().__init__(str)
        # 在此处可以添加自定义操作
        PassWorldError.error_count += 1

# raise可以手动抛出异常,抛出异常后,可以直接终止程序,或者使用try except进行捕获
# raise可以抛出自定义异常,也可以抛出系统异常
try:
    password = input('请输入您的密码:')
    if len(password) < 6:
        raise PassWorldError('您的密码不足6位,请重新输入')
        # raise NameError('您的密码错误了')
except PassWorldError as error:
    print(error)

# raise PassWorldError('密码错误')

10、模块导入

import 模块名
调用: 模块名.功能名

from 模块名 import 功能名
调用: 功能名

from 模块名  import  *
import 模块名  as 别名
from 模块名 import 功能名 as 别名

# Python中的模块就是可以将别人写好的,或者自己以前写好的功能直接导入新的文件或工程内,导入后可以直接调用  例如 : random  time os

# 我们没有实现模块中的功能,但是我们讲模块导入后就可以使用该功能,类似于继承

# 导入模块的方式
'''
import 模块名
调用: 模块名.功能名

from 模块名 import 功能名
调用: 功能名

from 模块名  import  *
import 模块名  as 别名
from 模块名 import 功能名 as 别名
'''
# # 导入os模块
# import os
#
# # 使用os模块
# print(os.listdir())

# # 导入os模块中部分功能
# from os import listdir, mkdir
# # 使用os模块中的功能
# print(listdir())

# # 导入os模块中的所有功能
# from os import *
# # *就是通配符,表示导入os模块中所有允许导入的模块
#
# # 使用os模块
# print(listdir())

# # 导入os模块,将模块改名为xitong
# import os as xitong
# # 使用os模块
# # NameError: name 'os' is not defined
# # print(os.listdir())
# # 如果给模块起了别名.则原名称不可使用
# print(xitong.listdir())

# from os import listdir as ls
# print(ls())
# NameError: name 'listdir' is not defined
# 给功能名称起别名后,无法使用原名称只能使用新的功能名称
# print(listdir())

11、自定义模块

  • 模块名一定要遵循标识符的命名规则才能被导入

  • 模块中书写的全局变量，函数，类可以盗取其他文件

  • 导入模块时，会将模块中的所有文件执行一遍

  • 为了保证测试代码在导入模块时不被执行，我们的测试代码需要写入

    if __name__ == '__main__:

# 标识符的命名规则
# 1/以字母数字下划线组成
# 2/不能以数字开头
# 3/不能是关键字
# 4/严格区分大小写

age = 18


def func():
    print('我是module中的函数')


class Person(object):
    def eat(self):
        print('西瓜真好吃呀')




# 在书写模块或者工具类的时候,经常需要调试,每次调试完成后还要将代码删除,否则导包结束后测试代码都会被执行一遍

# 所以我们需要想一个办法,将我们写的测试代码在当前模块中执行时,调用,在导入模块时不调用
# __name__就是说明当前文件执行的模块名是什么?
# print(__name__)   # __main__如果在当前文件中执行,模块名就是main
# 如果导入其他模块,则__name__的值就是文件名称module_01
# 所以我们根据__name__的值的判断,就可以断定他是咋当前文件执行,还是导入模块

# 使用该判断,让我们的测试代码只有在当前文件中执行的时候才会被调用
if __name__ == '__main__':
    if age > 10:
        print('今晚不能睡觉了')

12、模块查询顺序

  • sys.path可以查询模块调用路径列表，越靠前的路径越优先查询

  • 开发中可以添加调用路径 sys.path.append(路径)

# 可以使用sys.path查看模块的定位顺序,如果模块名相同,优先从最新的序列查找

import sys
print(sys.path)
# sys.path的返回值是一个路径列表,排名越靠前的路径,在调用模块时优先查找,如果这个路径下没有对应模块才去下一个路径中查找.

# 在开发中可以在列表中你添加路径(了解)

13、__all__的使用方式

# __all__可以控制模块使用功能from 模块名 import *所导入的功能列表

from module_02 import *

# NameError: name 'age' is not defined
# 如果__all__控制的类表中没有改功能则不能在文件中使用
# print(age)
# 如果写到__all__中则可以使用
func()


import module_02
# __all__不能控制import的导入效果
print(module_02.age)

from module_02 import age
# 如果针对性导入某个功能,不受__all__影响
print(age)

14、包的导入

导入包

  • import 包名.模块名

  • from 包名 import 模块名

  • 如果想要使用功能from 包名 import *

    • 要在__init__.py文件中书写__all__添加指定模块名才能导入

# 包:多个有关联的模块在一起,保存在同一个文件夹内,并且文件内有一个__init__.py为文件,这种文件夹就叫做包
# 创建包的方式: mew >>> package   这中创建方式会自动添加一个__init__.py文件

# # 导入包 : import 报名.模块名
# import my_package.module_02
# # 调用 : 包名.模块名.功能名称
# my_package.module_02.func()

# 导入包: from 包名 import 模块名
# from my_package import module_01
# # 调用: 模块名.功能名称
# print(module_01.age)

# 导入包: from 包名 import *
from my_package import *
# 必须在__init__.py文件中的__all__里添加模块列表,才能使用import* 进行导入

print(module_01.age)
module_02.func()

LI_dreamLT
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python类的继承与多态
loner_fang的博客
07-03 8179
python继承的特点：总是从某个类继承。如果没有继承类，则继承自object类python继承的优点：减少代码量；拥有父类的所有功能，只需要编写子类附加的功能即可。python继承类Student类需要有name和gender属性，因为Person类中有所以直接继承即可。另外需要新增score属性。class Person(object): def __init__(self, name...
python中的多继承和多态
陈娟的博客
11-09 8684
继承 就是一个子类继承多个父类： 多继承的例子，如下： class Base(object): def test(self): print("------base") class A(Base): def test1(self): print("-----test1") class B(Base): def test2(self): print("----t
一篇文章带你搞懂Python中的继承和多态
这家伙很懒，什么都没有留下
01-26 1663
继承是面向对象编程中的一个重要概念，它允许我们创建一个新的类，继承另一个类的属性和方法。新类被称为子类，而被继承的类被称为父类或基类。通过继承，子类可以复用父类的代码，并可以添加或覆盖父类的行为。多态是面向对象编程中的另一个核心概念，它允许我们以统一的方式处理不同类型的对象。简单来说，多态就是允许一个接口被多种数据类型实现的方式。通过多态，我们可以将子类的对象当作父类的对象来处理，使得代码更加灵活和可扩展。继承是面向对象编程中实现代码重用和扩展性的重要手段。
【学习笔记】Python中的类、继承和多态
qq_45659165的博客
01-07 599
在 Python 中，“类”是指用于创建对象的模板。它定义了一个类的对象将具有的属性（数据）和行为（方法）。例如，你可能会定义一个带有属性（如namebreed和age）和方法（如bark和fetch）的类Dog。“方法”是作为类的一部分定义的函数。它对类的对象的数据（属性）进行操作，使用点符号调用，例如，。例如，你可能会为类Dog定义一个调用时使狗对象叫的方法barkclass Dog:print("汪汪！")dog.bark() # output: "汪汪！
Python学习之-继承和多态
最新发布
Summer的博客
04-02 1932
什么是继承？什么是多态？面向对象的三大特性：封装：根据 职责 将属性和方法封装到一个抽象类中继承： 实现代码的重用，相同的代码不需要重复的编写多态： 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度继承继承是一种机制，它使得一个类（称为子类或派生类）能够继承另一个类（称为父类或基类）的属性和行为（方法）。子类除了可以继承父类的功能外，还可以添加新的功能或重写某些功能。单继承: 当一个类仅继承自一个父类时。多继承: 当一个类继承自多个父类时。
Python封装、继承和多态
Charge8的博客
02-04 1572
Python封装、继承和多态
Python之继承和多态共7页.pdf.zip
10-30
Python之继承和多态共7页.pdf.zip
Python类继承和多态原理解析
12-20
这篇文章主要介绍了python类继承和多态原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 现在属于是老年人的脑子，东西写着写着就忘了，东西记着记着就...
Python面向对象之继承和多态用法分析
09-19
主要介绍了Python面向对象之继承和多态用法,结合实例形式分析了Python面向对象程序设计中继承与多态的原理及相关操作技巧,需要的朋友可以参考下
Python面向对象编程之继承与多态详解
09-20
面向对象编程（Object-Oriented Programming, OOP）是Python语言的核心特性之一，它允许开发者创建复杂的数据结构，模拟现实世界中的对象。继承和多态是OOP中的两个重要概念，它们极大地增强了代码的复用性和灵活性...
Python-保护，继承，多态
码路编
03-30 623
1.7. 保护、继承、多态1.私有对象和属性： Python中没有像C++中public和private这些关键字来定义公有和私有属性方法 它是以属性命名的方法来区分，如果在属性名前面加上2个下滑线__表示表示这是私有属性，否则为公有属性，方法也是类似的 示例：class Msg: def __init__(self,money): # 私有属性 self.__money=money
Python中的继承和多态
Free雅轩的博客
06-04 251
本文以生活中的基础现象为切入点，主要介绍了Python基础中继承和多态，包括单继承、多继承的语法、多态常见的 “鸭子类型”、 以及如何重写父类的方法都做了详细的讲解。 一、继承的介绍 继承是一种创建新的类的方式，新创建的叫子类，继承的叫父类、超类、基类。继承的特点就是子类可以使用父类的属性(特征、技能)。继承是类与类之间的关系。 继承可以减少代码冗余、提高重用性。 在现实生活中，继承一般指的是子女继承父辈的财产，如下图： 二、如何用继承? 1.继承语法 Class 派生类名(基类名)：#
python继承和多态
m493096871的博客
01-24 671
继承数据的两种方式 class jic:     def __init__(self):         self.mystr="zhuan"         self.money=200000000 class kid(jic):     def __init__(self):         jic.__init__(self) #调用父类定义的变量方法一         #super()...
python中的继承和多态
qq_25360769的博客
03-17 296
继承和多态 “鸭子类型”
2020-10-15
qq_29529339的博客
10-19 144
特殊方法 init 魔法方法 初始化属性 创建实例的时候就会调用这个方法 特殊方法不需要我们调用，特殊方法会在特定时候自动调用 封装 就是为了告诉你的协同开发者，我这个属性是是一个私有属性 类里面别人不写set_name，就不能修改其属性 3.property ...
python的继承和多态
CoolBreeze的博客
06-16 294
# 继承和多态 class Animal: def eat(self): print("Animal is eating") class Bird(Animal): # 继承Animal类 def sing(self): print("Bird is singing") class Dog(...
python中的三大特点：封装 继承 多态
热门推荐
yangkaiorange的博客
09-06 1万+
面向对象的三大特点： 封装：将有一定功能的代码封装起来，使用时调用即可 继承：将公共的属性和方法放在父类中，自己自考虑特有的属性和方法。 多态：程序运行过程中，根据执行条件的不同，动态执行不同的操作代码的过程称为运行时多态。 一 封装 1.封装是面向对象编程的一大特点 2.面向对象编程的第一步，将属性和方法封装到一个抽象的类中 3.外界使用类创建对象，然后让对象调用方法 4...
Python 继承和多态
qq_43712409的博客
06-28 139
在 OOP 程序设计中，当我们定义一个 class 的时候，可以从某个现有的 class 继承，新的 class 称为子类（Subclass），而被继承的 class 称为基类、父类或超类（Base class、Super class）。 比如，我们已经编写了一个名为 Animal 的 class，有一个 run() 方法可以直接打印： class Animal(object): def run(self): print('Animal is running...') 当我们需要编
python 封装 继承 多态 例子_Python——类、面向对象，封装 继承 多态
weixin_34732336的博客
01-28 292
在面向对象的方法中，可以根据某些事物或者情景创建类，并基于这些类来创建对象。编写类时，定义一大类对象都有通用行为，基于类创建的对象，每个对象都自动具备这个类的通用行为。根据类来创建对象被称为实例化。在Python中编写类的方式如下：class Dog():'''创建小狗的类'''def __init__(self,name,age):self.name = nameself.age = age''...
python封装继承和多态
03-25
Python中的封装、继承和多态是面向对象编程的重要概念。下面我将为你介绍一下它们： 1. 封装（Encapsulation）： 封装是将数据和对数据的操作封装在一个类中，通过定义类的属性和方法来实现。封装可以隐藏类的内部...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值