python面向对象

最新推荐文章于 2024-04-22 01:14:29 发布
最新推荐文章于 2024-04-22 01:14:29 发布
阅读量1k 收藏 19
点赞数 2
分类专栏： # python基础 文章标签： python 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaotai1234/article/details/109128686
版权

python面向对象

一、面向对象编程介绍

1.概述

在这里插入图片描述

2.生活举例

在这里插入图片描述

二、类和对象

在这里插入图片描述

1.类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.对象

在这里插入图片描述

3.类和对象之间的关系

在这里插入图片描述

4.练习：区分类和对象

在这里插入图片描述

5.类的构成

在这里插入图片描述
在这里插入图片描述

6.类的抽象

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

三、定义类

在这里插入图片描述
在这里插入图片描述

四、创建对象

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 需求：洗衣机，功能：能洗衣服
# 1. 定义洗衣机类
"""
class 类名():
    代码
"""


class Washer():
    def wash(self):
        print('能洗衣服')


# 2. 创建对象
# 对象名 =  类名()
haier = Washer()


# 3. 验证成果
# 打印haier对象
print(haier)

# 使用wash功能 -- 实例方法/对象方法 -- 对象名.Wash()
haier.wash()

# 类：洗衣机 功能 洗衣服
class Washer():
    def wash(self):
        print('洗衣服')
        print(self)


haier = Washer()
print(haier)

haier.wash()

# 由于打印对象和打印self得到的内存地址相同，所以self指的是调用该函数的对象

haier1 = Washer()
print(haier1)

haier1.wash()

# 1. 一个类可以创建多个对象； 2. 多个对象都调用函数的时候，self地址是否相同
class Washer():
    def wash(self):
        print('洗衣服')
        print(self)


haier1 = Washer()
haier1.wash()

haier2 = Washer()
haier2.wash()

五、添加和获取对象的属性

在这里插入图片描述
在这里插入图片描述

class Washer():
    def wash(self):
        print('洗衣服')


haier1 = Washer()

# 添加属性  对象名.属性名 = 值
haier1.width = 400
haier1.height = 500

# 获取属性 对象名.属性名
print(f'洗衣机的宽度是{haier1.width}')
print(f'洗衣机的高度是{haier1.height}')

六、在方法内通过self获取对象属性

在这里插入图片描述
在这里插入图片描述

class Washer():
    def wash(self):
        print('洗衣服')

    # 获取实例属性
    def print_info(self):
        # self.属性名
        # print(self.width)
        print(f'洗衣机的宽度是{self.width}')
        print(f'洗衣机的高度是{self.height}')


haier1 = Washer()

# 添加属性
haier1.width = 400
haier1.height = 500

# 对象调用实例方法
haier1.print_info()

七、魔法方法:init()方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 目标： 定义init魔法方法设置初始化属性 并访问调用
"""
1. 定义类
    init魔法方法： width 和 height
    添加实例方法：访问实例属性

2. 创建对象
3. 验证成果
    调用实例方法
"""


class Washer():
    def __init__(self):
        # 添加实例属性
        self.width = 500
        self.height = 800

    def print_info(self):
        print(f'洗衣机的宽度是{self.width}')
        print(f'洗衣机的高度是{self.height}')


haier = Washer()

haier.print_info()

八、有参数的__init__()方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 1. 定义类：带参数的init：宽度和高度； 实例方法：调用实例属性
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def print_info(self):
        print(f'洗衣机的宽度是{self.width}, 洗衣机的高度是{self.height}')


# 2. 创建对象，创建多个对象且属性值不同；调用实例方法
haier1 = Washer(10, 20)
haier1.print_info()

haier2 = Washer(100, 200)
haier2.print_info()

九、魔法方法:str()方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Washer():
    def __init__(self):
        self.width = 300

    def __str__(self):
        return '解释说明：类的说明或对象状态的说明'


haier = Washer()
print(haier)

十、魔法方法:__del__()方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Washer():
    def __init__(self):
        self.width = 300

    def __del__(self):
        print('对象已经删除')


haier = Washer()

十一、继承的概念

1.现实中的继承

在这里插入图片描述

2.程序中的继承

在这里插入图片描述

# 继承：子类默认继承父类的所有属性和方法


# 1. 定义父类
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)


# 2. 定义子类 继承父类
class B(A):
    pass


# 3. 创建对象，验证结论
result = B()
result.info_print()

十二、单继承

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类
class Prentice(Master):
    pass


# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()

十三、多继承

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类 和 学校类
class Prentice(School, Master):
    pass


# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()


# 结论：如果一个类继承多个父类，优先继承第一个父类的同名属性和方法

十四、子类重写父类的同名属性和方法

在这里插入图片描述
在这里插入图片描述

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()

