CTGU三峡大学Spark算子 - Python

于 2024-01-17 16:24:39 发布
阅读量424 收藏 10
点赞数 8
分类专栏： 大数据技术与应用 文章标签： spark python javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67613621/article/details/135653769
版权
本文介绍了PySpark中常用的Transformation算子（如map,mapPartitions,filter,flatMap,distinct,sortBy,sortByKey,mapValues,reduceByKey）以及Actions（如collect,count,first,take,reduce）在处理数据时的应用实例。
摘要由CSDN通过智能技术生成

文章目录

第1关 Transformation - map

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

if __name__ == "__main__":
    #********** Begin **********#

    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local","App")

    # 2.创建一个1到5的列表List
    data = [_ for _ in range(1,6)]

    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(data)

    # 4.使用rdd.collect() 收集 rdd 的元素。
    print(rdd.collect())

    """
    使用 map 算子，将 rdd 的数据 (1, 2, 3, 4, 5) 按照下面的规则进行转换操作，规则如下:
    需求：
        偶数转换成该数的平方
        奇数转换成该数的立方
    """
    # 5.使用 map 算子完成以上需求
    li = rdd.map(lambda x : x ** 3 if x % 2 == 1 else x ** 2).collect()

    # 6.使用rdd.collect() 收集完成 map 转换的元素
    print(li)

    # 7.停止 SparkContext


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

第2关 Transformation - mapPartitions

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

#********** Begin **********#



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

if __name__ == "__main__":
    #********** Begin **********#
    
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local","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 算子完成以上需求
    li = rdd.map(lambda x : (x,len(x))).collect()
    # 6.使用rdd.collect() 收集完成 mapPartitions 转换的元素
    print(li)

    # 7.停止 SparkContext
    sc.stop()

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

第3关 Transformation - filter

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

