Spark RDD操作练习 2

最新推荐文章于 2022-01-03 07:12:00 发布
最新推荐文章于 2022-01-03 07:12:00 发布
阅读量225 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wint_ing/article/details/81518261
版权 
scala> 
scala> def func(index: Int, iter: Iterator[(Int)]): Iterator[String] = {
     | iter.toList.map(x => "[partId: " + index + ", val: " + x + "]").iterator
     | }
func: (index: Int, iter: Iterator[Int])Iterator[String]

scala> z.mapPartitionsWithIndex(func).collect
res29: Array[String] = Array([partId: 0, val: 1], [partId: 0, val: 2], [partId: 0, val: 3], [partId: 1, val: 4], [partId: 1, val: 5], [partId: 1, val: 6])

scala> z.aggregate(0)(math.max(_, _), _ + _)
res30: Int = 9

scala> z.aggregate(5)(math.max(_, _), _ + _)
res31: Int = 16

scala> val z = sc.parallelize(List("a", "b", "c", "d", "e", "f"), 2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[50] at parallelize at <console>:24

scala> def func(index: Int, iter: Iterator[(String)]): Iterator[String] = {
     | iter.toList.map(x => "[partId:" + index + ",val: " + x + "]").iterator
     | }
func: (index: Int, iter: Iterator[String])Iterator[String]

scala> z.mapPartitionsWithIndex(func).collect
res35: Array[String] = Array([partId:0,val: a], [partId:0,val: b], [partId:0,val: c], [partId:1,val: d], [partId:1,val: e], [partId:1,val: f])

scala> z.aggregate("")(_+_, _+_)
res36: String = abcdef

scala> z.aggregate("x")(_+_, _+_)
res37: String = xxabcxdef

scala> val z = sc.parallelize(List("12","23", "234", "268", "98"), 2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[52] at parallelize at <console>:24

scala> z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x+y)
res38: String = 22                                                              

scala> z.mapPartitionsWithIndex(func).collect
res39: Array[String] = Array([partId:0,val: 12], [partId:0,val: 23], [partId:1,val: 234], [partId:1,val: 268], [partId:1,val: 98])

scala> z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x+y)
res41: String = 22

scala> val z = sc.parallelize(List("12","23","345","4567"), 2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[55] at parallelize at <console>:24

scala> z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x+y)
res44: String = 42

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x+ y)
res51: String = 11

scala> val z = sc.parallelize(List("12", "23", "234", ""), 2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[56] at parallelize at <console>:24

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x+y)
res53: String = 01                                                              

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x+y)
res55: String = 10

scala> 



scala> val z = sc.parallelize(List("23", "12", "", "345"), 2)
z: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[57] at parallelize at <console>:24

scala> z.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x+y)
res57: String = 11

scala> val rdd = sc.parallelize(List(("cat", 2),("cat", 5),("mouse", 4), ("cat", 12),("dog", 12),("mouse", 2)), 2)
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[58] at parallelize at <console>:24

scala> def func(index: Int, iter: Iterator[(String, Int)]): Iterator[String] ={
     | iter.toList.map(x => "[partId:" + index + ",val:" + x + "]").iterator
     | }
func: (index: Int, iter: Iterator[(String, Int)])Iterator[String]

scala> rdd.mapPartitionsWithIndex(func).collect
res59: Array[String] = Array([partId:0,val:(cat,2)], [partId:0,val:(cat,5)], [partId:0,val:(mouse,4)], [partId:1,val:(cat,12)], [partId:1,val:(dog,12)], [partId:1,val:(mouse,2)])

scala> rdd.aggregateByKey(0)(math.max(_,_), _+_).collect
res60: Array[(String, Int)] = Array((dog,12), (cat,17), (mouse,6))

scala> 

scala> 

scala> rdd.aggregateByKey(0)(math.max(_,_), _+_).collect
res62: Array[(String, Int)] = Array((dog,12), (cat,17), (mouse,6))

