Spark算子 - Python

Transformation - map

任务描述

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

相关知识

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

map

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

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

map 案例

1. sc = SparkContext("local", "Simple App")
2. data = [1,2,3,4,5,6]
3. rdd = sc.parallelize(data)
4. print(rdd.collect())
5. rdd_map = rdd.map(lambda x: x * 2)
6. 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) 按照下面的规则进行转换操作，规则如下:

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

# -*- 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 = rdd.map(lambda x: x ** 2 if x % 2 == 0 else x ** 3)

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

    print(rdd.collect())

    # 7.停止 SparkContext

    sc.stop()

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

Transformation - mapPartitions

任务描述

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

相关知识

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

mapPartitions

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

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

mapPartitions 与 map

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

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

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

mapPartitions 案例

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

输出：

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

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

编程要求

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

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

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

1. dog --> (dog,3)
2. salmon --> (salmon,6)

# -*- coding: UTF-8 -*-

from pyspark import SparkContext

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

 

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

    rdd = rdd.mapPartitions(lambda partition: [(word, len(word)) for word in partition])

 

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

    print(rdd.collect())

    # 7.停止 SparkContext

    sc.stop()

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

Transformation - filter

任务描述

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

相关知识

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

filter

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

1. FilteredRDD(this，sc.clean(f))

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

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

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

filter 案例

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

输出：

