17_python基础—面向对象-继承

最新推荐文章于 2022-08-31 20:31:02 发布
最新推荐文章于 2022-08-31 20:31:02 发布
阅读量278 收藏
点赞数
分类专栏： Python专栏 文章标签： python pycharm vscode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/brawly/article/details/119723933
版权

文章目录

一、继承的概念

  • 拓展1：经典类或旧式类

不由任意内置类型派生出的类，称之为经典类。

class 类名:
    代码
    ......
  • 拓展2：新式类
class 类名(object):
    代码

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下：

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

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

# 子类B
class B(A):
    pass

# 创建对象
result = B()
result.info_print()  # 1

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

二、单继承

2.1 概念和语法

1）概念

继承的概念：子类 拥有 父类 的所有 方法 和 属性

在这里插入图片描述

2）语法

class 类名(父类名):

    pass
  • 子类 继承自 父类，可以直接 享受 父类中已经封装好的方法，不需要再次开发
  • 子类 中应该根据 职责，封装 子类特有的 属性和方法

2.2 专业术语

  • Dog 类是 Animal 类的子类，Animal 类是 Dog 类的父类，Dog 类从 Animal 类继承
  • Dog 类是 Animal 类的派生类，Animal 类是 Dog 类的基类，Dog 类从 Animal 类派生

2.3 继承的传递性

  • C 类从 B 类继承，B 类又从 A 类继承
  • 那么 C 类就具有 B 类和 A 类的所有属性和方法

子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法

2.4 案例

故事主线：一个煎饼果子老师傅，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼果子的技术。师父要把这套技术传授给他的唯一的最得意的徒弟。

分析：徒弟是不是要继承师父的所有技术？

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

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

        
# 2. 徒弟类
class Prentice(Master):
    pass


# 3. 创建对象daqiu
daqiu = Prentice()
# 4. 对象访问实例属性
print(daqiu.kongfu)
# 5. 对象调用实例方法
daqiu.make_cake()

三、多继承

3.1 概念和语法

1）概念

  • 子类 可以拥有 多个父类，并且具有 所有父类 的 属性 和 方法
  • 例如：孩子 会继承自己 父亲 和 母亲 的 特性

在这里插入图片描述

2）语法

class 子类名(父类名1, 父类名2...)
    pass

3.2 多继承的使用注意事项

1）问题的提出

  • 如果 不同的父类 中存在 同名的方法，子类对象 在调用方法时，会调用 哪一个父类中的方法呢？

提示：开发时，应该尽量避免这种容易产生混淆的情况！ —— 如果 父类之间 存在 同名的属性或者方法，应该 尽量避免 使用多继承

在这里插入图片描述

2）Python 中的 MRO —— 方法搜索顺序（知道）

  • Python 中针对 类 提供了一个 内置属性 __mro__ 可以查看 方法 搜索顺序
  • MRO 是 method resolution order，主要用于 在多继承时判断 方法、属性 的调用 路径
print(C.__mro__)

输出结果

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
  • 在搜索方法时，是按照 __mro__ 的输出结果 从左至右 的顺序查找的
  • 如果在当前类中 找到方法，就直接执行，不再搜索
  • 如果 没有找到，就查找下一个类 中是否有对应的方法，如果找到，就直接执行，不再搜索
  • 如果找到最后一个类，还没有找到方法，程序报错

3.3 案例

故事推进：daqiu是个爱学习的好孩子，想学习更多的煎饼果子技术，于是，搜索报班学习煎饼果子技术。

所谓多继承意思就是一个类同时继承了多个父类。

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):
    pass

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

注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法。

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

如果子类和父类拥有同名方法和属性，用子类创建对象，这个对象调用同名方法和属性，调用的是子类封装好的方法和属性，而不再是父类里面的。

故事：daqiu掌握了师父和培训的技术后，自己潜心钻研出自己的独门配方的一套全新的煎饼果子技术。

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 = '[独创煎饼果子配方]'

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


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()


# 一个类继承的父类和这些父类的层级关系
print(Prentice.__mro__)

子类和父类具有同名属性和方法，默认使用子类的同名属性和方法。