if __name__ == "__main__":
       #********** Begin **********#
       
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext('local','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 算子完成以上需求
    li = rdd.flatMap(lambda x : x).collect()
    # 6.使用rdd.collect() 收集完成 filter 转换的元素
    print(li)
    # 7.停止 SparkContext
    sc.stop()
    #********** End **********#

第4关 Transformation - flatMap

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

if __name__ == "__main__":
       #********** Begin **********#
       
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext('local','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 算子完成以上需求
    li = rdd.flatMap(lambda x : x).collect()
    # 6.使用rdd.collect() 收集完成 filter 转换的元素
    print(li)
    # 7.停止 SparkContext
    sc.stop()
    #********** End **********#

第5关 Transformation - distinct

# -*- 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 = [_ for _ in range(1,7)] + [_ for _ in range(5,0,-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 算子完成以上需求

    li = rdd.distinct().collect()

    # 6.使用rdd.collect() 收集完成 distinct 转换的元素
    print(li)

    # 7.停止 SparkContext
    sc.stop()

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

第6关 Transformation - sortBy

# -*- 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 算子完成以上需求

    li = rdd.sortBy(lambda x : x).collect()

    # 6.使用rdd.collect() 收集完成 sortBy 转换的元素
    print(li)

    # 7.停止 SparkContext
    sc.stop()

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

第7关 Transformation - sortByKey

# -*- 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 算子完成以上需求

    li = rdd.sortByKey().collect()

    # 6.使用rdd.collect() 收集完成 sortByKey 转换的元素

    print(li)

    # 7.停止 SparkContext
    sc.stop()

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

第8关 Transformation - mapValues

# -*- 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 算子完成以上需求

    li = rdd.mapValues(lambda x : x ** 3 if x % 2 else x ** 2).collect()

    # 6.使用rdd.collect() 收集完成 mapValues 转换的元素

    print(li)
    # 7.停止 SparkContext
    sc.stop()

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

第9关 Transformations - reduceByKey

# -*- 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 算子完成以上需求

    li = rdd.reduceByKey(lambda x,y : x + y).collect()

    # 6.使用rdd.collect() 收集完成 reduceByKey 转换的元素

    print(li)
    # 7.停止 SparkContext
    sc.stop()

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

第10关 Actions - 常用算子

# -*- 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 **********#
123456msk
关注
专栏目录
Spark算子 - Python（头歌）
python一生之敌的博客
10-15 2152
Spark算子 - Python
Transformation的map使用
weixin_39868387的博客
07-03 732
上篇：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 1116
第2关：Transformation - mapPartitions。第7关：Transformation - sortByKey。第8关：Transformation - mapValues。第5关：Transformation - distinct。第4关：Transformation - flatMap。第3关：Transformation - filter。第6关：Transformation - sortBy。第1关：Transformation - map。
常用transformation介绍
小江专栏
07-09 703
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 7601
一、理论基础 Spark的算子可分为： Transformation变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。Transformation操作是延迟计算的，也就是说从一个RDD转换生成另一个RDD的操作不是马上执行，需要等到有Action操作的时候才会真正触发运算。 Action行动算子：这类算子会触发SparkContext提交Job作业。Action算子会触发Spark提交作业（Job），并将数据输出Spark系统。 第1关：Transformation - map 任务描述
Spark常见的Transformation算子（一）
大数据进阶之路
01-13 446
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...
CTGU三峡大学人工智能实验八-强化学习
01-13
机器人导航 图 1是一个机器人导航问题的地图。机器人从起点Start出发，每一个时间点，它必须选择一个行动(上下左右)。在马尔可夫决策中实验中，机器人是根据环境模型中的转移矩阵 P\left(x,a,x^\prime\right) 来进行...
CTGU三峡大学软件工程实验五：面向对象的系统建模
最新发布
01-13
【医院预约挂号系统】是基于面向对象的系统建模技术设计的一个典型实例，主要用于实现便捷的医疗服务预约。...系统的主要目标是为用户提供高效、安全的预约挂号服务，同时也考虑到了支付、信用评估和系统维护等方面的...
2018-821机械原理-三峡大学考研.pdf
12-16
本次提供的资料是关于三峡大学2018年硕士研究生入学考试的专业课真题，科目代码为821，名为机械原理。考试的题目类型包括判断题、填空题、选择题、简答题、计算题和机构分析题。以下将根据各个题型详细解析知识点。 ...
2015-822机械原理-三峡大学考研.pdf
12-16
整体来看，这些知识点涵盖了机械原理的核心概念、机构运动学、动力学分析以及实际机械设计的计算方法，是三峡大学机械原理考研初试的重要内容。考生需要对这些知识点有深入的理解，并能灵活应用解决实际问题。
2019-821机械原理-三峡大学考研.pdf
12-16
本部分知识点主要围绕机械原理，特别是与三峡大学2019年机械原理研究生入学考试相关的概念和原理。考试内容涵盖了机构自由度计算、机构动力学分析、凸轮机构设计等机械设计与分析的诸多方面。 首先，考试题目的基本...
Spark算子 - Python
m0_62600503的博客
11-18 348
【代码】Spark算子 - Python。
Spark算子：transformation之map、flatMap和distinct
csmnjk的专栏
09-20 1204
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 1305
任务描述 本关任务：使用 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 212
介绍以下Transformations算子： map flatMap mapPartitions mapPartitionsWithIndex filter sample union intersection sortBy sortByKey groupByKey reduceByKey distinct coalesce repartition (1) map、mapPartitions、ma...
Spark算子 - Python （二）
weixin_44686879的博客
10-22 2864
仅供交流学习使用！ 第6关：Transformation - sortBy 100 任务要求 参考答案 评论4 任务描述 相关知识 sortBy sortBy 案例 编程要求 测试说明 任务描述 本关任务：使用 Spark 的 SortBy 算子按照相关需求完成相关操作。 相关知识 为了完成本关任务，你需要掌握：如何使用 sortBy 算子。 sortBy sortBy 函数是在 org.apache.spark.rdd.RDD 类中实现的，它的实现如下： def sortBy
Spark RDD中Transformation的map、flatMap、mapPartitions、glom详解
snail_gesture的博客
11-08 2657
Ma(func) 返回一个新的分布式数据集，该数据集由每一个输入元素经过func函数转换后组成。 由上可以看出，每一个分片中每一个元素都要经过f函数，将原来元素转成新元素u。 V1，V2，V3组成一个集合，经过flatMap之后就会将原来的几个集合合并成一个集合，产生新的RDD。 它会以整个分区为输入函数，也就是说这个函数是作用于整个分区的。应用在连接数据库， 使用mapParti
Spark Transformation —— map算子
搬砖小工053
07-22 1571
特点 在已有的RDD上创建一个新的RDD 延迟执行（lazy）, Transformation 的时候不执行，在促发action的时候执行。 map(func) 函数功能说明返回一个新的分布式数据集，由每个原元素经过func函数转换后组成。新的分布式数据集和原数据集的形式是一样的。 将一个RDD中的每个数据项，通过map中的函数映射变为一个新的元素。输入分区与输出分区一对一，即：有多少个输入分区
【Spark Java API】Transformation(1)—mapPartitions、mapPartitionsWithIndex
小飞侠的专栏
08-19 1174
spark java api...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值