Spark RDD及其常用算子介绍

一、RDD介绍

1.1 什么是RDD

RDD（Resilient Distributed DataSet），称作弹性分布式数据集，是Spark中最基本的数据抽象，表示一个不可变的，分区的，其中元素可以被并行计算的数据集合。所有的数据操作都是建立在RDD这一抽象数据结构上的，就好比我们Java中的List，Set一样，只不过List和Set是在一个JVM进程中的，不是分布式的而已。

1.2 RDD的特点

• RDD是分区的；

  分区是RDD数据存储的最小单元，一个RDD中的数据会被分为多个分区存储在分布式集群上。

  # 指定使用三个分区
  >>> sc.parallelize([1,2,3,4,5,6,7,8,9], 3).glom().collect()
  [[1,2,3],[4,5,6],[7,8,9]]
  # 指定使用六个分区
  >>> sc.parallelize([1,2,3,4,5,6,7,8,9], 6).glom().collect()
  [[1],[2,3],[4],[5,6],[7],[8,9]]
  

• RDD的运算会作用在其所有的分区上；

  我们对RDD中的数据进行运算时，其效果是同时作用在所有的分区上的。

  # 对6个分区中的所有数据进行乘10的操作
  >>> sc.parallelize([1,2,3,4,5,6,7,8,9],6).map(lambda x: x*10).glom().collect()
  [[10], [20, 30], [40], [50, 60], [70], [80, 90]]
  

• RDD之间是有依赖关系的；

  from pyspark import SparkConf
  from pyspark import SparkContext
  
  if __name__ == '__main__':
      conf=SparkConf().setAppName("test1").setMaster("local")
      sc=SparkContext(conf=conf)
  
      rdd1 = sc.parallelize([1,2,3,4,5,6], 3)
      rdd2 = rdd1.map(lambda x : x * 10)
      rdd3 = rdd2.map(lambda x : x + 1)
  
      print(rdd3.collect())
  

  其中rdd3依赖rdd2，rdd2又依赖rdd1，它们之间形成了一个依赖链条；

• 对于K-V形式数据的RDD可以使用自定义分区器；

  在K-V类型的数据shuffle过程中，默认的分区规则是Hash分区，我们可以自定义指定使用何种分区规则；

• RDD的分区规划会尽量靠近其数据所在的服务器；

  Spark会在确保并行计算能力的前提下，尽量让各个分区从本地读取数据，而非通过网络读取数据；

1.3 RDD的创建

要想创建RDD对象，首先需要初始化Spark RDD的程序入口，即SparkContext对象，只有基于它，才能创建出第一个RDD对象。

from pyspark import SparkConf
from pyspark import SparkContext

if __name__ == '__main__':
    conf=SparkConf().setAppName("test1").setMaster("local")
    sc=SparkContext(conf=conf)
    # SparkContext的主要作用就是创建出第一个RDD对象
    rdd1 = sc.parallelize([1,2,3,4,5,6], 3)

通常我们有两种方式来创建RDD：

• 通过并行化本地集合创建；

  # 将本地集合转为分布式的集合
  rdd1 = sc.parallelize([1,2,3,4,5,6], 3)
  

• 通过读取外部数据文件创建；

  # 读取指定文件（支持HDFS等其它存储）转为分布式集合，分区数会由spark根据设定值自行调整
  rdd1 = sc.textFile("./word.txt", 100)
  

二、常用算子介绍

分布式集合对象上的API操作被称为算子，算子通常被分为三大类：

2.1 转换算子Transformation

转换算子的结果仍然是一个RDD对象，这类算子是懒加载的，只有遇到Action算子，它们才会真正进行转换计算；

• map，将RDD中的数据一条条进行处理，rdd.map(func)

  from pyspark import SparkConf
  from pyspark import SparkContext
  
  if __name__ == '__main__':
      conf=SparkConf().setAppName("test1").setMaster("local")
      sc=SparkContext(conf=conf)
  
      rdd = sc.parallelize([1,2,3,4,5])
  
      # 如果方法体中的逻辑比较简单，推荐使用lambda匿名方法的形式
      # [10, 20, 30, 40, 50]
      print(rdd.map(lambda x : x * 10).collect())
  
      # 如果方法体中的逻辑比较复杂，推荐使用定义方法的形式
      def map_func(data):
          return (data * 10 + 1)
      # [11, 21, 31, 41, 51]
      print(rdd.map(map_func).collect())
  