# 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法
class Prentice(Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()

print(Prentice.__mro__)

十五、子类调用父类同名属性和方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        # 加自己的初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        # 父类类名.函数()
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
daqiu.make_cake()

daqiu.make_master_cake()

daqiu.make_school_cake()

daqiu.make_cake()

十六、多层继承

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 步骤：1. 创建类Tusun， 用这个类创建对象；2. 用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
    pass


xiaoqiu = Tusun()

xiaoqiu.make_cake()

xiaoqiu.make_master_cake()

xiaoqiu.make_school_cake()

十七、通过super()来调用父类中方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

        # 2.1 super()带参数写法
        # super(School, self).__init__()
        # super(School, self).make_cake()

        # 2.2 无参数的super
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

    # 需求：一次性调用父类School Master的方法
    def make_old_cake(self):
        # 方法一：如果定义的类名修改，这里也要修改，麻烦； 代码量庞大，冗余
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)

        # 方法二：super()
        # 2.1 super(当前类名, self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()

        # 2.2 无参数super
        super().__init__()
        super().make_cake()


daqiu = Prentice()

daqiu.make_old_cake()

十八、私有属性和私有方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
        # self.money = 2000000
        # 定义私有属性
        self.__money = 2000000

    # 定义私有方法
    def __info_print(self):
        print('这是私有方法')

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


class Tusun(Prentice):
    pass


xiaoqiu = Tusun()

# print(xiaoqiu.money)
# print(xiaoqiu.__money)

xiaoqiu.__info_print()

十九、修改私有属性的值

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
        # 定义私有属性
        self.__money = 2000000

    # 定义函数：获取私有属性值 get_xx
    def get_money(self):
        return self.__money

    # 定义函数：修改私有属性值 set_xx
    def set_money(self):
        self.__money = 500

    # 定义私有方法
    def __info_print(self):
        print('这是私有方法')

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


class Tusun(Prentice):
    pass


xiaoqiu = Tusun()

print(xiaoqiu.get_money())

xiaoqiu.set_money()

print(xiaoqiu.get_money())

二十、多态

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 需求：警务人员和警犬一起工作，警犬分2种：追击敌人和追查毒品，携带不同的警犬，执行不同的工作


# 1. 定义父类，提供公共方法： 警犬 和 人
class Dog(object):
    def work(self):
        pass


# 2. 定义子类，子类重写父类方法：定义2个类表示不同的警犬
class ArmyDog(Dog):
    def work(self):
        print('追击敌人...')


class DrugDog(Dog):
    def work(self):
        print('追查毒品...')


# 定义人类
class Person(object):
    def work_with_dog(self, dog):
        dog.work()


# 3. 创建对象，调用不同的功能，传入不同的对象，观察执行的结果
ad = ArmyDog()
dd = DrugDog()

daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)

二十一、类属性和实例属性

在这里插入图片描述

1.类属性

在这里插入图片描述

# 1. 定义类，定义类属性
class Dog(object):
    tooth = 10


# 2. 创建对象
wangcai = Dog()
xiaohei = Dog()

# 3. 访问类属性： 类和对象
print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)

2.实例属性(对象属性)

在这里插入图片描述

3.通过实例(对象)去修改类属性

在这里插入图片描述

class Dog(object):
    tooth = 10


wangcai = Dog()
xiaohei = Dog()

# 1. 类 类.类属性 = 值
# Dog.tooth = 20
# print(Dog.tooth)
# print(wangcai.tooth)
# print(xiaohei.tooth)


# 2. 测试通过对象修改类属性
wangcai.tooth = 200

print(Dog.tooth)  # 10
print(wangcai.tooth)  # 200
print(xiaohei.tooth)  # 10

4.总结

在这里插入图片描述

二十二、静态方法和类方法

1.类方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

# 1. 定义类：私有类属性，类方法获取这个私有类属性
class Dog(object):
    __tooth = 10

    # 定义类方法
    @classmethod
    def get_tooth(cls):
        return cls.__tooth


# 2. 创建对象，调用类方法
wangcai = Dog()
result = wangcai.get_tooth()
print(result)

2.静态方法

在这里插入图片描述

# 1. 定义类，定义静态方法
class Dog(object):
    @staticmethod
    def info_print():
        print('这是一个静态方法')


# 2. 创建对象
wangcai = Dog()

# 3. 调用静态方法：类 和 对象
wangcai.info_print()

Dog.info_print()

3.总结

在这里插入图片描述

