Spark算子 - Python

于 2023-11-18 09:50:55 发布
阅读量205 收藏
点赞数 5
分类专栏： python 文章标签： spark python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62600503/article/details/134474534
版权

第1关：Transformation - map

# -*- coding: UTF-8 -*-
from pyspark import SparkContext
 
if __name__ == "__main__":
    #********** Begin **********#
 
    # 1.初始化 SparkContext，该对象是 Spark 程序的入口
    sc = SparkContext("local","Simple App")
    # 2.创建一个1到5的列表List
    List = [1,2,3,4,5]
    # 3.通过 SparkContext 并行化创建 rdd
    rdd = sc.parallelize(List)
    # 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

# -*- coding: UTF-8 -*-
from pyspark import SparkContext
 
#********** Begin **********#
def f(iterator):
    list = []
    for x in iterator:
        list.append((x,len(x)))
    return list
#********** End **********#
 
if __name__ == "__main__":
    #********** Begin **********#
    
    # 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

# -*- 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

# -*- 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

# -*- 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 算子完成以上需求
    a = rdd.distinct()

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

    # 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 算子完成以上需求
    a = rdd.sortBy(lambda x:x)

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

    # 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 算子完成以上需求
    a = rdd.sortByKey()

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

    # 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 算子完成以上需求
    a = rdd.mapValues(lambda x:x*x if x%2==0 else x*x*x)

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

    # 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 算子完成以上需求
    a = rdd.reduceByKey(lambda x,y:x+y)

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

    # 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 **********#

垫脚摸太阳
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spark2-python
03-30
使用Python3的Apache Spark2编程
Spark-Programming-In-Python:Apache Spark 3-适用于初学者的Python Spark编程
05-03
Apache Spark 3-适用于初学者的Python Spark编程 这是与Apache Spark 3相关的所有材料的中央存储库-适用于初学者的Python中的Spark编程课程由Prashant Pandey撰写。 您可以在获得完整的课程 描述 我正在创建Apache Spark 3-适用于初学者的Python Spark编程课程，以帮助您了解Spark编程并将这些知识应用于构建数据工程解决方案。 本课程以示例为导向，并遵循类似工作会议的方法。 我们将采用实时编码方法，并在此过程中解释所有需要的概念。 谁应该选这门课程？ 我为愿意使用Apache Spark开发数据工程管道和应用程序的软件工程师设计了本课程。 我还将为负责设计和构建组织以数据为中心的基础架构的数据架构师和数据工程师创建本课程。 另一类人是不直接使用Spark实施的经理和架构师。 尽管如此，他们仍与在底层实施Apa
Transformation的map使用
weixin_39868387的博客
07-03 685
上篇：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 915
第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 1581
Spark算子 - Python
常用transformation介绍
小江专栏
07-09 661
map map：将RDD中的每个元素传入自定义函数，获取一个新的元素，然后用新的元素组成新的RDD。 案例：将集合中每一个元素都乘以2 java: // 构造集合 List numbers = Arrays.asList(1, 2, 3, 4, 5); // 并行化集合，创建初始RDD JavaRDD numberRDD = sc.parallelize(numbers); // 使用
Spark常见的Transformation算子（一）
大数据进阶之路
01-13 421
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...
Java Spark算子：sample
01-07
import org.apache.spark.... * sample(withReplacement,fraction,seed) 算子 * 对RDD中的数据进行随机采样，会有误差。 * 第一个参数：boolean类型，表示产生的样本是否可以重复：false不重复，也就是不放回的取；t
25个经典Spark算子的JAVA实现
08-16
1、25个经典Spark算子的JAVA实现。2、含有详细的注释。3、全部通过junit测试。
Apache-Spark-with-Python
02-25
Apache-Spark-with-Python 记住的命令 ＃安装 Java版本 python --version cd spark_home（无空格） bin \ pyspark（检查spark是否已成功安装） spark.version-确定版本-最后一行中的messgae Exit（）-从pyspark ...
Spark算子：transformation之map、flatMap和distinct
csmnjk的专栏
09-20 1148
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算子 - Python （一）
weixin_44686879的博客
10-22 7205
一、理论基础 Spark的算子可分为： Transformation变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。Transformation操作是延迟计算的，也就是说从一个RDD转换生成另一个RDD的操作不是马上执行，需要等到有Action操作的时候才会真正触发运算。 Action行动算子：这类算子会触发SparkContext提交Job作业。Action算子会触发Spark提交作业（Job），并将数据输出Spark系统。 第1关：Transformation - map 任务描述
Spark算子 - JAVA版本
Junds0的博客
12-05 1160
任务描述 本关任务：使用 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 177
介绍以下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 2696
仅供交流学习使用！ 第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 2630
Ma(func) 返回一个新的分布式数据集，该数据集由每一个输入元素经过func函数转换后组成。 由上可以看出，每一个分片中每一个元素都要经过f函数，将原来元素转成新元素u。 V1，V2，V3组成一个集合，经过flatMap之后就会将原来的几个集合合并成一个集合，产生新的RDD。 它会以整个分区为输入函数，也就是说这个函数是作用于整个分区的。应用在连接数据库， 使用mapParti
Spark Transformation —— map算子
搬砖小工053
07-22 1544
特点 在已有的RDD上创建一个新的RDD 延迟执行（lazy）, Transformation 的时候不执行，在促发action的时候执行。 map(func) 函数功能说明返回一个新的分布式数据集，由每个原元素经过func函数转换后组成。新的分布式数据集和原数据集的形式是一样的。 将一个RDD中的每个数据项，通过map中的函数映射变为一个新的元素。输入分区与输出分区一对一，即：有多少个输入分区
spark算子--transformation篇
zhaolimin6666的专栏
02-22 639
spark算子分为两大种，一种是transformation算子，另一种是action算子。其实细分的话transformation算子又可以细分为value型和k-v型，个人感觉没必要，也就不细化了，省得把大家搞晕。 transformation又叫转换算子，它从一个RDD到另一个RDD是延迟执行的，不会马上触发作业的提交，只有在后续遇到某个action算子时才执...
【Spark Java API】Transformation(1)—mapPartitions、mapPartitionsWithIndex
小飞侠的专栏
08-19 1142
spark java api...
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)]) # 第一次排序，按照第一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

垫脚摸太阳

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

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

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

打赏作者

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

抵扣说明：

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

余额充值