知识点
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 **********#