1. [1, 2, 3, 4, 5, 6]
2. [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 = rdd.filter(lambda x: x % 2 == 0)

 

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

    print(rdd.collect())

    # 7.停止 SparkContext

    sc.stop()

 

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

Transformation - flatMap

任务描述

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

相关知识

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

flatMap

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

1. 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 案例

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

输出：

1. [['m'], ['a', 'n']]
2. ['m', 'a', 'n']

flatMap：将两个集合转换成一个集合

编程要求

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

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

• 合并RDD的元素，例如：
  1. ([1,2,3],[4,5,6]) --> (1,2,3,4,5,6)
  2. ([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 算子完成以上需求

    rdd = rdd.flatMap(lambda x: x)

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

    print(rdd.collect())

    # 7.停止 SparkContext

    sc.stop()

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

Transformation - distinct

任务描述

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

相关知识

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

distinct

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

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

distinct 案例

1. sc = SparkContext("local", "Simple App")
2. data = ["python", "python", "python", "java", "java"]
3. rdd = sc.parallelize(data)
4. print(rdd.collect())
5. distinct = rdd.distinct()
6. print(distinct.collect())

输出：

1. ['python', 'python', 'python', 'java', 'java']
2. ['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 算子完成以上需求

    rdd = rdd.distinct()

 

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

    print(rdd.collect())

 

    # 7.停止 SparkContext

    sc.stop()

 

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

Transformation - sortBy

任务描述

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

相关知识

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

sortBy

sortBy 函数是在 org.apache.spark.rdd.RDD 类中实现的，它的实现如下：

1. def sortBy(self, keyfunc, ascending=True, numPartitions=None):
2. return self.keyBy(keyfunc).sortByKey(ascending, numPartitions).values()

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

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

从sortBy函数的实现可以看出，第一个参数是必须传入的，而后面的两个参数可以不传入。

sortBy 案例

1. sc = SparkContext("local", "Simple App")
2. data = [("a",1),("a",2),("c",1),("b",1)]
3. rdd = sc.parallelize(data)
4. by = rdd.sortBy(lambda x: x)
5. print(by.collect())

输出：

1. [('a', 1), ('a', 2), ('b', 1), ('c', 1)]

编程要求

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

需求：使用 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 算子完成以上需求

    rdd = rdd.sortBy(lambda x: x)

 

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

    print(rdd.collect())

 

    # 7.停止 SparkContext

    sc.stop()

 

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

Transformation - sortByKey

任务描述

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

相关知识

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

sortByKey

1. def sortByKey(self, ascending=True, numPartitions=None, keyfunc=lambda x: x):
2. if numPartitions is None:
3. numPartitions = self._defaultReducePartitions()
5. memory = self._memory_limit()
6. serializer = self._jrdd_deserializer
8. def sortPartition(iterator):
9. sort = ExternalSorter(memory * 0.9, serializer).sorted
10. return iter(sort(iterator, key=lambda kv: keyfunc(kv[0]), reverse=(not ascending)))
12. if numPartitions == 1:
13. if self.getNumPartitions() > 1:
14. self = self.coalesce(1)
15. return self.mapPartitions(sortPartition, True)
17. # first compute the boundary of each part via sampling: we want to partition
18. # the key-space into bins such that the bins have roughly the same
19. # number of (key, value) pairs falling into them
20. rddSize = self.count()
21. if not rddSize:
22. return self # empty RDD
23. maxSampleSize = numPartitions * 20.0 # constant from Spark's RangePartitioner
24. f\fraction = min(maxSampleSize / max(rddSize, 1), 1.0)
25. samples = self.sample(False, f\fraction, 1).map(lambda kv: kv[0]).collect()
26. samples = sorted(samples, key=keyfunc)
28. # we have numPartitions many parts but one of the them has
29. # an implicit boundary
30. bounds = [samples[int(len(samples) * (i + 1) / numPartitions)]
31. for i in range(0, numPartitions - 1)]
33. def rangePartitioner(k):
34. p = bisect.bisect_left(bounds, keyfunc(k))
35. if ascending:
36. return p
37. else:
38. return numPartitions - 1 - p
40. return self.partitionBy(numPartitions, rangePartitioner).mapPartitions(sortPartition, True)

说明：ascending参数是指排序（升序还是降序），默认是升序。numPartitions参数是重新分区，默认与上一个RDD保持一致。keyfunc参数是排序规则。

sortByKey 案例

1. sc = SparkContext("local", "Simple App")
2. data = [("a",1),("a",2),("c",1),("b",1)]
3. rdd = sc.parallelize(data)
4. key = rdd.sortByKey()
5. print(key.collect())

输出：

1. [('a', 1), ('a', 2), ('b', 1), ('c', 1)]

编程要求

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

需求：使用 sortBy 算子，将 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 算子完成以上需求

    rdd = rdd.sortByKey()

 

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

    print(rdd.collect())

 

    # 7.停止 SparkContext

    sc.stop()

 

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

Transformation - mapValues

任务描述

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

相关知识

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

mapValues

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

上图中的方框代表 RDD 分区。 a=>a+2 代表对 (V1,1) 这样的 Key Value 数据对，数据只对 Value 中的 1 进行加 2 操作，返回结果为 3。

mapValues 案例

1. sc = SparkContext("local", "Simple App")
2. data = [("a",1),("a",2),("b",1)]
3. rdd = sc.parallelize(data)
4. values = rdd.mapValues(lambda x: x + 2)
5. print(values.collect())

输出：

1. [('a', 3), ('a', 4), ('b', 3)]

编程要求

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

需求：使用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 算子完成以上需求

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

 

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

    print(rdd.collect())

    # 7.停止 SparkContext

    sc.stop()

 

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

Transformations - reduceByKey

任务描述

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

相关知识

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

reduceByKey

reduceByKey 算子，只是两个值合并成一个值，比如叠加。

函数实现：

1. def reduceByKey(self, func, numPartitions=None, partitionFunc=portable_hash):
2. return self.combineByKey(lambda x: x, func, func, numPartitions, partitionFunc)

上图中的方框代表 RDD 分区。通过自定义函数 (A,B) => (A + B) ，将相同 key 的数据 (V1,2) 和 (V1,1) 的 value 做加法运算，结果为（ V1,3）。

reduceByKey 案例

1. sc = SparkContext("local", "Simple App")
2. data = [("a",1),("a",2),("b",1)]
3. rdd = sc.parallelize(data)
4. print(rdd.reduceByKey(lambda x,y:x+y).collect())

输出：

1. [('a', 3), ('b', 1)]

编程要求

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

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

例如：

1. ("soma",4), ("soma",1)， ("soma",2） -> ("soma",7)

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

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

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

    print(rdd.collect())

 

    # 7.停止 SparkContext

    sc.stop()

 

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

Actions - 常用算子

任务描述

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

相关知识

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

count

count()：返回 RDD 的元素个数。

示例：

1. sc = SparkContext("local", "Simple App")
2. data = ["python", "python", "python", "java", "java"]
3. rdd = sc.parallelize(data)
4. print(rdd.count())

输出：

1. 5

first

first()：返回 RDD 的第一个元素（类似于take(1)）。

示例：

1. sc = SparkContext("local", "Simple App")
2. data = ["python", "python", "python", "java", "java"]
3. rdd = sc.parallelize(data)
4. print(rdd.first())

输出：

1. python

take

take(n)：返回一个由数据集的前 n 个元素组成的数组。

示例：

1. sc = SparkContext("local", "Simple App")
2. data = ["python", "python", "python", "java", "java"]
3. rdd = sc.parallelize(data)
4. print(rdd.take(2))

输出：

1. ['python', 'python']

reduce

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

示例：

1. sc = SparkContext("local", "Simple App")
2. data = [1,1,1,1]
3. rdd = sc.parallelize(data)
4. print(rdd.reduce(lambda x,y:x+y))

输出：

1. 4

collect

collect()：在驱动程序中，以数组的形式返回数据集的所有元素。

示例：

1. sc = SparkContext("local", "Simple App")
2. data = [1,1,1,1]
3. rdd = sc.parallelize(data)
4. print(rdd.collect())

输出：

1. [1,1,1,1]

编程要求

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

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