Spark算子 - Python （二）

最新推荐文章于 2023-10-15 11:01:00 发布
最新推荐文章于 2023-10-15 11:01:00 发布
阅读量2.7k 收藏 17
点赞数 12
分类专栏： 大数据分析与预测 Python程序设计 文章标签： spark python 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44686879/article/details/120908183
版权

仅供交流学习使用！

第6关：Transformation - sortBy

100

任务要求
参考答案
评论4

任务描述
相关知识
    sortBy
    sortBy 案例
编程要求
测试说明

任务描述

本关任务：使用 Spark 的 SortBy 算子按照相关需求完成相关操作。
相关知识

为了完成本关任务，你需要掌握：如何使用 sortBy 算子。
sortBy

sortBy 函数是在 org.apache.spark.rdd.RDD 类中实现的，它的实现如下：

    def sortBy(self, keyfunc, ascending=True, numPartitions=None):
        return self.keyBy(keyfunc).sortByKey(ascending, numPartitions).values()

该函数最多可以传三个参数：

第一个参数是一个函数，排序规则；
第二个参数是 ascending ，从字面的意思大家应该可以猜到，是的，这参数决定排序后 RDD 中的元素是升序还是降序，默认是 true ，也就是升序；
第三个参数是 numPartitions ，该参数决定排序后的 RDD 的分区个数，默认排序后的分区个数和排序之前的个数相等，即为this.partitions.size。

从sortBy函数的实现可以看出，第一个参数是必须传入的，而后面的两个参数可以不传入。
sortBy 案例

    sc = SparkContext("local", "Simple App")
    data = [("a",1),("a",2),("c",1),("b",1)]
    rdd = sc.parallelize(data)
    by = rdd.sortBy(lambda x: x)
    print(by.collect())

输出：

[('a', 1), ('a', 2), ('b', 1), ('c', 1)]

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

需求：使用 sortBy 算子，将 rdd 中的数据进行排序（升序）。
测试说明

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

开始你的任务吧，祝你成功！

# -*- coding: UTF-8 -*-
from pyspark import SparkContext

if __name__ == "__main__":
     # ********** Begin **********#
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local", "Simple App")
    # 2.创建一个内容为（1, 3, 5, 7, 9, 8, 6, 4, 2）的列表List
    data = [1, 3, 5, 7, 9, 8, 6, 4, 2]
    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(data)
    # 4.使用rdd.collect() 收集 rdd 的元素
    print(rdd.collect())
    """
       使用 sortBy 算子，将 rdd 的数据 (1, 3, 5, 7, 9, 8, 6, 4, 2) 按照下面的规则进行转换操作，规则如下:
       需求：
           元素排序，例如：
            5,4,3,1,2  --> 1,2,3,4,5
       """
    # 5.使用 sortBy 算子完成以上需求
    sort_result = rdd.sortBy(lambda x: x)
    # 6.使用rdd.collect() 收集完成 sortBy 转换的元素
    print(sort_result.collect())
    # 7.停止 SparkContext
    sc.stop()
    #********** End **********#

第7关：Transformation - sortByKey

100

任务要求
参考答案
评论4

任务描述
相关知识
    sortByKey
    sortByKey 案例
编程要求
测试说明

任务描述

本关任务：使用 Spark 的 sortByKey 算子按照相关需求完成相关操作。
相关知识

为了完成本关任务，你需要掌握：如何使用 sortByKey 算子。
sortByKey

    def sortByKey(self, ascending=True, numPartitions=None, keyfunc=lambda x: x):
        if numPartitions is None:
            numPartitions = self._defaultReducePartitions()
        memory = self._memory_limit()
        serializer = self._jrdd_deserializer
        def sortPartition(iterator):
            sort = ExternalSorter(memory * 0.9, serializer).sorted
            return iter(sort(iterator, key=lambda kv: keyfunc(kv[0]), reverse=(not ascending)))
        if numPartitions == 1:
            if self.getNumPartitions() > 1:
                self = self.coalesce(1)
            return self.mapPartitions(sortPartition, True)
        # first compute the boundary of each part via sampling: we want to partition
        # the key-space into bins such that the bins have roughly the same
        # number of (key, value) pairs falling into them
        rddSize = self.count()
        if not rddSize:
            return self  # empty RDD
        maxSampleSize = numPartitions * 20.0  # constant from Spark's RangePartitioner
        f\fraction = min(maxSampleSize / max(rddSize, 1), 1.0)
        samples = self.sample(False, f\fraction, 1).map(lambda kv: kv[0]).collect()
        samples = sorted(samples, key=keyfunc)
        # we have numPartitions many parts but one of the them has
        # an implicit boundary
        bounds = [samples[int(len(samples) * (i + 1) / numPartitions)]
                  for i in range(0, numPartitions - 1)]
        def rangePartitioner(k):
            p = bisect.bisect_left(bounds, keyfunc(k))
            if ascending:
                return p
            else:
                return numPartitions - 1 - p
        return self.partitionBy(numPartitions, rangePartitioner).mapPartitions(sortPartition, True)