• flatmap，先对RDD进行map操作，然后再解除数据的嵌套，rdd.flatmap(func)

  from pyspark import SparkConf
  from pyspark import SparkContext
  
  if __name__ == '__main__':
      conf=SparkConf().setAppName("test2").setMaster("local")
      sc=SparkContext(conf=conf)
  
      rdd = sc.parallelize(["a b c", "d e f", "a c f"])
      # [['a', 'b', 'c'], ['d', 'e', 'f'], ['a', 'c', 'f']]
      print(rdd.map(lambda x : x.split(" ")).collect())
      # ['a', 'b', 'c', 'd', 'e', 'f', 'a', 'c', 'f']
      print(rdd.flatMap(lambda x : x.split(" ")).collect())
  

• reduceByKey，表示对于K-V类型的数据，先按照key进行分组，然后将各个组的值按照指定的函数进行迭代计算；

  from pyspark import SparkConf
  from pyspark import SparkContext
  
  if __name__ == '__main__':
      conf=SparkConf().setAppName("test3").setMaster("local")
      sc=SparkContext(conf=conf)
  
      rdd = sc.parallelize([("a",1),("b",1),("a",2),("b",3),("a",2)])
      result = rdd.reduceByKey(lambda x,y:x+y)
      # [('a', 5), ('b', 4)]
      print(result.collect())
  

  需要注意的是，reduceByKey是先在每个分区里面按照key进行分组，然后再进行shuffle，好处就是减少了shuffle的数量，性能上会提高。

• groupBy，表示将RDD中的数据按照指定函数的规则进行分组；

  from pyspark import SparkConf
  from pyspark import SparkContext
  
  if __name__ == '__main__':
      conf=SparkConf().setAppName("test3").setMaster("local")
      sc=SparkContext(conf=conf)
  
      rdd = sc.parallelize([1,2,3,4,5])
      result = rdd.groupBy(lambda x:x%2).collect()
      # [(1, [1, 3, 5]), (0, [2, 4])]
      print([(x,sorted(y)) for (x,y) in result])
  

• Filter，表示将RDD中符合指定过滤条件的数据保留；

  from pyspark import SparkConf
  from pyspark import SparkContext
  
  if __name__ == '__main__':
      conf=SparkConf().setAppName("test3").setMaster("local")
      sc=SparkContext(conf=conf)
  
      rdd = sc.parallelize([1,2,3,4,5])
      result = rdd.filter(lambda x:x%2==1).collect()
      # [1, 3, 5]
      print(result)
  

• distinct，对RDD中的数据去重；

  from pyspark import SparkConf
  from pyspark import SparkContext
  
  if __name__ == '__main__':
      conf=SparkConf().setAppName("test3").setMaster("local")
      sc=SparkContext(conf=conf)
  
      rdd = sc.parallelize([1,1,3,3,5,5,6,1,2,3,3])
      result = rdd.distinct()
      # [1, 3, 5, 6, 2]
      print(result.collect())
  

• union，表示将两个RDD中的数据合并成1个RDD返回；

  rdd1 = sc.parallelize([1,2,3,4,5])
  rdd2 = sc.parallelize(["a","b","c"])
  result = rdd1.union(rdd2)
  # [1, 2, 3, 4, 5, 'a', 'b', 'c']
  print(result.collect())
  

• join，表示对于K-V类型的数据，可以使用连接操作来返回一个RDD；

  # 部门ID和员工姓名
  rdd1 = sc.parallelize([(1001,"zhangsan"),(1002,"lisi"),(1003,"wangwu")])
  # 部门ID和部门名称
  rdd2 = sc.parallelize([(1001,"sales"),(1002,"it"),(1003,"tech")])
  result = rdd1.join(rdd2)
  # [(1002, ('lisi', 'it')), (1001, ('zhangsan', 'sales')), (1003, ('wangwu', 'tech'))]
  print(result.collect())
  

