Spark算子 - Python （一）

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

一、理论基础

Spark的算子可分为：

Transformation变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。Transformation操作是延迟计算的，也就是说从一个RDD转换生成另一个RDD的操作不是马上执行，需要等到有Action操作的时候才会真正触发运算。

Action行动算子：这类算子会触发SparkContext提交Job作业。Action算子会触发Spark提交作业（Job），并将数据输出Spark系统。

第1关：Transformation - map

任务描述

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

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

将原来RDD的每个数据项通过map中的用户自定义函数 f 映射转变为一个新的元素。

图中每个方框表示一个RDD 分区，左侧的分区经过自定义函数 f:T->U 映射为右侧的新 RDD 分区。但是，实际只有等到 Action 算子触发后，这个 f 函数才会和其他函数在一个 Stage 中对数据进行运算。
map 案例

    sc = SparkContext("local", "Simple App")
    data = [1,2,3,4,5,6]
    rdd = sc.parallelize(data)
    print(rdd.collect())
    rdd_map = rdd.map(lambda x: x * 2)
    print(rdd_map.collect())

输出：

[1, 2, 3, 4, 5, 6]
[2, 4, 6, 8, 10, 12]

说明：rdd1 的元素（ 1 , 2 , 3 , 4 , 5 , 6 ）经过 map 算子( x -> x*2 )转换成了 rdd2 ( 2 , 4 , 6 , 8 , 10 )。
编程要求

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

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

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

测试说明

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

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

代码

from pyspark import SparkContext

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

第2关：Transformation - mapPartitions任务描述

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

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

mapPartitions函数获取到每个分区的迭代器，在函数中通过这个分区整体的迭 代器对整个分区的元素进行操作。

图中每个方框表示一个RDD分区，左侧的分区经过自定义函数 f:T->U 映射为右侧的新RDD分区。
mapPartitions 与 map

map：遍历算子，可以遍历RDD中每一个元素，遍历的单位是每条记录。

mapPartitions：遍历算子，可以改变RDD格式，会提高RDD并行度，遍历单位是Partition，也就是在遍历之前它会将一个Partition的数据加载到内存中。

那么问题来了，用上面的两个算子遍历一个RDD谁的效率高？
mapPartitions算子效率高。
mapPartitions 案例

def f(iterator):
    list = []
    for x in iterator:
        list.append(x*2)
    return list
if __name__ == "__main__":
    sc = SparkContext("local", "Simple App")
    data = [1,2,3,4,5,6]
    rdd = sc.parallelize(data)
    print(rdd.collect())
    partitions = rdd.mapPartitions(f)
    print(partitions.collect())

输出：

[1, 2, 3, 4, 5, 6]
[2, 4, 6, 8, 10, 12]

mapPartitions()：传入的参数是rdd的 iterator（元素迭代器），返回也是一个iterator（迭代器）。
编程要求

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

需求：使用 mapPartitions 算子，将 rdd 的数据 (“dog”, “salmon”, “salmon”, “rat”, “elephant”) 按照下面的规则进行转换操作，规则如下:

将字符串与该字符串的长度组合成一个元组，例如：

    dog  -->  (dog,3)
    salmon   -->  (salmon,6)

测试说明

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

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

from pyspark import SparkContext

#********** Begin **********#
def f(iterator):
    list = []
    for x in iterator:
        list.append((x, len(x)))
    return list


#********** End **********#

if __name__ == "__main__":
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local", "Simple App")
    # 2. 一个内容为（"dog", "salmon", "salmon", "rat", "elephant"）的列表List
    data = ["dog", "salmon", "salmon", "rat", "elephant"]
    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(data)
    # 4.使用rdd.collect() 收集 rdd 的元素。
    print(rdd.collect())
    """
    使用 mapPartitions 算子，将 rdd 的数据 ("dog", "salmon", "salmon", "rat", "elephant") 按照下面的规则进行转换操作，规则如下:
    需求：
        将字符串与该字符串的长度组合成一个元组，例如：
        dog  -->  (dog,3)
        salmon   -->  (salmon,6)
    """
    # 5.使用 mapPartitions 算子完成以上需求
    partitions = rdd.mapPartitions(f)
    # 6.使用rdd.collect() 收集完成 mapPartitions 转换的元素
    print(partitions.collect())
    # 7.停止 SparkContext
    sc.stop()

    #********** End **********#

第3关：Transformation - filter

100

任务要求
参考答案
评论4

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

任务描述

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

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

filter 函数功能是对元素进行过滤，对每个元素应用f函数，返 回值为 true的元素在RDD中保留，返回值为false的元素将被过滤掉。内部实现相当于生成。

FilteredRDD(this，sc.clean(f))