说明：ascending参数是指排序（升序还是降序），默认是升序。numPartitions参数是重新分区，默认与上一个RDD保持一致。keyfunc参数是排序规则。
sortByKey 案例

    sc = SparkContext("local", "Simple App")
    data = [("a",1),("a",2),("c",1),("b",1)]
    rdd = sc.parallelize(data)
    key = rdd.sortByKey()
    print(key.collect())

输出：

[('a', 1), ('a', 2), ('b', 1), ('c', 1)]

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

需求：使用 sortBy 算子，将 rdd 中的数据进行排序（升序）。
测试说明

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

开始你的任务吧，祝你成功！

# -*- coding: UTF-8 -*-
from pyspark import SparkContext

if __name__ == "__main__":
   # ********** Begin **********#
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local", "Simple App")
    # 2.创建一个内容为[(B',1),('A',2),('C',3)]的列表List
    data = [('B', 1), ('A', 2), ('C', 3)]
    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(data)
    # 4.使用rdd.collect() 收集 rdd 的元素
    print(rdd.collect())
    """
       使用 sortByKey 算子，将 rdd 的数据 ('B', 1), ('A', 2), ('C', 3) 按照下面的规则进行转换操作，规则如下:
       需求：
           元素排序，例如：
            [(3,3),(2,2),(1,1)]  -->  [(1,1),(2,2),(3,3)]
       """
    # 5.使用 sortByKey 算子完成以上需求
    sort_by_key = rdd.sortByKey()
    # 6.使用rdd.collect() 收集完成 sortByKey 转换的元素
    print(sort_by_key.collect())
    # 7.停止 SparkContext
    sc.stop()
    # ********** End **********#

第8关：Transformation - mapValues

100

任务要求
参考答案
评论4

任务描述
相关知识
    mapValues
    mapValues 案例
编程要求
测试说明

任务描述

本关任务：使用Spark 的 mapValues 算子按照相关需求完成转换操作。
相关知识

为了完成本关任务，你需要掌握：如何使用 mapValues 算子。
mapValues

mapValues ：针对（Key， Value）型数据中的 Value 进行 Map 操作，而不对 Key 进行处理。

上图中的方框代表 RDD 分区。 a=>a+2 代表对 (V1,1) 这样的 Key Value 数据对，数据只对 Value 中的 1 进行加 2 操作，返回结果为 3。
mapValues 案例

    sc = SparkContext("local", "Simple App")
    data = [("a",1),("a",2),("b",1)]
    rdd = sc.parallelize(data)
    values = rdd.mapValues(lambda x: x + 2)
    print(values.collect())

输出：

[('a', 3), ('a', 4), ('b', 3)]

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

需求：使用mapValues算子，将rdd的数据 (“1”, 1), (“2”, 2), (“3”, 3), (“4”, 4), (“5”, 5) 按照下面的规则进行转换操作，规则如下:

偶数转换成该数的平方
奇数转换成该数的立方

测试说明

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

开始你的任务吧，祝你成功！

# -*- coding: UTF-8 -*-
from pyspark import SparkContext