xiaotai1234
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python——面向对象
2301_76512755的博客
03-05 644
Python——面向对象
【Python】Python 中的面向对象编程思想
day day up
10-27 1956
一个思想、理论、逻辑。 独立于变成语言。理论来源于生活 、来源于人类的思考方式。 面向对象：适合解决大型、 复杂业务的项目 面向接口 面向过程 面向切片。
【Python从零到壹】用Python实现植物大战僵尸里的面向对象
最新发布
2401_84003809的博客
04-22 369
类的组成：类名的规范： 是由一个或者多个单词组成的，要求每个单词的首字母大写，其余的小写；Python中一切皆对象，需要开辟内存空间class Student:passprint(id(Student))print(type(Student))print(Student)看到ID的数值，就知道这里的类是开辟了一块内存空间。class Student:native_pace=‘山东’ # 直接写在类里的变量，成为属性 ，学生的地方属性是山东#实例方法： 在类之外定义称为函数，在类之内定义成为方法def ini
Python面向对象
weixin_50666824的博客
08-17 407
第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.__class__ 则指向类。在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数。self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。在类内部的方法中使用时。
python 立方体切割块数_如何在python中绘制数据立方体
weixin_39805195的博客
12-05 120
I was wondering if there's a way to plot a data cube in Python. I mean I have three coordinate for every pointx=part.points[:,0]y=part.points[:,1]z=part.points[:,2]And for every point I have a scalar ...
python面向对象练习题.pdf
09-04
python面向对象练习题，资料，教育资料
面向对象编程基础_python面向对象_python教程_
09-29
以上就是Python面向对象编程的基本概念和特性。掌握这些基础知识，能帮助你更好地理解和编写Python程序，尤其在处理复杂逻辑和大型项目时，面向对象编程的优势会更加明显。在实际应用中，不断实践和探索，才能真正...
python面向对象课件
11-12
面向对象编程（Object-Oriented Programming，简称OOP）是Python编程中的核心概念之一，它是一种编程范式，强调通过创建对象来组织代码，使得程序更易于理解和维护。本课件详细介绍了Python中的面向对象特性，包括类...
Python面向对象进阶学习
09-19
在本文里我们整理了关于Python面向对象的进阶学习知识点以及学习路线等内容，有兴趣的朋友们学习下。
Python面向对象详细教程
12-14
Python开发技术，及面向对象详细说明，及使用方法概述
2014年度辛星python面向对象教程
06-09
这是2014年度辛星python的面向对象教程，希望大家能够喜欢。
python高级之面向对象高级
weixin_34101229的博客
09-27 2947
python高级之面向对象高级 本节内容 成员修饰符 特殊成员 类与对象 异常处理 反射/自省 单例模式 1.成员修饰符 python的类中只有私有成员和公有成员两种，不像c++中的类有公有成员（public），私有成员(private)和保护成员(protected).并且python中没有关键字去修饰成员，默认python中所有的成员都是公有成员，但是私有成员是以两个下划线开头的名字标示私...
python快速入门【五】---- 面向对象编程、python类
丨汀、的博客
03-12 1907
目录 Python面向对象编程 什么是面向对象编程（OOP）？ Python中的类 Python对象（实例） 如何在Python中定义类 实例属性 类属性 实例化对象 这是怎么回事？ 练习 实例方法 修改属性 Python对象继承 狗公园示例 扩展父类的功能 父类与子类 覆盖父类的功能 练习: 狗狗继承 练习: 狗狗饿不饿 Python面向对象编程 在本文中，您将学习Python中的OOP的以下基本概念： Python类 对象实例 定义和使用方法 OOP继承
Python——— 面向对象
qq_63976098的博客
07-14 488
Python面向对象详解，万字图文详解
python入门（8）面向对象 ：类、对象、属性与方法
喜欢历史的码农
05-25 4538
当我们谈论Python的面向对象思想时，主要指的是Python中的类和对象的概念以及与之相关的特性和原则。面向对象编程（Object-Oriented Programming，简称OOP）是一种常用的编程范式，它将程序中的数据和操作数据的方法组织在一起，形成对象，通过对象之间的交互来实现程序的功能。在Python中，面向对象编程主要围绕以下几个核心概念展开：（1）：类是面向对象编程的基础，它是一种自定义的数据类型，用于描述对象的属性和行为。
【wrodpress】wordpress发表文章后无法显示(1)，一次违反常规的Python大厂面试经历
qq194582923的博客
03-28 311
为了方便每次编辑完文章不用改下链接。可以安装这个插件：Pinyin Permalink，自动修改文章的链接为拼音，这样即可一劳永逸的解决问题。在wordpress的文章编辑页面中，手动修改链接为纯英文，问题解决。
面向对象初识
weixin_34194359的博客
06-08 2034
一,初始面向对象. 面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。 优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。 缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。 应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Ap...
Python 面向对象
09-03
Python面向对象编程是一种编程范式，它将程序组织成对象的集合，每个对象都有自己的属性和方法。在Python中，可以通过定义类来创建对象，并通过实例化类来创建具体的对象。引用[1]中的代码示例展示了一个Animal类，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值