下面代码为函数的本质实现：

   def filter(self, f):
        """
        Return a new RDD containing only the elements that satisfy a predicate.
        >>> rdd = sc.parallelize([1, 2, 3, 4, 5])
        >>> rdd.filter(lambda x: x % 2 == 0).collect()
        [2, 4]
        """
        def func(iterator):
            return filter(fail_on_stopiteration(f), iterator)
        return self.mapPartitions(func, True)

上图中每个方框代表一个 RDD 分区， T 可以是任意的类型。通过用户自定义的过滤函数 f，对每个数据项操作，将满足条件、返回结果为 true 的数据项保留。例如，过滤掉 V2 和 V3 保留了 V1，为区分命名为 V’1。
filter 案例

    sc = SparkContext("local", "Simple App")
    data = [1,2,3,4,5,6]
    rdd = sc.parallelize(data)
    print(rdd.collect())
    rdd_filter = rdd.filter(lambda x: x>2)
    print(rdd_filter.collect())

输出：

[1, 2, 3, 4, 5, 6]
[3, 4, 5, 6]

说明：rdd1( [ 1 , 2 , 3 , 4 , 5 , 6 ] ) 经过 filter 算子转换成 rdd2( [ 3 ,4 , 5 , 6 ] )。
编程要求

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

需求1：使用 filter 算子，将 rdd 中的数据 (1, 2, 3, 4, 5, 6, 7, 8) 按照以下规则进行过滤，规则如下:

过滤掉rdd中的所有奇数。

测试说明

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

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

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

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

第4关：Transformation - flatMap

100

任务要求
参考答案
评论4

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

任务描述

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

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

将原来RDD中的每个元素通过函数f转换为新的元素，并将生成的RDD中每个集合的元素合并为一个集合，内部创建：

FlatMappedRDD(this，sc.clean(f))

上图表示RDD的一个分区，进行flatMap函数操作，flatMap中传入的函数为f:T->U，T和U可以是任意的数据类型。将分区中的数据通过用户自定义函数f转换为新的数据。外部大方框可以认为是一个RDD分区，小方框代表一个集合。V1、V2、V3在一个集合作为RDD的一个数据项，可能存储为数组或其他容器，转换为V’1、V’2、V’3后，将原来的数组或容器结合拆散，拆散的数据形成RDD中的数据项。
flatMap 案例

    sc = SparkContext("local", "Simple App")
    data = [["m"], ["a", "n"]]
    rdd = sc.parallelize(data)
    print(rdd.collect())
    flat_map = rdd.flatMap(lambda x: x)
    print(flat_map.collect())

输出：

[['m'], ['a', 'n']]
['m', 'a', 'n']

flatMap：将两个集合转换成一个集合
编程要求

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

需求：使用 flatMap 算子，将rdd的数据 ([1, 2, 3], [4, 5, 6], [7, 8, 9]) 按照下面的规则进行转换操作，规则如下:

合并RDD的元素，例如：

    ([1,2,3],[4,5,6])  -->  (1,2,3,4,5,6)
    ([2,3],[4,5],[6])  -->  (1,2,3,4,5,6)

测试说明

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

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

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

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

第5关：Transformation - distinct

100

任务要求
参考答案
评论4

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

任务描述

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

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

distinct 将 RDD 中的元素进行去重操作。

上图中的每个方框代表一个 RDD 分区，通过 distinct 函数，将数据去重。 例如，重复数据 V1、 V1 去重后只保留一份 V1 。
distinct 案例

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

输出：

['python', 'python', 'python', 'java', 'java']
['python', 'java']

编程要求

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

需求：使用 distinct 算子，将 rdd 中的数据进行去重。
测试说明

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

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

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