scala> rdd.aggregateByKey(100)(math.max(_,_), _+_).collect
res63: Array[(String, Int)] = Array((dog,100), (cat,200), (mouse,200))

scala> val x = sc.parallelize(List(1,2,3,4,5))
x: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[65] at parallelize at <console>:24

scala> val y = sc.parallelize(List(6,7,8,9,10))
y: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[66] at parallelize at <console>:24

scala> x.cartesian(y).collect
res65: Array[(Int, Int)] = Array((1,6), (1,7), (1,8), (1,9), (1,10), (2,6), (2,7), (2,8), (2,9), (2,10), (3,6), (3,7), (3,8), (3,9), (3,10), (4,6), (4,7), (4,8), (4,9), (4,10), (5,6), (5,7), (5,8), (5,9), (5,10))


scala> sc.setCheckpointDir("hdfs://mini1:9000/input")

scala> val a = sc.parallelize(1 to 4)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[69] at parallelize at <console>:24

scala> a.checkpoint

scala> a.count
res77: Long = 4                                                                 

scala> res77
res78: Long = 4

scala> 

scala> val y = sc.parallelize(1 to 10, 10)
y: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[71] at parallelize at <console>:24

scala> y.collect
res79: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> y.partitions.length
res80: Int = 10

scala> val z = y.coalesce(2, false)
z: org.apache.spark.rdd.RDD[Int] = CoalescedRDD[72] at coalesce at <console>:26

scala> z.partition
partitioner   partitions

scala> z.partitions.length
res81: Int = 2

scala> val a = sc.parallelize(List(1,2,1,3), 1)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[73] at parallelize at <console>:24

scala> val b = a.map((_, "b"))
b: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[74] at map at <console>:26

scala> val c = a.map((_, "c"))
c: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[75] at map at <console>:26

scala> b.collect
res82: Array[(Int, String)] = Array((1,b), (2,b), (1,b), (3,b))

scala> b.cogroup(c).collect
res83: Array[(Int, (Iterable[String], Iterable[String]))] = Array((1,(CompactBuffer(b, b),CompactBuffer(c, c))), (3,(CompactBuffer(b),CompactBuffer(c))), (2,(CompactBuffer(b),CompactBuffer(c))))

scala> c.collect
res84: Array[(Int, String)] = Array((1,c), (2,c), (1,c), (3,c))

scala> val d = a.map((_, "d"))
d: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[78] at map at <console>:26

scala> b.cogroup(c,d).collect
res85: Array[(Int, (Iterable[String], Iterable[String], Iterable[String]))] = Array((1,(CompactBuffer(b, b),CompactBuffer(c, c),CompactBuffer(d, d))), (3,(CompactBuffer(b),CompactBuffer(c),CompactBuffer(d))), (2,(CompactBuffer(b),CompactBuffer(c),CompactBuffer(d))))

scala> val x = sc.parallelize(List((1, "apple"), (2, "banana"), (3, "orange"), (4, "kiwi")), 2)
x: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[81] at parallelize at <console>:24

scala> val y = sc.parallelize(List((5,"computer"),(1, "laptop"),(1, "desktop"),(4, "ipad")), 2)
y: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[82] at parallelize at <console>:24

scala> x.cogroup(y).collect
res86: Array[(Int, (Iterable[String], Iterable[String]))] = Array((4,(CompactBuffer(kiwi),CompactBuffer(ipad))), (2,(CompactBuffer(banana),CompactBuffer())), (1,(CompactBuffer(apple),CompactBuffer(desktop, laptop))), (3,(CompactBuffer(orange),CompactBuffer())), (5,(CompactBuffer(),CompactBuffer(computer))))

scala> 

scala> val a = sc.parallelize(List(1,2,1,3), 1)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[85] at parallelize at <console>:24

scala> val b = a.zip(a)
b: org.apache.spark.rdd.RDD[(Int, Int)] = ZippedPartitionsRDD2[86] at zip at <console>:26

scala> b.collect
res87: Array[(Int, Int)] = Array((1,1), (2,2), (1,1), (3,3))

