Spark算子-Python

最新推荐文章于 2024-01-08 10:56:07 发布
最新推荐文章于 2024-01-08 10:56:07 发布
阅读量236 收藏 3
点赞数
文章标签： spark 大数据 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52680439/article/details/134357029
版权

知识点

1.map：将原来RDD的每个数据项通过map中的用户自定义函数 f 映射转变为一个新的元素，遍历单位是每条记录。

2.mapPartitions：获取到每个分区的迭代器，在函数中通过这个分区整体的迭代器对整个分区的元素进行操作，遍历单位是Partition。

3.filter：对元素进行过滤，对每个元素应用f函数，返 回值为 true的元素在RDD中保留，返回值为false的元素将被过滤掉。

4.flatMap：将原来RDD中的每个元素通过函数f转换为新的元素，并将生成的RDD中每个集合的元素合并为一个集合。flatMap中传入的函数为f:T->U，T和U可以是任意的数据类型。将分区中的数据通过用户自定义函数f转换为新的数据。

5.distinct：对RDD中的元素进行去重操作。

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

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

7.sortByKey：与sortBy相同

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

9.reduceByKey：将两个值合并成一个值。

10.Action常用算子

（1）count：返回RDD的元素个数；

（2）first：返回RDD的第一个元素；

（3）take(n)：返回一个由数据集的前n个元素组成的数组；

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

（5）collect：以数组形式返回数据集中的所有元素。

第1关：Transformation-map

编程要求

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

  • 偶数转换成该数的平方；
  • 奇数转换成该数的立方。
# -*- coding: UTF-8 -*-
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**2 if x % 2 == 0 else x**3)

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

    # 7.停止 SparkContext
    sc.stop()

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

第2关：Transformation-mapPartitions

编程要求

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

  • 将字符串与该字符串的长度组合成一个元组
# -*- coding: UTF-8 -*-
from pyspark import SparkContext

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


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

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

    # 7.停止 SparkContext
    sc.stop()

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

第3关：Transformation-filter

编程要求

使用 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 算子完成以上需求
    new_data=rdd.filter(lambda x:x%2==0)

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

    # 7.停止 SparkContext
    sc.stop()

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

第4关：Transformation-flatMap

编程要求

使用 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

编程要求

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

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

    # 7.停止 SparkContext
    sc.stop()

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

第6关：Transformation-sortBy

编程要求

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

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

    # 7.停止 SparkContext
    sc.stop()

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

第7关：Transformation-sortByKey

编程要求

使用 sortByKey 算子，将 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 算子完成以上需求
    key = rdd.sortByKey()

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

    # 7.停止 SparkContext
    sc.stop()

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

第8关：Transformation-mapValues

编程要求

使用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**2 if x%2==0 else x**3)

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

    # 7.停止 SparkContext
    sc.stop()

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

第9关：Transformation-reduceByKey

编程要求

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

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

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

    # 7.停止 SparkContext
    sc.stop()

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

第10关：Actions-常用算子

编程要求

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

