Spark-core/SparkSQL 简单使用总结

一、Spark-core RDD常用算子总结

1、RDD对象特性

• RDD 定义：（Resilient Distributed Dataset）

  弹性分布式数据集，Spark中最基本的数据抽象，代表一个不可变、可分区、里面的元素可并行计算的集合。

• RDD 5大特性：

  1. RDD的分区是RDD数据存储的最小单位
  2. RDD的方法会作用在其所有分区上
  3. RDD 之间是有依赖关系的（RDD有血缘关系）
  4. Key-Value型的RDD可以有自己的分区器
  5. RDD的分区规划，分区会尽量靠近数据所在的服务器

• RDD 程序编程入口：SparkContext

  1. spark RDD 编程的程入口对象就是SparkContext对象（不论何种编程语言）,只有构建出SparkContext,基于它才能执行后续的API调用和计算，本质上，SparkContext对于编程来说，主要功能就是创建第一个RDD出来

• RDD 构建

  1. 通过并行化集合创建（本地对象list --> 分布式RDD）

  2. 读取本地数据源或HDFS文件

2、RDD常用算子

2.1 SparkContext对象创建

# SparkContext对象创建
conf = SparkConf().setAppName('Spark core').setMaster('local[10]')
sc = SparkContext(conf=conf)
sc

# 对象详情
'''
SparkContext

Spark UI

Version    v3.3.0
Master     local[10]
AppName    Spark core
'''

2.2 RDD对象创建

## RDD对象创建
# 1. 通过本地list对象创建
rdd1 = sc.parallelize(c=[1,2,3,4,5],numSlices=3)
print(rdd1.glom().collect()) # 收集所有分区，汇总到driver端显示数据
print(rdd1.getNumPartitions()) # 获取RDD的分区数量

# 输出
'''
[[1], [2, 3], [4, 5]]
3
'''

# 2. 通过读取文件创建
# 2.1 sc.textFile api
rdd1 = sc.textFile('./data',minPartitions=None)# 参数2：最小分区数，一般不指定，spark有自己的合理划分， 
print(rdd1.collect()) # 读取路径下所有文件，每一行认为是一条记录
print(rdd1.getNumPartitions())

# 输出
'''
['hellow world', 'hollow python', 'hollow java']
3
'''

# 2.2 sc.wholeTextFiles api
rdd1 = sc.wholeTextFiles('./data',minPartitions=None)
print(rdd1.collect()) # 读取路径下所用文件，每个元素内容为2元组，k:文件路径，v：对应文件里所有内容
print(rdd1.getNumPartitions()) # 通常用于许多小文件的需求（small files are preferred,as each file will be loaded fully in memory）

# 输出
'''
[('file:/data/jupyter_lab/zyp/pyspark学习/data/wordcount1.txt', 'hellow world\nhollow python\nhollow java')]
1
'''

2.3 Transformation算子: 懒加载，只记录对rdd的操作，不实际执行，操作结果返回一个新的rdd

# 1. map: 对RDD内的每个元素进行map操作
rdd1 = sc.parallelize(range(10),3)
print(rdd1.collect())
print(rdd1.map(lambda x:x+1).collect())

# 输出：
'''
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
'''

# 2. flatMap：对RDD执行map操作后，再进行解除嵌套的操作
rdd1 = sc.parallelize([[1,2],[3,4],[5,6]])
print(rdd1.collect())
print(rdd1.flatMap(lambda x:x).collect())

# 输出：
'''
[[1, 2], [3, 4], [5, 6]]
[1, 2, 3, 4, 5, 6]
'''

# 3 mapValues: 对k-v型RDD中value进行map操作
rdd1 = sc.parallelize([('a',1),('a',1),('b',1),('b',1),('b',1)])
rdd1.mapValues(lambda x:x+1).collect()

# 输出
'''
[('a',2),('a',2),('b',2),('b',2),('b',2)]
'''

# 4. reduceByKey :针对K-V型RDD，自动按照key进行分组，然后根据提供的聚合逻辑，完成组内数据（value）的聚合操作,返回聚合后的K-V值
rdd1 = sc.parallelize([('a',1),('a',1),('b',1),('b',1),('b',1)])
print(rdd1.reduceByKey(lambda a,b:a+b).collect())

# 输出
'''
[('b', 3), ('a', 2)]
'''

# 5. groupBy :将RDD的数据根据指定规则进行分组,返回k-v型RDD（v:可迭代对象）
rdd1 = sc.parallelize([('a',1),('a',1),('b',1),('b',1),('b',1)])
print(rdd1.groupBy(lambda x:x[0]).collect())

# 输出(输出后的value为一个可迭代对象)
'''
[('b', <pyspark.resultiterable.ResultIterable object at 0x2adb5a6a30d0>), ('a', <pyspark.resultiterable.ResultIterable object at 0x2adb5a6a9190>)]
'''

# 6. groupByKey: 针对KV型rdd,自动按照key进行分组(groupBy算子则没有此限定)
rdd1 = sc.parallelize([('a',1),('a',1),('b',1),('b',1),('b',1)])
rdd1.groupByKey().collect()