if __name__ == "__main__":
   #********** Begin **********#
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local", "Simple App")
    # 2.创建一个内容为（1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1）的列表List
    data = [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(data)
    # 4.使用rdd.collect() 收集 rdd 的元素
    print(rdd.collect())
    """
       使用 distinct 算子，将 rdd 的数据 (1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1) 按照下面的规则进行转换操作，规则如下:
       需求：
           元素去重，例如：
                        1,2,3,3,2,1  --> 1,2,3
                        1,1,1,1,     --> 1
       """
    # 5.使用 distinct 算子完成以上需求
    distinctResult = rdd.distinct()
    # 6.使用rdd.collect() 收集完成 distinct 转换的元素
    print(distinctResult.collect())
    # 7.停止 SparkContext
    sc.stop()
    #********** End **********#
如是Rushy
关注
  • 11
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark算子-Python
m0_52680439的博客
11-12 228
1.map：将原来RDD的每个数据项通过map中的用户自定义函数f映射转变为一个新的元素，遍历单位是每条记录。2.mapPartitions：获取到每个分区的迭代器，在函数中通过这个分区整体的迭代器对整个分区的元素进行操作，遍历单位是Partition。3.filter：对元素进行过滤，对每个元素应用f函数，返 回值为true的元素在RDD中保留，返回值为false的元素将被过滤掉。4.flatMap：将原来RDD中的每个元素通过函数f转换为新的元素，并将生成的RDD中每个集合的元素合并为一个集合。
Spark之Transformation和Action
微信搜：import_bigdata，大数据领域硬核原创作者
04-13 291
福利部分： 《大数据成神之路》大纲 大数据成神之路 《几百TJava和大数据资源下载》 资源下载 Transformation算子 基本的初始化 static SparkConf conf = null; static JavaSparkContext sc = null; static { conf = new SparkConf(); conf.setMast...
头歌平台Spark分类分析小节测试（8.2小节测试）
最新发布
MinL1ghT的博客
06-12 244
打开右侧代码文件窗口，在至区域补充代码，完成任务。读取文件中的内容，使用二项逻辑斯蒂回归进行二分类分析，过滤类。
头歌作业答案
Zeroist0的博客
11-27 2626
本关任务：根据编程要求，完成任务。
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
educoder大数据作业答案
Zeroist0的博客
11-20 4412
平台将对你编写的代码进行评测，如果与预期结果一致，则通关，否则测试失败。平台将对你编写的代码进行评测，如果与预期结果一致，则通关，否则测试失败。平台将对你编写的代码进行评测，如果与预期结果一致，则通关，否则测试失败。平台将对你编写的代码进行评测，如果与预期结果一致，则通关，否则测试失败。平台将对你编写的代码进行评测，如果与预期结果一致，则通关，否则测试失败。平台将对你编写的代码进行评测，如果与预期结果一致，则通关，否则测试失败。平台将对你编写的代码进行评测，如果与预期结果一致，则通关，否则测试失败。
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
3. **Stage的创建**: 从最后一个算子开始向前追溯，直到遇到宽依赖算子，这一系列算子将形成一个Stage。然后继续向前追溯，重复上述过程，直到处理完所有的算子。 **总结**: Stage的划分对于优化Spark作业的执行...
Python库 | dagster-pyspark-0.12.0rc0.tar.gz
03-02
《Python库：深入理解dagster-pyspark-0.12.0rc0》 Python是一种广泛应用于数据处理、科学计算、机器学习等...对于那些需要处理大规模数据，并且希望在Python环境中使用Spark的开发者来说，这是一个不可多得的选择。
Spark算子 - Python（头歌）
python一生之敌的博客
10-15 1898
Spark算子 - Python
Spark算子：transformation之mapPartitions、mapPartitionsWithIndex
csmnjk的专栏
09-20 505
1、mapPartitions： def mapPartitions[U](f: (Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false)(implicit arg0: ClassTag[U]): RDD[U] 该函数类似于map，只不过映射函数的参数是RDD每个分区的迭代器。若在映射的过程中需要频繁地创建...
Python初体验——Hello World
pro_daily的博客
09-02 7805
Python作业
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 Transformation —— mapPartitions
搬砖小工053
07-22 1014
原理def mapPartitions[U](f: (Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false)(implicit arg0: ClassTag[U]): RDD[U] 该函数和map函数类似，只不过映射函数的参数由RDD中的每一个元素变成了RDD中每一个分区的迭代器。如果在映射的过程中需要频繁创建额外
小节测验
Junds0的博客
12-19 1198
打开右侧代码文件窗口，在 Begin 至 End 区域补充代码，完成任务。打开右侧代码文件窗口，在 Begin 至 End 区域补充代码，完成任务。打开右侧代码文件窗口，在 Begin 至 End 区域补充代码，完成任务。打开右侧代码文件窗口，在 Begin 至 End 区域补充代码，完成任务。打开右侧代码文件窗口，在 Begin 至 End 区域补充代码，完成任务。打开右侧代码文件窗口，在 Begin 至 End 区域补充代码，完成任务。
Spark面试题及其答案
热门推荐
时间(实践)是检验真理的唯一标准
07-24 3万+
一、简答题 1.Spark master使用zookeeper进行HA的，有哪些元数据保存在Zookeeper？ 答：spark通过这个参数spark.deploy.zookeeper.dir指定master元数据在zookeeper中保存的位置，包括Worker，Driver和Application以及Executors。standby节点要从zk中，获得元数据信息，恢复集群运行状态，才能对外...
数据挖掘与机器学习：数据挖掘算法原理与实践：数据预处理
Shining0596_Limcy
11-22 4106
第一关本关任务：利用sklearn对数据进行标准化。为了完成本关任务，你需要掌握：1.为什么要进行标准化，2.Z-score标准化，3.Min-max标准化，4.MaxAbs标准化。第二关本关任务：利用sklearn对数据进行非线性转换。为了完成本关任务，你需要掌握：1.为什么要非线性转换，2.映射到均匀分布，3.映射到高斯分布。第三关本关任务：利用sklearn对数据进行归一化。第四关、本关任务：利用sklearn对标签进行OneHot编码。第五关、第六关。
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、付费专栏及课程。

余额充值