五、调用父类方法（两种方式）

  • 方法一：
父类名.方法(self)
  • 方法二：
super().父类方法

5.1 子类调用父类的同名方法和属性

故事：很多顾客都希望也能吃到古法和学校的技术的煎饼果子。

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 = '[独创煎饼果子配方]'

    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)


daqiu = Prentice()

daqiu.make_cake()

daqiu.make_master_cake()

daqiu.make_school_cake()

daqiu.make_cake()

5.2 super()调用父类方法

1）用法

  • 在子类中 重写 父类的方法
  • 在需要的位置使用 super().父类方法 来调用父类方法的执行
super().父类方法
  • 代码其他的位置针对子类的需求，编写 子类特有的代码实现

2）super

  • 在 Python 中 super 是一个 特殊的类
  • super() 就是使用 super 类创建出来的对象
  • 最常 使用的场景就是在 重写父类方法时，调用 在父类中封装的方法实现

3）案例

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(School, self).__init__()
        # super(School, self).make_cake()

        # 方法2.2 无参数
        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)

    # 一次性调用父类的同名属性和方法
    def make_old_cake(self):
        # 方法一：代码冗余；父类类名如果变化，这里代码需要频繁修改
        # Master.__init__(self)
        # Master.make_cake(self)
        # School.__init__(self)
        # School.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()

注意：使用super() 可以自动查找父类。调用顺序遵循 __mro__ 类属性的顺序。比较适合单继承使用。

六、多层继承

故事：N年后，daqiu老了，想要把所有技术传承给自己的徒弟。

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 = '[独创煎饼果子配方]'

    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_school_cake()

xiaoqiu.make_master_cake()

运用[独创煎饼果子配方]制作煎饼果子
运用[学校煎饼果子配方]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子

七、父类 私有属性 和 私有方法

7.1 定义私有属性和方法

  1. 子类对象 不能 在自己的方法内部，直接 访问 父类的 私有属性 或 私有方法
  2. 子类对象 可以通过 父类 的 公有方法 间接 访问到 私有属性 或 私有方法

在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。

故事：daqiu把技术传承给徒弟的同时，不想把自己的钱(2000000个亿)继承给徒弟，这个时候就要为钱这个实例属性设置私有权限。

设置私有权限的方法：在属性名和方法名 前面 加上两个下划线 __。

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

    # 定义私有方法
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)

    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


daqiu = Prentice()
# 对象不能访问私有属性和私有方法
# print(daqiu.__money)
# daqiu.__info_print()

xiaoqiu = Tusun()
# 子类无法继承父类的私有属性和私有方法
# print(xiaoqiu.__money)  # 无法访问实例属性__money
# xiaoqiu.__info_print()

注意：私有属性和私有方法只能在类里面访问和修改。

7.2 获取和修改私有属性值

在Python中，一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性值。

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

    # 获取私有属性
    def get_money(self):
        return self.__money

    # 修改私有属性
    def set_money(self):
        self.__money = 500

    def __info_print(self):
        print(self.kongfu)
        print(self.__money)

    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


daqiu = Prentice()

xiaoqiu = Tusun()
# 调用get_money函数获取私有属性money的值
print(xiaoqiu.get_money())
# 调用set_money函数修改私有属性money的值
xiaoqiu.set_money()
print(xiaoqiu.get_money())

八、新式类与旧式（经典）类

object 是 Python 为所有对象提供的 基类，提供有一些内置的属性和方法，可以使用 dir 函数查看

  • 新式类：以 object 为基类的类，推荐使用
  • 经典类：不以 object 为基类的类，不推荐使用
  • 在 Python 3.x 中定义类时，如果没有指定父类，会 默认使用 object 作为该类的 基类 —— Python 3.x 中定义的类都是 新式类
  • 在 Python 2.x 中定义类时，如果没有指定父类，则不会以 object 作为 基类

新式类 和 经典类 在多继承时 —— 会影响到方法的搜索顺序

为了保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行！
今后在定义类时，如果没有父类，建议统一继承自 object

class 类名(object):    
	pass