# 输出
'''
[('b', <pyspark.resultiterable.ResultIterable at 0x2adb5a6d61f0>),
 ('a', <pyspark.resultiterable.ResultIterable at 0x2adb5a6d6e50>)]
'''

# 7. filter: 按给定规则对rdd中的数据进行过滤(和python filter高阶函数用法一致)
rdd1 = sc.parallelize([('a',1),('a',1),('b',1),('b',1),('b',1)])
rdd1.filter(lambda x:True if x[0] == 'a' else False).collect()

# 输出
'''
[('a', 1), ('a', 1)]
'''

# 8. distinct:对RDD数据进行去重，返回新的RDD(k-v型数据也可以去重)
rdd1 = sc.parallelize([('a',1),('a',1),('b',1),('b',1),('b',1)])
rdd1.distinct().collect()

# 输出
'''
[('b', 1), ('a', 1)]
'''

# 9. union: 将2个rdd合并成1个rdd
rdd1 = sc.parallelize([('b',1),('b',1),('b',1)])
rdd2 = sc.parallelize([('a',1),('a',1)])
rdd2.union(rdd1).collect()

# 输出
'''
[('a', 1), ('a', 1), ('b', 1), ('b', 1), ('b', 1)]
'''

# 10. intersection: 求2个rdd的交集
rdd1 = sc.parallelize(range(10))
rdd2 = sc.parallelize(range(5))
rdd1.intersection(rdd2).collect()

# 输出
'''
[0, 1, 2, 3, 4]
'''

# 11. join:对2个rdd执行joi操作,型数据k-v型数据（相当于sql的内连接）
rdd1 = sc.parallelize([('name','张三'),('sex','男'),('age',19),('love','足球')])
rdd2 = sc.parallelize([('name','李四'),('sex','女'),('age',12)])
print(rdd1.join(rdd2).collect())

# 输出
'''
[('name', ('张三', '李四')), ('sex', ('男', '女')), ('age', (19, 12))]
'''

# 12. leftOuterJoin:左外连接 ；rightOuterJoin:右外连接
rdd1 = sc.parallelize([('name','张三'),('sex','男'),('age',19),('love','足球')])
rdd2 = sc.parallelize([('name','李四'),('sex','女'),('age',12)])
rdd1.leftOuterJoin(rdd2).collect()

# 输出
'''
[('name', ('张三', '李四')),
 ('sex', ('男', '女')),
 ('age', (19, 12)),
 ('love', ('足球', None))]
'''

# 13. glom: 将rdd的数据，加上嵌套，这个嵌套按照分区来进行
rdd1 = sc.parallelize(range(10),3)
rdd1.glom().collect()

# 输出
'''
[[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
'''

# 14 sortBy:对rdd数据按照指定规则进行排序
# 语法：rdd.sortBy(func,ascending=False,numPartitions=1) func: 排序规则定义;ascending:False降序；numPartitions:排序后的分区
rdd1 = sc.parallelize(range(10),3)
print(rdd1.glom().collect())
print(rdd1.sortBy(lambda x:x,ascending=False,numPartitions=2).glom().collect())

# 输出
'''
[[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
[[9, 8, 7, 6], [5, 4, 3, 2, 1, 0]]
'''

# 15. sortByKey:针对KV型rdd，按照key进行排序
# 语法：rdd.sortByKey(ascending=True,numPartitions=1,keyfunc) keyfunc:在排序前对key进行处理
rdd1 = sc.parallelize([('a',1),('d',1),('c',2),('b',1),('b',1),('b',1)])
rdd1.sortByKey().collect()

# 输出
'''
[('a', 1), ('b', 1), ('b', 1), ('b', 1), ('c', 2), ('d', 1)]
'''

2.4 Action 算子: 激活rdd相关所有计算，返回一个值或一个结果（保存文件）

# 1. collect: 将rdd各个分区的数据，统一收集到driver中，形成一个list对象（注意：数据量会不会把driver内存撑爆）
rdd1 = sc.parallelize([1,2,3,4,5],2)
type(rdd1.glom().collect()) >> list


# 2. count : 统计rdd有多少元素,返回一个数值
rdd1 = sc.parallelize([('a',1),('d',1),('c',2),('b',1),('b',1),('b',2)])
print(rdd1.count())   >> 6

# 3. countByKey: 统计key出现的次数（一般适用于kv型rdd）
rdd1 = sc.parallelize([('a',1),('d',1),('c',2),('b',1),('b',1),('b',2)])
print(rdd1.countByKey)
      
# 输出
'''
defaultdict(<class 'int'>, {'a': 1, 'd': 1, 'c': 1, 'b': 3})
'''

# 4. reduce:对rdd数据集按照规则进行聚集
rdd1 = sc.parallelize([1,2,3,4,5],2)
rdd1.reduce(lambda a,b :a+b) >> 15

# 5. fold: 和reduce一样，对rdd数据集进行聚合，只不过带有初始值(初始值作用在:分区内聚合，分区间聚合)
rdd1 = sc.parallelize([1,2,3,4,5],2)
rdd1.fold