咖啡不提神
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spark算子--Scala版本
Junds0的博客
04-15 622
第1关：转换算子之map和distinct算子 本关任务：输出每个元素及其长度并去重。 import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} object EduCoder1 { def main(args: Array[String]): Unit = { val conf =new SparkConf().setAppName("educoder").setMaster("loc
Spark算子--------coalesce、repartition
a18295764050的博客
08-05 520
RDD的重分区
pyspark里mapPartitions的用法
攻城狮Kevin
07-19 2825
111
Spark (Python版) 学习笔记（二）
u013567842的博客
04-05 449
import sys from operator import addfrom pyspark import SparkContextsc = SparkContext(appName="PythonWordCount")#1. map(func) 将func函数作用到数据集的每个元素，生成一个新的分布式的数据集并返回 a = sc.parallelize(('a', 'b', 'c')) prin
Spark算子 - Python（头歌）
python一生之敌的博客
10-15 1907
Spark算子 - Python
SparkRdd算子练习
weixin_57405709的博客
08-10 822
练习一： valrdd=sc.parallelize(List("dog","an","cat","an","cat")) 第一步：通过获取rdd中每个元素的长度创建新的rdd1 第二步：通过zip把rdd1和rdd组合创建rdd2 第三步：去重 第四步：输出结果 val rdd = sc.parallelize(List("dog","an","cat","an","cat")) //第一步：通过获取rdd中每个元素的长度创建新的rdd1 val rdd1 = rdd.map(_....
[PySpark学习]RDD的重要算子
最新发布
alie_123的博客
01-08 955
1、 map和foreach算子都有对应的分区算子，分别是mapPartitions和foreachPartition2、 分区算子适用于有反复消耗资源的操作，例如：文件的打开和关闭、数据库的连接和关闭等，能够减少操作的次数。3、 如果没有反复消耗资源的操作，调用两类算子，效果一样。1、 这两个算子都是用来改变RDD的分区数。2、 repartition 既能够增大RDD分区数，也能够减小RDD分区数。但是都会导致发生Shuffle过程。
Spark算子--Scala版本(头歌)
m0_53510670的博客
06-14 3450
第1关转换算子之map和distinct算子 代码如下： importorg.apache.spark.rdd.RDD importorg.apache.spark.{SparkConf,SparkContext} objectEduCoder1{ defmain(args:Array[String]):Unit={ valconf=newSparkConf().setAppName("educoder1").setMaster...
python使用spark_apache spark - 在python中导入pyspark
weixin_39859909的博客
11-23 507
apache spark - 在python中导入pyspark这是另一个从未回答过的论坛上的别人问题的副本，所以我想我会在这里重新提问，因为我有同样的问题。 （见[http://geekple.com/blogs/feeds/Xgzu7/posts/351703064084736)]我在我的机器上正确安装了Spark，并且当使用./bin/pyspark作为我的python解释器时，能够使用p...
CC00021.spark——|Hadoop&Spark.V09|——|Spark.v09|sparkcore|算子综合案例&wordcount-Java|
yanqi_vip
04-12 210
一、算子综合案例wordcount-java ### --- WordCount - java ~~~ Spark提供了：Scala、Java、Python、R语言的API；对 Scala 和 Java 语言的支持最好； ### --- 源码地址说明 ~~~ 地址：https://spark.apache.org/docs/latest/rdd-programm...
spark python算子讲解
weixin_30258901的博客
03-10 308
1：spark的算子分类 Transformation 称为转换，是一种延迟加载的算法，会记录元数据信息，任务触发action时开始执行 Action 称为动作 出发就执行 sc.textFile().map map是transformation .filter transformation ...
PySpark 基础之 Transformation算子和Action算子
不忘初欣丶的博客
04-05 900
spark算子，常用的transformation算子和action算子
Pyspark: RDD及其常用算子
读万卷书 行万里路
04-25 3771
Spark提供了一种对数据的核心抽象，称为弹性分布式数据集(Resilient Distributed Dataset, RDD)。这个数据集的全部或部分可以缓存在内存中，并且可以在多次计算时重用。RDD其实就是一个分布在多个节点上的数据集合(一个数据集存储在不同的节点上，每个节点存储数据集的一部分)。......
mapPartitions--Transformation类算子
一夜飘零
08-29 7659
代码示例 mapPartitionsWithIndex–Transformation类算子 代码示例
转载（RDD转换算子大全）
qq_42448606的博客
09-23 437
RDD 中的所有转换都是延迟加载的，也就是说，它们并不会直接计算结果。相反的，它们只是记住这些应用到基础数据集（例如一个文件）上的转换动作。只有当发生一个要求返回结果给 Driver 的动作时，这些转换才会真正运行。这种设计让 Spark 更加有效率地运行。 常用的Transformation map，filter，flatMap，mapPartitions，mapPartitonsWithIndex，sampl...
二、Spark算子：基本RDD转换操作(1)–map、flatMap、distinct、coalesce、repartition、union、intersection、subtract
xuehuagongzi000的博客
04-20 1092
1、数据 hadoop fs -cat /tmp/1234/1.txt hello world hello spark hello hive //读取HDFS文件到RDD scala> var data = sc.textFile("/tmp/1234/1.txt") data: org.apache.spark.rdd.RDD[String] = MapPartitio...
SparkRDD算子练习
weixin_55983492的博客
08-10 2618
练习一： scala> val list = List(("zhangsan",85),("zhangsan",90),("zhangsan",76),("lisi",80),("lisi",75),("lisi",89)) scala> val rdd = sc.parallelize(list) //将相同key的值聚合到一起 scala> val rdd1 = rdd.reduceByKey((a,b)=>a+b) //查看结果 scala> rdd1.collect
Spark—常用的RDD转换算子
To_9426464的博客
02-08 631
Spark—常用的RDD转换算子 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，
Spark算子：RDD基本转换操作(5)–mapPartitions、mapPartitionsWithIndex
houzhizhen的专栏
01-24 2378
关键字：Spark算子、Spark RDD基本转换、mapPartitions、mapPartitionsWithIndex mapPartitions def mapPartitions[U](f: (Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false)(implicit arg0: ClassTag[U])
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)]) # 第一次排序，按照第一个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值