spark的惰性计算_Spark大数据分析（二）：RDD数据处理

Spark作为当前企业覆盖度最广大数据平台，大数据处理能力基本上是每一个算法工程师or数据分析师的必备技能。所以即使不做大数据开发的读者，也很有必要掌握其基本构造以及使用方法。

在使用Spark的API接口时，一般不会限定使用语言，公司内使用Java/Scala/Python语言调用Spark dataframe，在性能上是没有显著差异的。只有在使用底层RDD形式处理数据时，python的性能较差。当然，目前企业中的数据处理的主要方法是dataframe或者SQL语言，所以可以不用担心使用语言的效率问题。

基本结构

Spark可以分为1个driver(笔记本电脑或者集群网关机器上)和若干个executor(在各个节点上)，通过SparkContext(简称sc)连接Spark集群、创建RDD、累加器(accumlator)、广播变量(broadcast variables)，简单可以认为SparkContext是Spark程序的一个入口，类似于python中的import。

Driver会把计算任务分成一系列小的task，然后送到executor执行。executor之间可以通信，在每个executor完成自己的task以后，所有的信息会被传回。

在Spark里，所有的处理和计算任务都会被组织成一系列Resilient Distributed Dataset(弹性分布式数据集，简称RDD)上的transformations(转换) 和 actions(动作)。

弹性分布式数据集

RDD是一个包含诸多元素、被划分到不同节点上进行并行处理的数据集合，可以将RDD持久化到内存中，这样就可以有效地在并行操作中复用(在机器学习这种需要反复迭代的任务中非常有效)。在节点发生错误时RDD也可以自动恢复。

RDD就像一个NumPy array或者一个Pandas Series，可以视作一个有序的item集合。只不过这些item太大了，并不能存在driver端的内存里，而是被分割成很多个partitions，每个partition的数据存在集群的executor的内存中。

使用python调用非常简单：

import pysparkfrom pyspark import SparkContextfrom pyspark import SparkConf#设定名字和master位置conf=SparkConf().setAppName("miniProject").setMaster("local[*]")#使用已经存在的SparkContextsc=SparkContext.getOrCreate(conf)#存放在当前环境中的list初始化为rdd，切分到不同的节点上rdd = sc.parallelize([1,2,3,4,5])#查看分区状况rdd.glom().collect()

[[1], [2], [3], [4, 5]]

在这个例子中，是一个4-core的CPU笔记本。Spark创建了4个executor，然后把数据分成4个块。

第2种方式当然是直接把文本读到RDD了。你的每一行都会被当做一个item，不过需要注意的一点是，Spark一般默认你的路径是指向HDFS的，如果你要从本地读取文件的话，给一个file://开头的全局路径。

import oscwd = os.getcwd()rdd = sc.textFile("file://" + cwd + "/names/yob1880.txt")#取出一个itermrdd.first()

u'Mary,F,7065'

你甚至可以很粗暴地读入整个文件夹的所有文件。但是要特别注意，这种读法，RDD中的每个item实际上是一个形如 (文件名，文件所有内容) 的元组。咱们来试着读一读所有的文件。

rdd = sc.wholeTextFiles("file://" + cwd + "/names")rdd.first()