九、总结

  • 继承的特点

    • 子类默认拥有父类的所有属性和方法
    • 子类重写父类同名方法和属性
    • 子类调用父类同名方法和属性

  • super()方法快速调用父类方法

  • 私有权限

    • 不能继承给子类的属性和方法需要添加私有权限
    • 语法
class 类名():
  # 私有属性
  __属性名 = 值

  # 私有方法
  def __函数名(self):
    代码
少云清
关注
专栏目录
Python面向对象--多继承的案例
那人独钓寒江雪
03-14 1116
class ShenXian: '''神仙类''' def fly(self): print("神仙会飞") def fight(self): print("神仙喜欢打架") class Monkey: '''灵长类''' def eat_banner(self): print("猴子喜欢吃香蕉") def fight(self): print("猴子喜欢打架") class Mon
Python面向对象类的继承实例详解
python基础编程开发教程
03-21 852
本文实例讲述了Python面向对象类的继承。分享给大家供大家参考，具体如下： 一、概述 面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。在某些 OOP 语言中，一...
【python】面向对象---继承 案例
张小三的博客
11-16 275
原本是学java 的突然接触Python还真有点不习惯啊。 例如： 有一个动物类Animal如下： 无参构造： # object 万物之父 class Animal (object): #定义私有属性 type = '爬行' action = '爬' speck = '滋滋' #构造方法不写 # self 类中每个方法的必要参数，指代当...
python面向对象小例子_Python面向对象继承案例
weixin_39602560的博客
11-24 230
面向对象三大特性封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中继承实现代码的重用，相同的代码不需要重复的编写多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度1、单继承1.1、 继承的概念、语法和特点继承的概念：子类 拥有 父类 的所有 方法 和 属性classAnimal:defeat(self):print("吃")defdrink(self):print(...
Python面向对象——继承 实例
Ming's的博客
02-06 520
# coding=UTF-8 class SchoolMember: '''SchoolMember是基类，代表任何学校里的成员。''' def __init__(self, name, age): #定义类的字段 self.name = name self.age = age print('(Initialized
面向对象编程基础_python面向对象_python教程_
09-29
以上就是Python面向对象编程的基本概念和特性。掌握这些基础知识，能帮助你更好地理解和编写Python程序，尤其在处理复杂逻辑和大型项目时，面向对象编程的优势会更加明显。在实际应用中，不断实践和探索，才能真正...
python 类继承object_python-面向对象-17-继承/object类/mro方法
weixin_39527768的博客
11-30 1470
1.继承的基本概念继承是面向对象程序设计的重要特征，也是实现"代码复用"的重要手段。如果一个新类继承自一个设计好的类，就直接具备已有类的特征，这样就大大降低了工作难度，因为很多事情父类已经做了，不需要再重新做一遍，减少重复劳动。已有的类，我们称为父类或者基类，新的类，我们称为子类或者派生类。继承关系示意图：继承语法格式:class 子类类名[(父类1 [, 父类2, ...])]类体结构说明：因为...
python实例化对象是什么意思_python面向对象---类的定义与实例化
weixin_39710251的博客
11-24 2491
python面向对象---类的定义与实例化python是一种面向对象编程语言，自然也有类的概念。python中的类通过class 关键字定义，提供了面向对象的所有标准特性，例如允许一个类继承多个基类， 子类可以覆盖父类的方法，封装，继承，多态 面向对象的三大特性python一样不少。1.类的定义定义一个类使用class关键字class Stu:def __init__(self, name, ag...
python自己封装的类怎么调用_python（面向对象-类封装调用）
weixin_39806603的博客
11-21 2233
一、面对对象思想（1）大家肯定听过 Python 中”一切皆对象“的说法，但可能并不了解它的具体含义，只是在学习的时候听说 Python 是面向对象的编程语言，本节将向大家详细介绍 Python 面向对象的含义。面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性。面向对象编程（Object-oriented Programming，简称 OOP），是一种封装代码...
Python-3-Object-Oriented-Programming-Third-Edition:Packt发行的《 Python 3面向对象编程》第三版
05-05
Python 3面向对象编程-第三版 这是Packt发布的的代码存储库。 在Python 3.8中使用面向对象的设计模式构建健壮且可维护的软件 这本书是关于什么的？ 面向对象编程（OOP）是一种流行的设计范例，其中数据和行为以...
Python3.5面向对象与继承图文实例详解
wx1871428的博客
06-21 218
本文实例讲述了Python3.5面向对象与继承。分享给大家供大家参考，具体如下： 1、编程的方式 2、面向对象的基本概念 3、类的基本概念 4、类的定义与调用――简单代码举例 注：建议类名的开头字母用大写，在Python中，类内的函数称作方法，类外的函数还是称作函数。 #!/usr/bin/env python # -*- coding:utf-8 -*- # Author:ZhengzhengLiu #类 class Person:
day20-面向对象编程、继承
weixin_30485799的博客
11-16 131
一、面向对象编程 1、简介　　面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。　　而面向对象的程序设...
Object——多态与继承
duke-coder的博客
11-06 787
1. 继承简介 继承是⾯向对象三⼤特性之⼀ 通过继承我们可以使⼀个类获取到其他类中的属性和⽅法 在定义类时，可以在类名后⾯的括号中指定当前类的⽗类(超类、基类) 继承提⾼了类的复⽤性。让类与类之间产⽣了关系。有了这个关系，才有了多态的特性 2.方法重写 如果在⼦类中有和⽗类同名的⽅法，则通过⼦类实例去调⽤⽅法时，会调⽤⼦类的⽅法⽽不是⽗类的⽅法，这个特点我们称之为⽅法的重写(覆盖) 当我们调⽤⼀个对象的⽅法时： 会优先去当前对象中寻找是否具有该⽅法，如果有则直接调⽤ 如果没有，则去当前对象的⽗类中
最近5年183个Java面试问题列表及答案［最全］
weixin_34122548的博客
02-21 3200
Java 面试随着时间的改变而改变。在过去的日子里，当你知道 String 和 StringBuilder 的区别（String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象。因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 Str...
Python学习11--面向对象
溪云阁
05-25 317
一、面向过程和面向对象 面向过程：程序里面有大量的函数，每一个环节都是进行函数的调用。编程思想是按照执行时从头到尾的顺序来进行编程的 面向对象：根据需求，划分不同的对象，将对象划分成若干个类，以对象的方式来进行方法或者行为 的调用，不是以函数为单位，而是以对象为单位。 举例说明：编写一个实现请假功能的代码块，大致流程为：员工请假—领导审批—人事记录 1、以面向过程的思想编程： 定义以下函数执行，伪代码如下： def 请假（员工，领导） pass def 撤销请假流程（员工，领导） pass def 审
7_python基础—while循环应用1-100累加和
热门推荐
brawly的博客
08-20 1万+
文章目录一、1-100累加和二、1-100偶数累加和（法一）三、1-100偶数累加和（法二） 一、1-100累加和 # 需求：1-100数字累加和 -- 1 + 2 + 3 + 4...+ 100 = 结果，打印结果 """ 1. 准备做加法运算的数据 1- 100 增量为1 2. 准备变量保存将来运算的结果 3. 循环做加法运算 4. 打印结果 5. 验证结果正确性 """ # 准备数据 i = 1 # 结果变量 result = 0 # 循环 while i <= 100: # 加法
eval 函数
brawly的博客
08-31 3373
eval 函数
Python中的常用模块
brawly的博客
12-01 3018
1.sys模块 在sys模块中定义了一些函数和变量，用来设置和获取系统的信息。
GUI库：PyQt5
brawly的博客
12-21 2298
1.PyQt5简介 PyQt是基于QT的Python封装，标准的QT开发使用的是C++语言，开发效率比较低，而使用Python语言进行封装后，开发效率也大大提升。并且还可以进行可视化的开发。 PyQt是英国的Riverbank Computing公司开发的一套封装QT程序库的Python GUI库。 PyQt5有两种版本：GPL(开源)和商业授权。 PyQt5的模块 1. QtCore：包含了核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

少云清

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值