• intersection，表示求两个RDD的交集并返回一个新的RDD；

  rdd1 = sc.parallelize([(1001,"zhangsan"),(1002,"lisi"),(1003,"wangwu")])
  rdd2 = sc.parallelize([(1001,"zhangwu"),(1002,"lisi"),(1003,"wangliu")])
  result = rdd1.intersection(rdd2)
  # [(1002, 'lisi')]
  print(result.collect())
  

• glom，表示按照分区给RDD中的数据加上嵌套；

      rdd = sc.parallelize([1,2,3,4,5])
      result = rdd.glom()
      # [[1, 2, 3, 4, 5]]
      print(result.collect())
  
      rdd2 = sc.parallelize([1,2,3,4,5],3)
      result2 = rdd2.glom()
      # [[1], [2, 3], [4, 5]]
      print(result2.collect())
  

• groupByKey，功能上类似于reduceByKey，但是原理上不同，是将所有分区上的数据都先进行shuffle，性能上不如reduceByKey，适合小数据集时使用；

  rdd = sc.parallelize([("a",1),("b",1),("a",2),("b",3),("a",2)])
  result = rdd.groupByKey().map(lambda x: (x[0],list(x[1])))
  # [('a', 5), ('b', 4)]
  # [('a', [1, 2, 2]), ('b', [1, 3])]
  print(result.collect())
  

• sortBy，根据指定的规则对RDD中的数据进行排序；

  data = [("a",3),("d",1),("e",2),("b",5)]
  result1 = sc.parallelize(data).sortBy(lambda x:x[0])
  # [('a', 3), ('b', 5), ('d', 1), ('e', 2)]
  print(result1.collect())
  
  result2 = sc.parallelize(data).sortBy(lambda x:x[1])
  # [('d', 1), ('e', 2), ('a', 3), ('b', 5)]
  print(result2.collect())
  

• sortByKey，表示对于K-V类型的数据，按照数据的key进行排序；

  data = [("a",3),("b",5),("g",3),("b",1),("k",2),("c",5),("g",2),("f",5),("z",2),("t",5),("d",1),("e",2),("n",2),("l",5)]
  # 按照key升序排列，且要求全局有序
  result1 = sc.parallelize(data,3).sortByKey(ascending=True, numPartitions=1)
  # [('a', 3), ('b', 5), ('b', 1), ('c', 5), ('d', 1), ('e', 2), ('f', 5), ('g', 3), ('g', 2), ('k', 2), ('l', 5), ('n', 2), ('t', 5), ('z', 2)]
  print(result1.collect())
  # 按照key降序排列，不保证全局有序，只保证各个分区内数据有序
  result2 = sc.parallelize(data,3)
  # 查看当前分区情况
  # [[('a', 3), ('b', 5), ('g', 3), ('b', 1)], [('k', 2), ('c', 5), ('g', 2), ('f', 5)], [('z', 2), ('t', 5), ('d', 1), ('e', 2), ('n', 2), ('l', 5)]]
  print(result2.glom().collect())
  # [('a', 3), ('b', 5), ('b', 1), ('c', 5), ('d', 1), ('e', 2), ('f', 5), ('g', 3), ('g', 2), ('k', 2), ('l', 5), ('n', 2), ('t', 5), ('z', 2)]
  print(result2.sortByKey(ascending=True, numPartitions=3).collect())
  

2.2 动作算子Action

动作算子的结果不是RDD对象，它相当于是一个指令来让整个执行计划开始真正工作；通常在Action算子之前都会有一系列的转换算子链条，最终通过一个Action算子来结束当前的计算链条，同时其也是启动整个计算链条工作的开关；

• countByKey，对于K-V类型的数据，统计Key出现的次数；

  rdd = sc.parallelize([("a",1),("b",1),("a",2),("b",3),("a",2)])
  result = rdd.countByKey();
  # defaultdict(, {'a': 3, 'b': 2})
  print(result)
  

• collect，将RDD各个分区内的数据统一收集到Driver中，形成一个List；

  这个在上面的例子中都有介绍，就不额外举例了。