scala> b.collectAsMap
res88: scala.collection.Map[Int,Int] = Map(2 -> 2, 1 -> 1, 3 -> 3)

scala> 

scala> val a = sc.parallelize(List("dog", "cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
a: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[87] at parallelize at <console>:24

scala> val b = sc.parallelize(List(1,1,2,2,2,1,2,2,2), 3)
b: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[88] at parallelize at <console>:24

scala> val c = b.zip(a)
c: org.apache.spark.rdd.RDD[(Int, String)] = ZippedPartitionsRDD2[89] at zip at <console>:28

scala> c.collect
res89: Array[(Int, String)] = Array((1,dog), (1,cat), (2,gnu), (2,salmon), (2,rabbit), (1,turkey), (2,wolf), (2,bear), (2,bee))

scala> val d = c.combineByKey(List(_), (x: List[String], y:String) => y :: x, (x:List[String], y: List[String]) => x ::: y)
d: org.apache.spark.rdd.RDD[(Int, List[String])] = ShuffledRDD[90] at combineByKey at <console>:34

scala> d.collect
res90: Array[(Int, List[String])] = Array((1,List(turkey, cat, dog)), (2,List(bee, bear, wolf, gnu, rabbit, salmon)))

scala> val d = c.combineByKey(List(_), (x: List[String], y: String) => x :+ y, (x:List[String], y: List[String]) => x ::: y)
d: org.apache.spark.rdd.RDD[(Int, List[String])] = ShuffledRDD[91] at combineByKey at <console>:34

scala> d.collect
res91: Array[(Int, List[String])] = Array((1,List(dog, cat, turkey)), (2,List(wolf, bear, bee, gnu, salmon, rabbit)))

scala> val d = c.combineByKey(List(_), (x: List[String], y: String) => x :+ y, (x:List[String], y: List[String]) => x ::: y).collect
d: Array[(Int, List[String])] = Array((1,List(turkey, dog, cat)), (2,List(wolf, bear, bee, gnu, salmon, rabbit)))


scala> c
res92: org.apache.spark.rdd.RDD[(Int, String)] = ZippedPartitionsRDD2[89] at zip at <console>:28

scala> c.collect
res93: Array[(Int, String)] = Array((1,dog), (1,cat), (2,gnu), (2,salmon), (2,rabbit), (1,turkey), (2,wolf), (2,bear), (2,bee))

scala> c.partitions.length
res94: Int = 3

scala> 

scala> def func(index: Int, iter: Iterator[(Int)]) : Iterator[String] = {
     | iter.toList.map(x => "id " +index+ ",val"+ x+ "." ).iterator}
func: (index: Int, iter: Iterator[Int])Iterator[String]


scala> c.mapPartitionsWithIndex(func).collect


scala> c.partitions.length
res98: Int = 3

scala> c
res99: org.apache.spark.rdd.RDD[(Int, String)] = ZippedPartitionsRDD2[89] at zip at <console>:28

scala> c.collect
res100: Array[(Int, String)] = Array((1,dog), (1,cat), (2,gnu), (2,salmon), (2,rabbit), (1,turkey), (2,wolf), (2,bear), (2,bee))

scala> def func(index: Int, iter: Iterator[(Int)]) : Iterator[String] = {
     | iter.toList.map(x => "id " +index+ ",val"+ x._2 + "." ).iterator}

scala> 

scala> 

scala> val a = sc.parallelize(1 to 10000 , 20)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[96] at parallelize at <console>:24

scala> val b = a++a++a++a++a
b: org.apache.spark.rdd.RDD[Int] = UnionRDD[100] at $plus$plus at <console>:26

scala> b.collect
res101: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176...
scala> val b = a++a
b: org.apache.spark.rdd.RDD[Int] = UnionRDD[101] at $plus$plus at <console>:26

scala> b.collect
res102: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176...

scala> b.countApproxDistinct(0.05)
res104: Long = 9760                                                             

scala> b.countApproxDistinct(0.01)
res105: Long = 9947

scala> b.countApproxDistinct(0.001)
res106: Long = 10000
___bluesky
关注
Spark中的RDD基本操作
Mr.Phoebe的专栏
02-11 9338
Spark中的RDD基本操作 前言 RDD是spark特有的数据模型，谈到RDD就会提到什么弹性分布式数据集，什么有向无环图。这些知识点在别的地方介绍得非常多，本文就不去讲这些了。 在阅读本文时候，大家可以就把RDD当作一个数组，或者一个Scala的collection对象，这样的理解对我们学习RDD的API是非常有帮助的。 RDD的创建 Spark里的计算都是操作RDD进行，那...
利用pyspark练习sparkRDD算子的操作练习实验
qq_47844519的博客
05-02 2397
实验名称 RDD算子的操作实验 实验目的 掌握RDD算子的基本用法 实验资源 student.txt 实验环境 VMware Workstation Ubuntu 16.04 Jupyter Notebook Pyspark 实验内容 student.txt中的数据一共分为6列，每一列含义如下表所示： 班级号 姓名 年龄 性别 课程 分数 练习题目： (1) 读入studnet.txt文档，生成RDD (2) 获得年龄大于20的学生 (3) 获得性别为男的学生 (4
spark学习（RDD案例实战）
weixin_34211761的博客
03-05 154
练习0（并行化创建RDD） 先启动spark-shell 通过并行化生成rdd scala> val rdd1 = sc.parallelize(List(63,45,89,23,144,777,888)) rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console&...
【Spark】SparkRDD实操练习(一)
HR的博客
01-03 358
本篇所使用到的数据可以在此处找到点击下载. SparkRDD实操练习一 数据浏览 个字段分别是：时间戳、省份、城市、用户、广告，分割符是空格 每一条数据代表了一次点击 需求： 统计出 每一个省份 每个广告被点击数量 排行的TOP3 代码实现 object RDDTest { def main(args: Array[String]): Unit = { val spark = new SparkConf().setMaster("local[6]").setAppName("agent.
Spark学习笔记2：RDD编程
weixin_30855761的博客
09-14 187
通过一个简单的单词计数的例子来开始介绍RDD编程。 import org.apache.spark.{SparkConf, SparkContext} object word { def main(args: Array[String]): Unit = { val conf = new SparkConf().setMaster("local").setAppNam...
RDD编程
weixin_33790053的博客
12-22 94
2019独角兽企业重金招聘Python工程师标准>>> ...
spark rdd 操作详解
04-22
spark rdd相关操作详解;包括全部的操作说明和举例；
Spark RDD 练习作业（选择部分数据（可以是自拟，可以是采集的，也可以是现有的），进行多角度数据统计及分析）.zip
03-09
Spark RDD 练习作业（选择部分数据（可以是自拟，可以是采集的，也可以是现有的），进行多角度数据统计及分析，并进行数据整合及展示（尽量多的运用 Spark RDD API））.zip Spark RDD 练习作业（选择部分数据（可以...
SparkRDD编程练习
linanmengxiaoai的专栏
07-22 409
1.引子 关于多态的使用立场可以有以下理由： （1）为了消除各个类型之间的耦合关系 （2）将做什么和怎么做分离开来（与前一条的理由相关） （3）为了改善代码的结构、可读性和易维护性，使得项目更具有长远的可扩展性 面向对象的三大特性：封装、继承和多态，封装将事物的属性和行为合并隐藏在类中，继承允许将多种类型视为它自己本身的类型或者基类型对待，而多态的作用则是消除多个...
Spark RDD 练习作业（进行多角度数据统计及分析，并进行数据整合及展示（尽量多的运用 Spark RDD API）.zip
03-27
2、适用人群：主要针对计算机相关专业(如计科、信息安全、数据科学与大数据技术、人工智能、通信、物联网、数学、电子信息等)的同学或企业员工下载使用，具有较高的学习借鉴价值。 3、不仅适合小白学习实战练习，也...
Spark RDD编程
Ran's Hacking Zone
02-16 1293
0. RDD基础 RDD(Resilient Distributed Dataset)：弹性分布式数据集 Spark中的RDD其实是一个不可变的分布式对象集合，每个RDD都被分为多个分区，这些分区运行在集群上的不同节点上。 在Spark中，对数据的所有操作不外乎创建RDD、转化已有RDD以及调用RDD操作进行求值。而在这一切的背后，Spark会自动将RDD的数据分发到集群上，并将操作并行化执行。 创
Spark学习笔记(一):pySpark RDD编程
weixin_41993767的博客
02-15 499
from pyspark import SparkContext,SparkConf #spark配置信息 注意实际工程中不会用硬编码 sc = SparkContext("local", "context") ''' RDD操作有两个方面: 1.transformations: map filter groupby... 2.actions: reduce count collect....
RDD实战
kxr0502的博客
01-21 1081
第一阶段（1-3月）：会从浅入深，基于大量案例实战，深度剖析和讲解Spark，并且会包含完全从企业真实复杂业务需求中抽取出的案例实战。课程会涵盖Scala编程详解、Spark核心编程、Spark SQL和Spark       Streaming、Spark、GraphX、SparkR、Machine Learning、Spark内核以及源码剖析、性能调优、企业级案例实战等部分 第二阶段（S
Spark 核心编程（1）- Spark基本工作原理和RDD
一角残叶的博客
01-04 306
1 Spark 基本工作原理 分布式 主要基于内存（少数情况基于磁盘） 迭代式计算 1. MapReduce 分为 map 和 reduce 阶段，所以在一个 job 里处理有限 2. spark 可以很多阶段，因为是内存迭代式的计算 2 RDD Resilient Distributed Dataset,弹性分布式数据集，spark的核心抽象； RDD 在抽象上来说是一种元素集合，包含了...
Spark小课堂Week3 FirstSparkApp(RDD开发)
weixin_33716941的博客
07-24 89
Spark小课堂Week3 FirstSparkApp 问题:Java有哪些数据结构 大致有如下几种，其中List与Map是最重要的： List Map Set Array Heap Stack Queue Tree 练习：构造一个1-5的List,把他们打印出来 写法1 List<Integer> input = Arrays.asList(1, 2, 3, 4,...
spark核心编程，spark基本工作原理与RDD
weixin_43212037的博客
11-20 429
1. Spark基本工作原理 2. RDD以及其特点 3. 什么是Spark开发
sparkRDD
weixin_42487706的博客
04-11 135
基本概念 RDD（Resilient Distributed Dataset），弹性分布式数据集，是Spark数据处理的核心抽象 属性：分区列表、分区函数、RDD依赖、分片函数（只有kv格式数RDD才有，两种函数HashPatitioner和RangePartitioner，不是kv格式的RDD则是none。可选）、数据就近原则（数据在哪里就在哪个节点执行任务或最近...
Spark基础RDD练习（一）
x531280572的博客
02-19 850
spark_rdd练习 1.并行化创建RDD 通过并行化生成rdd scala&gt; var rdd1 = sc.parallelize(List(123,32,44,55,66,77,88,999)) rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at :24 查看该RDD的分...
实验十五 Spark实验：RDD综合实验
WistWill的博客
04-13 4145
实验指导： 15.1 实验目的 1． 通过Spark-shell的操作理解RDD操作； 2． 能通过RDD操作的执行理解RDD的原理； 3． 对Scala能有一定的认识。 15.2 实验要求 在实验结束时能完成max，first，distinct，foreach等api的操作。 15.3 实验原理 RDD(Resilient Distributed Datasets，弹性分布式数据...
sparkrdd算子练习使用java语言
最新发布
10-10
在Java中，你可以通过`org.apache.spark.rdd.RDD`接口来操作RDD。以下是几个基本的Spark RDD算子（transformations）的使用示例： 1. **创建RDD**: 使用`parallelize()`函数将本地列表转换为RDD，例如： ```java ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值