if __name__ == "__main__":
   # ********** Begin **********#
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local", "Simple App")
    # 2.创建一个内容为[("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5)]的列表List
    data = [("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5)]
    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(data)
    # 4.使用rdd.collect() 收集 rdd 的元素
    print(rdd.collect())
    """
           使用 mapValues 算子，将 rdd 的数据 ("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5) 按照下面的规则进行转换操作，规则如下:
           需求：
               元素（key,value）的value进行以下操作：
                                                偶数转换成该数的平方
                                                奇数转换成该数的立方
    """
    # 5.使用 mapValues 算子完成以上需求
    values = rdd.mapValues(lambda x: x * x if x % 2 == 0 else x * x * x)
    # 6.使用rdd.collect() 收集完成 mapValues 转换的元素
    print(values.collect())
    # 7.停止 SparkContext
    sc.stop()
    # ********** End **********#

第9关：Transformations - reduceByKey

100

任务要求
参考答案
评论4

任务描述
相关知识
    reduceByKey
    reduceByKey 案例
编程要求
测试说明

任务描述

本关任务：使用 Spark 的 reduceByKey 算子按照相关需求完成转换操作。
相关知识

为了完成本关任务，你需要掌握：如何使用 reduceByKey 算子。
reduceByKey

reduceByKey 算子，只是两个值合并成一个值，比如叠加。

函数实现：

 def reduceByKey(self, func, numPartitions=None, partitionFunc=portable_hash):
        return self.combineByKey(lambda x: x, func, func, numPartitions, partitionFunc)

上图中的方框代表 RDD 分区。通过自定义函数 (A,B) => (A + B) ，将相同 key 的数据 (V1,2) 和 (V1,1) 的 value 做加法运算，结果为（ V1,3）。
reduceByKey 案例

    sc = SparkContext("local", "Simple App")
    data = [("a",1),("a",2),("b",1)]
    rdd = sc.parallelize(data)
    print(rdd.reduceByKey(lambda x,y:x+y).collect())

输出：

[('a', 3), ('b', 1)]

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

需求：使用 reduceByKey 算子，将 rdd(key-value类型) 中的数据进行值累加。

例如：

("soma",4), ("soma",1)， ("soma",2） ->  ("soma",7)

测试说明

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

开始你的任务吧，祝你成功！

# -*- coding: UTF-8 -*-
from pyspark import SparkContext

if __name__ == "__main__":
    # ********** Begin **********#
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local", "Simple App")
    # 2.创建一个内容为[("python", 1), ("scala", 2), ("python", 3), ("python", 4), ("java", 5)]的列表List
    data = [("python", 1), ("scala", 2), ("python", 3), ("python", 4), ("java", 5)]
    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(data)
    # 4.使用rdd.collect() 收集 rdd 的元素
    print(rdd.collect())
    """
          使用 reduceByKey 算子，将 rdd 的数据[("python", 1), ("scala", 2), ("python", 3), ("python", 4), ("java", 5)] 按照下面的规则进行转换操作，规则如下:
          需求：
              元素（key-value）的value累加操作，例如：
                                                (1,1),(1,1),(1,2)  --> (1,4)
                                                (1,1),(1,1),(2,2),(2,2)  --> (1,2),(2,4)
    """
    # 5.使用 reduceByKey 算子完成以上需求
    result = rdd.reduceByKey(lambda x, y: x + y)
    # 6.使用rdd.collect() 收集完成 reduceByKey 转换的元素
    print(result.collect())
    # 7.停止 SparkContext
    sc.stop()
    # ********** End **********#

第10关：Actions - 常用算子

100

任务要求
参考答案
评论4

任务描述
相关知识
    count
    first
    take
    reduce
    collect
编程要求
测试说明

任务描述

本关任务：使用Spark 的 Action 常用算子按照相关需求完成相关操作。
相关知识

为了完成本关任务，你需要掌握：如何使用 Action 的常用算子。
count

count()：返回 RDD 的元素个数。

示例：

    sc = SparkContext("local", "Simple App")
    data = ["python", "python", "python", "java", "java"]
    rdd = sc.parallelize(data)
    print(rdd.count())

输出：

5

first

first()：返回 RDD 的第一个元素（类似于take(1)）。

示例：

    sc = SparkContext("local", "Simple App")
    data = ["python", "python", "python", "java", "java"]
    rdd = sc.parallelize(data)
    print(rdd.first())

输出：

python

take

take(n)：返回一个由数据集的前 n 个元素组成的数组。

示例：

    sc = SparkContext("local", "Simple App")
    data = ["python", "python", "python", "java", "java"]
    rdd = sc.parallelize(data)
    print(rdd.take(2))

输出：

['python', 'python']

reduce

reduce()：通过func函数聚集 RDD 中的所有元素，该函数应该是可交换的和关联的，以便可以并行正确计算。

示例：

    sc = SparkContext("local", "Simple App")
    data = [1,1,1,1]
    rdd = sc.parallelize(data)
    print(rdd.reduce(lambda x,y:x+y))

输出：

4

collect

collect()：在驱动程序中，以数组的形式返回数据集的所有元素。

示例：

    sc = SparkContext("local", "Simple App")
    data = [1,1,1,1]
    rdd = sc.parallelize(data)
    print(rdd.collect())

输出：

[1,1,1,1]

编程要求

请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下：

需求1：使用 count 算子，统计下 rdd 中元素的个数；

需求2：使用 first 算子，获取 rdd 首个元素；

需求3：使用 take 算子，获取 rdd 前三个元素；

需求4：使用 reduce 算子，进行累加操作；

需求5：使用 collect 算子，收集所有元素。
测试说明

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

开始你的任务吧，祝你成功！

# -*- coding: UTF-8 -*-
from pyspark import SparkContext

if __name__ == "__main__":
   # ********** Begin **********#
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local", "Simple App")
    # 2.创建一个内容为[1, 3, 5, 7, 9, 8, 6, 4, 2]的列表List
    data = [1, 3, 5, 7, 9, 8, 6, 4, 2]
    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(data)
    # 4.收集rdd的所有元素并print输出
    print(rdd.collect())
    # 5.统计rdd的元素个数并print输出
    print(rdd.count())
    # 6.获取rdd的第一个元素并print输出
    print(rdd.first())
    # 7.获取rdd的前3个元素并print输出
    print(rdd.take(3))
    # 8.聚合rdd的所有元素并print输出
    print(rdd.reduce(lambda x, y: x + y))
    # 9.停止 SparkContext
    sc.stop()
    # ********** End **********#
如是Rushy
关注
  • 12
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Transformation的map使用
weixin_39868387的博客
07-03 712
上篇：Sink-StreamingFileSink的使用 需求实现：在nc -lk 8888窗口下执行输入数据，把输入的单词转为大写在控制台输出 具体代码： package cn._51doit.flink.day02; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.configuration.Configuration; import org.apache.flink.stream
5.6 Spark算子 - Python
weixin_43988390的博客
04-10 983
第2关：Transformation - mapPartitions。第7关：Transformation - sortByKey。第8关：Transformation - mapValues。第5关：Transformation - distinct。第4关：Transformation - flatMap。第3关：Transformation - filter。第6关：Transformation - sortBy。第1关：Transformation - map。
Spark算子 - Python（头歌）
最新发布
python一生之敌的博客
10-15 1898
Spark算子 - Python
常用transformation介绍
小江专栏
07-09 669
map map：将RDD中的每个元素传入自定义函数，获取一个新的元素，然后用新的元素组成新的RDD。 案例：将集合中每一个元素都乘以2 java: // 构造集合 List numbers = Arrays.asList(1, 2, 3, 4, 5); // 并行化集合，创建初始RDD JavaRDD numberRDD = sc.parallelize(numbers); // 使用
Spark算子 - Python （一）
weixin_44686879的博客
10-22 7368
一、理论基础 Spark的算子可分为： Transformation变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。Transformation操作是延迟计算的，也就是说从一个RDD转换生成另一个RDD的操作不是马上执行，需要等到有Action操作的时候才会真正触发运算。 Action行动算子：这类算子会触发SparkContext提交Job作业。Action算子会触发Spark提交作业（Job），并将数据输出Spark系统。 第1关：Transformation - map 任务描述
Python库 | dagster_spark-0.7.4rc0-py3-none-any.whl
03-17
2. 无缝集成Spark与Dagster：在Dagster的数据管道中直接使用Spark算子，实现复杂的数据处理逻辑。 3. 监控和调试：利用Dagster的监控界面和日志记录功能，查看Spark作业的运行状态，方便问题定位和优化。 4. 可重复...
spark_tutorial:spark算子使用例子, spark RDD的算子挺多，有时候如何灵活的使用，该如何用一下子想不起来，这一段时间将spark的算子如何使用的例子给记录了下来，下面是spark RDD 的一些常用算子的使用 这些算子包括有java的，也有scala的语言(博客中才有)，由于精力有限，暂时没有python的，以后有空再加上吧
05-01
spark RDD的算子挺多，有时候如何灵活的使用，该如何用一下子想不起来，这一段时间将spark的算子如何使用的例子给记录了下来，下面是spark RDD 的一些常用算子的使用这些算子包括有java的，也有scala的语言，由于...
spark-sql数据.rar
08-21
Spark SQL提供了丰富的内置函数和算子，可用于数据清洗、转换和聚合。例如，`filter`用于筛选满足条件的行，`groupBy`和`agg`用于分组和聚合操作，`join`用于合并多个DataFrame，`window`函数用于窗口操作等。此外...
spark面试资料
10-16
#### 二、Spark中常用算子的区别 - **map**: 适用于每一个数据项应用函数并返回新的RDD。属于转换算子。 - **foreach**: 遍历每一个数据项并应用函数，但不返回任何结果。属于行动算子。 - **mapPartitions**: 对每...
Python库 | dagster-pyspark-0.12.0rc0.tar.gz
03-02
PySpark是Apache Spark的Python接口，允许用户用Python编写Spark应用程序。Spark作为一个分布式计算框架，以其高效、易用和多功能而受到广大数据科学家和工程师的青睐。dagster-pyspark则进一步提升了PySpark在数据...
spark官方文档.docx
12-05
Apache Spark 是一个高性能、通用的集群计算框架，其核心特性在于提供Java、Scala、Python和R的高级API，以及一个优化的图计算引擎。Spark不仅仅是一个基础计算平台，它还包括了一系列高级工具，如Spark SQL用于SQL...
工信部spark初级考试参考题目
05-23
7. Spark 为 Python 开发者提供的 API 是 pyspark。 8. 与 Spark 环境相关的配置文件是 spark-env.sh。 9. 与 Spark 日志相关的配置文件是 log4j.properties。 10. 与 Spark 集群节点相关的配置文件是 slaves。 ...
初识Spark入门
08-25
Spark的特点包括速度快、内存计算速度比mr快100倍以上、磁盘计算速度比mr快10倍以上、易于使用、提供了java、scala、python、R语言的api接口、一站式解决方案等。Spark可以运行在任意平台上，如yarn、Mesos、...
spark+openfire二次开发（三）
05-28
当我们进行二次开发时，可能需要对Spark进行扩展，例如自定义数据源、开发新的算子或优化现有算法。这通常涉及对Spark的源码进行阅读和理解，以便于定位和修改关键部分。同时，对于Openfire，我们可能需要定制插件来...
Spark常见的Transformation算子（一）
大数据进阶之路
01-13 430
Spark常见的Transformation算子（一） parallelize 将一个存在的集合，转换成一个RDD /** Distribute a local Scala collection to form an RDD. * * @note Parallelize acts lazily. If `seq` is a mutable collection and is altered a...
Spark算子：transformation之map、flatMap和distinct
csmnjk的专栏
09-20 1181
1、map 将RDD中的每个元素通过map中的函数映射为一个新的元素，并返回一个新类型的RDD。输入时的分区数与输出时的分区数保持一致。 //HDFS上的txt文件 hadoop fs -cat /tmp/1.txt hello world hello spark hello hive //读取HDFS文件到RDD scala> var data = sc.textFile("/t...
Spark算子 - JAVA版本
Junds0的博客
12-05 1277
任务描述 本关任务：使用 Spark 的map算子按照相关需求完成转换操作。相关知识 为了完成本关任务，你需要掌握：如何使用map算子。map 将原来RDD的每个数据项通过map中的用户自定义函数f映射转变为一个新的元素。图中每个方框表示一个RDD分区，左侧的分区经过自定义函数f:T->U映射为右侧的新RDD分区。但是，实际只有等到Action算子触发后，这个f函数才会和其他函数在一个Stage中对数据进行运算。map 案例 List list = Arrays.asList(1, 2, 3, 4, 5,
Spark常用Transformations算子(一)
zhang__rong的博客
03-08 182
介绍以下Transformations算子： map flatMap mapPartitions mapPartitionsWithIndex filter sample union intersection sortBy sortByKey groupByKey reduceByKey distinct coalesce repartition (1) map、mapPartitions、ma...
Spark Combinkey算子python实现二次排序
06-08
在 Spark 中，可以使用 `groupByKey` 和 `sortBy` 算子来实现二次排序。具体的 Python 代码实现如下： ```python rdd = sc.parallelize([(1, 2, 3), (2, 3, 4), (1, 4, 5), (2, 1, 6)]) # 第一次排序，按照第一个元素进行排序 sorted_rdd = rdd.sortBy(lambda x: x[0]) # 第二次排序，按照第二个元素进行排序 result = sorted_rdd.groupByKey().flatMap(lambda x: sorted(x[1], key=lambda y: y[1])) ``` 首先，将数据转化为一个 RDD。然后，使用 `sortBy` 算子按照第一个元素进行排序，得到一个排序后的 RDD。接着，使用 `groupByKey` 算子将相同的第一个元素放在同一个 reduce 中，然后使用 `flatMap` 算子将每个 reduce 中的数据按照第二个元素进行排序。最终得到的 `result` 是一个按照第一个元素和第二个元素进行排序的 RDD。 需要注意的是，在实际的应用中，可能需要对数据进行序列化和反序列化，以便在不同的节点之间传输数据。另外，对于大规模的数据集，可能需要使用分布式文件系统来进行存储和管理数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值