• reduce，表示对RDD内部的元素使用指定的函数进行迭代计算，rdd.reduce(func)

  rdd = sc.parallelize([2,1,3,4])
  result = rdd.reduce(lambda x,y:x*y)
  # 2*1*3*4=24
  print(result)
  

• fold，功能和reduce类似，但是可以接受带初始值进行聚合；

  # 在三个分区平均放置1~9
  rdd = sc.parallelize(range(1,10),3)
  # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  print(rdd.glom().collect())
  result = rdd.fold(10, lambda x,y:x+y)
  # 10 + (10+1+2+3) + (10+4+5+6) + (10+7+8+9) = 85
  print(result)
  

• first，取出RDD中的第一个元素；

• take，取出RDD中的前n个元素，组合成List返回；

• top，对RDD中的数据进行降序排列，取前N个；

• count，计算RDD中有多少条数据，返回一个数字；

• takeSalmpe，从RDD中随机抽取数据；

• takeOrdered，对RDD中的数据进行排序，然后取前N个；

2.3 分区算子

分区上的数据在本分区内由各自的Executor分别直接执行，不用经过Driver；通常我们需要控制并发数和分区数一致时可以考虑试用分区算子。

• foreach，对RDD中的每一个元素，执行提供的逻辑操作；

  rdd = sc.parallelize([1,2,3,4,5,6,9],3)
  # 在每次迭代中打印出计算的内容
  r = rdd.foreach(lambda x: print(x * 10))
  # 由于foreach没有返回值，此处打印为None
  print(r)
  # foreach并没有修改原始数据集合，因此打印内容仍然为[1, 2, 3, 4, 5, 6, 9]
  print(rdd.collect())
  

• saveAsTextFile，将RDD的数据写入文本或者HDFS等文件系统；注意：分区执行，不经过Driver，因此在每个分区上都会有一个结果文件；

  # 要求将数据分为三个分区，实验效果才够明显
  rdd = sc.parallelize([1,2,3,4,5,6,9],3)
  # 将分区详情打印出来，理论上将和保存结果一致，[[1, 2], [3, 4], [5, 6, 9]]
  print(rdd.glom().collect())
  # 要求data文件不能已存在
  rdd.saveAsTextFile("E:\data")
  

  执行完成后，我们打开文件夹就能看到三个输出文件：

  • part-00000，里面内容为1，2
  • part-00001，里面内容为3，4
  • part-00002，里面内容为5，6，9

• foreachPartition，功能和foreach一致，只不过是对每个分区分别进行处理；

      rdd = sc.parallelize([1,2,3,4,5,6,9],3)
      # [[1, 2], [3, 4], [5, 6, 9]]
      print(rdd.glom().collect())
      
      def operate(data):
          print("------")
          result = list()
          for i in data:
              result.append(i * 10)
          print(result)
  
      # ------
      # [10, 20]
      # ------
      # [30, 40]
      # ------
      # [50, 60, 90]
      rdd.foreachPartition(operate)
  

• mapPartitions，功能同map，只不过是对每个分区分别进行处理；

      rdd = sc.parallelize([1,2,3,4,5],3)
      # [[1], [2, 3], [4, 5]]
      print(rdd.glom().collect())
  
      def add(data):
          yield sum(data)
  
      # [[1], [5], [9]]
      print(rdd.mapPartitions(add).glom().collect())
  

• partitionBy，对RDD中的数据进行自定义分区操作；

• repartition，对RDD的分区进行重新分区；

• coalesce，对分区的数量进行增减；

• mapValues，针对KV形式的数据，对其内部的value进行map操作；

这里只是列举了常用的一些算子，详细的内容请参考官方文档：API Reference — PySpark 3.3.2 documentation (apache.org)

三、案例演示与分析

3.1 wordcount

我们在项目根目录下新建一个待统计的文本文件，当然你可以指定其它任何位置的文件皆可：

hello spark
hello python
hello pyspark
welcome to spark world

现在我们需要编写一个基于pyspark的计数程序：