(u'file:/home/ds/notebooks/spark/names/yob1880.txt',
 u'Mary,F,7065\r\nAnna,F,2604\r\nEmma,F,2003\r\nElizabeth,F,1939\r\nMinnie,F,1746\r\nMargaret,F,1578\r\nIda,F,1472\r\nAlice,F,1414\r\nBertha,F,1320\r\n)

RDD还可以通过其他的方式初始化，包括

1. HDFS上的文件

2. Hive中的数据库与表

3. Spark SQL得到的结果

transformation

我们先给大家提一下RDD上最最常用到的transformation:

• map() 对RDD的每一个item都执行同一个操作

• flatMap() 对RDD中的item执行同一个操作以后得到一个list，然后以平铺的方式把这些list里所有的结果组成新的list

• filter() 筛选出来满足条件的item

• distinct() 对RDD中的item去重

• sample() 从RDD中的item中采样一部分出来，有放回或者无放回

• sortBy() 对RDD中的item进行排序

如果你想看操作后的结果，可以用一个叫做collect()的action把所有的item转成一个Python list。

numbersRDD = sc.parallelize(range(1,10+1))print(numbersRDD.collect())#map和dataframe中用法相同squaresRDD = numbersRDD.map(lambda x: x**2)  # Square every numberprint(squaresRDD.collect())filteredRDD = numbersRDD.filter(lambda x: x % 2 == 0)  # Only the evensprint(filteredRDD.collect())

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[2, 4, 6, 8, 10]

输入一个iterm，输出一个iterm.

然后咱们看看flatMap()的平展功能:

sentencesRDD = sc.parallelize(['Hello world', 'My name is Patrick'])wordsRDD = sentencesRDD.flatMap(lambda sentence: sentence.split(" "))print(wordsRDD.collect())print(wordsRDD.count())

['Hello', 'world', 'My', 'name', 'is', 'Patrick']
6

flatmap后的iterm中括号是被打开的，输入一个iterm，输出多个iterm.

为了做一个小小的对应，咱们看看python里对应的操作大概是什么样的:

l = ['Hello world', 'My name is Patrick']ll = []for sentence in l:    ll = ll + sentence.split(" ")ll

['Hello', 'world', 'My', 'name', 'is', 'Patrick']
6

并且Transformation，可以一个接一个地串联，比如:

# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]def doubleIfOdd(x):    if x % 2 == 1:        return 2 * x    else:        return xresultRDD = (numbersRDD           # In parentheses so we can write each             .map(doubleIfOdd)    # transformation in one line             .filter(lambda x: x > 6)             .distinct())resultRDD.collect()

如果你手头上有2个RDD了，下面的这些操作能够帮你对他们以各种方式组合得到1个RDD:

• rdd1.union(rdd2): 所有rdd1和rdd2中的item组合

• rdd1.intersection(rdd2): rdd1 和 rdd2的交集

• rdd1.substract(rdd2): 所有在rdd1中但不在rdd2中的item(差集)

• rdd1.cartesian(rdd2): rdd1 和 rdd2中所有的元素笛卡尔乘积 

numbersRDD = sc.parallelize([1,2,3])moreNumbersRDD = sc.parallelize([2,3,4])numbersRDD.union(moreNumbersRDD).collect()

[1, 2, 3, 2, 3, 4]

numbersRDD.intersection(moreNumbersRDD).collect()

[2, 3]

numbersRDD.subtract(moreNumbersRDD).collect()

[1]

numbersRDD.cartesian(moreNumbersRDD).collect()

[(1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4)]

特别注意：Spark的一个核心概念是惰性计算。当你把一个RDD转换成另一个的时候，这个转换不会立即生效执行。Spark会把它先记在心里，等到真的需要拿到转换结果的时候，才会重新组织你的transformations(因为可能有一连串的变换)。这样可以避免不必要的中间结果存储和通信。

刚才提到了惰性计算，那么什么东西能让它真的执行转换与运算呢？ 是的，就是我们马上提到的Actions，下面是常见的action，当他们出现的时候，表明我们需要执行刚才定义的transform了:

• collect(): 计算所有的items并返回所有的结果到driver端，接着 collect()会以Python list的形式返回结果

• first(): 和上面是类似的，不过只返回第1个item

• take(n): 类似dataframe.head()，但是返回n个item

• count(): 计算RDD中item的个数

• top(n): 返回头n个items，按照自然结果排序

• reduce(): 对RDD中的items做聚合

我们之前已经看过 collect(), first() 和 count() 的例子了。咱们看看 reduce()如何使用。比如Spark里从1加到10你可以这么做。

# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]rdd = sc.parallelize(range(1,10+1))rdd.reduce(lambda x, y: x + y)

55

如果你想了解一下reduce的细节的话，其实可能会先在每个分区(partition)里完成reduce操作，然后再全局地进行reduce。这个过程你可以从如下的代码大致理解。

def f(x,y):    return x + yl = [1,2,3,4]f(f(f(l[0],l[1]), l[2]), l[3])

10

咱们刚才已经见识到了Spark中最常见的transform和action，但是有时候我们会遇到更复杂的结构，比如非常非常经典的是以元组形式组织的k-v对(key, value)我们把它叫做pair RDDs，而Sark中针对这种item结构的数据，定义了一些transform和action:

• reduceByKey(): 对所有有着相同key的items执行reduce操作

• groupByKey(): 返回类似(key, listOfValues)元组的RDD，后面的value List 是同一个key下面的

• sortByKey(): 按照key排序

• countByKey(): 按照key去对item个数进行统计

• collectAsMap(): 和collect有些类似，但是返回的是k-v的字典

使用spark中的rdd完成hadoop中的词频统计

rdd = sc.parallelize(["Hello hello", "Hello New York", "York says hello"])resultRDD = (    rdd    .flatMap(lambda sentence: sentence.split(" "))  # 分词    .map(lambda word: word.lower())                 # 小写    .map(lambda word: (word, 1))                    # 统计词频    .reduceByKey(lambda x, y: x + y)                # 相同词词频相加(group by 词名))resultRDD.collect()

[('says', 1), ('new', 1), ('hello', 4), ('york', 2)]

以上的展示结果很丑，所以我们将结果以k-v字典的形式返回(collectAsMap)

result = resultRDD.collectAsMap()result

{'hello': 4, 'new': 1, 'says': 1, 'york': 2}

如果你想要出现频次最高的2个词，可以这么做:

print(resultRDD      .sortBy(keyfunc=lambda (word, count): count, ascending=False)      .take(2))

[('hello', 4), ('york', 2)]