# 读取文件转换为RDD
fileRdd = sc.textFile("./word.txt")
# 对每行数据按章空格进行切割，并去除每行自带的嵌套
wordRdd = fileRdd.flatMap(lambda x : x.split(" "))
# ['hello', 'spark', 'hello', 'python', 'hello', 'pyspark', 'welcome', 'to', 'spark', 'world']
print(wordRdd.collect())
# 每个单词计数为1，形成KV形式
wordPairRdd = wordRdd.map(lambda x : (x, 1))
# [('hello', 1), ('spark', 1), ('hello', 1), ('python', 1), ('hello', 1), ('pyspark', 1), ('welcome', 1), ('to', 1), ('spark', 1), ('world', 1)]
print(wordPairRdd.collect())
# 对单词进行规约reduce计算，相同的单词计数器相加
wordCountRdd = wordPairRdd.reduceByKey(lambda a, b : a + b)
# [('hello', 3), ('spark', 2), ('python', 1), ('pyspark', 1), ('welcome', 1), ('to', 1), ('world', 1)]
print(wordCountRdd.collect())
# 将RDD对象转换为List进行输出
result = wordCountRdd.collect()
# [('hello', 3), ('spark', 2), ('python', 1), ('pyspark', 1), ('welcome', 1), ('to', 1), ('world', 1)]
print(result)

3.2 商品筛选

现在我们要基于如下项目根目录下的商品信息进行商品数据的提取：要求从中提取出北京的商品，去重展示。

{"id":19,"timestamp":"2019-05-08T01:03.00Z","category":"电脑","areaName":"杭州","money":"5551"}|{"id":20,"timestamp":"2019-05-08T01:01.00Z","category":"电脑","areaName":"北京","money":"2450"}
{"id":21,"timestamp":"2019-05-08T01:03.00Z","category":"食品","areaName":"北京","money":"5520"}|{"id":22,"timestamp":"2019-05-08T01:01.00Z","category":"食品","areaName":"北京","money":"6650"}
{"id":23,"timestamp":"2019-05-08T01:03.00Z","category":"服饰","areaName":"杭州","money":"1240"}|{"id":24,"timestamp":"2019-05-08T01:01.00Z","category":"食品","areaName":"天津","money":"5600"}
{"id":25,"timestamp":"2019-05-08T01:03.00Z","category":"食品","areaName":"北京","money":"7801"}|{"id":26,"timestamp":"2019-05-08T01:01.00Z","category":"服饰","areaName":"北京","money":"9000"}

我们编写的pyspark的程序如下：

from pyspark import SparkConf
from pyspark import SparkContext
import json

if __name__ == '__main__':
    conf=SparkConf().setAppName("test1").setMaster("local")
    sc=SparkContext(conf=conf)

    # 读取文件转换为RDD
    fileRdd = sc.textFile("./goods.txt")
    # 每行数据按照分隔符进行分割，得到单独的json数据
    jsonRdd = fileRdd.flatMap(lambda x : x.split("|"))
    # print(jsonRdd.collect())
    # 使用json库转为字典类型
    dictRdd = jsonRdd.map(lambda x : json.loads(x))
    # {'id': 1, 'timestamp': '2019-05-08T01:03.00Z', 'category': '平板电脑', 'areaName': '北京', 'money': '1450'}等等8条
    print(dictRdd.collect())
    # 筛选北京的字典KV数据
    beijingDictRdd = dictRdd.filter(lambda x : x["areaName"] == "北京")
    # {'id': 20, 'timestamp': '2019-05-08T01:01.00Z', 'category': '电脑', 'areaName': '北京', 'money': '2450'}等等5条
    print(beijingDictRdd.collect())
    # 将北京的地域名和商品名拼接起来
    resultRdd = beijingDictRdd.map(lambda x : x["areaName"] + "_" + x["category"])
    # ['北京_电脑', '北京_食品', '北京_服饰']
    print(resultRdd.distinct().collect())

四、踩坑小记

4.1 Too many parameters

在使用某些算子进行实现的时候，比如reduceByKey、distinct的时候，明明代码案例和官网示例一模一样，但就是执行报错：

TypeError: Too many parameters for typing.Iterable; actual 2, expected 1

后来在stackoverflow上查到一个类似的，说是python版本和spark版本不兼容导致的，我出现问题的版本是：

• python3.6
• spark3.3.2

然后将python更新到3.7版本后，该报错问题就解决了：

conda install python=3.7