RDD转换

txtFile = r'C:\Desktop\1.txt'
rdd = sparkContext.textFile(txtFile)
rdd.flatMap(lambda x: x.split()).map(lambda x: (x, 1)).reduceByKey(lambda x, y: x+y)

2、创建RDD

（1）基于数据集合创建RDD

data = [1, 2, 3, 4, 5]
distData1 = sc.parallelize(data)   # parallelize函数创建RDD
distData2 = sc.parallelize(data, 2)  # 指定分区数创建RDD，指定2个分区
distData2.count() # count函数返回RDD中元素的个数（不是某个分区的，是全部的元素个数）。

遍历：对list、tuple、dict、set、str等类型的数据使用for...in...的循环语法从其中依次拿到数据进行使用，这样的过程称为遍历，也叫迭代。

可迭代对象（Iterable）：通过for...in...这类语句迭代读取一条数据供我们使用的对象。

（2）基于外部数据源创建RDD

textFile 函数可以将一个外部数据源转换为RDD对象，文件的一行数据就是RDD的一个元素，需要传入该数据源的url，

distFile1 = sc.textFile(“file:///home/camel/Repos/spark/README.md”) # 本地文件
distFile2 = sc.textFile(“hdfs://地址：端口号/test/output”) # hdfs上的文件
distFile1.count() # 此时的count函数返回的是文本的行数

3、RDD算子

作用于RDD上的Operation（操作）分为转换(transformantion)和动作(action)。

RDD拥有的操作比MR丰富的多，不仅仅包括Map、Reduce操作，还包括filter、sort、join、save、count等操作，所以Spark比MR更容易方便完成更复杂的任务。

（1）转换操作 map

将指定的函数作用在RDD的每个分区的每个元素上

rdd = sc.parallelize(["b", "a", "c"])
rdd.map(lambda x: (x, 1)).collect()
结果：
[('b', 1), ('a', 1), ('c', 1)]

map会依次取出rdd中的每一个元素，然后传给lambda x: (x, 1)中x变量，接着lambda针对x变量进行生成tuple (x,1)的操作，collect()是将各内存中的结果返回到驱动端，返回的是包含RDD所有元素的列表（list）

（2）转换操作 flatMap

首先将map函数应用于该RDD的所有元素，然后将结果平坦化（可以理解为将类型为元祖的元素逐个放出来），从而返回新的RDD

rdd = sc.parallelize([2, 3, 4])
rdd.flatMap(lambda x: [(x, x), (x, x)]).collect()
[(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)]

如果将flatMap换成map，结果则为：
[[(2, 2), (2, 2)], [(3, 3), (3, 3)], [(4, 4), (4, 4)]]

（3）转换操作 filter

用指定的函数作为过滤条件，在RDD的所有分区中筛选出符合条件的元素

rdd = sc.parallelize([1, 2, 3, 4, 5])
rdd.filter(lambda x: x % 2 == 0).collect()
[2, 4]

（4）转换操作 union

对一个RDD和参数RDD求并集后，返回一个新的RDD，只不过这里的union不会去重

rdd1 = sc.parallelize([1, 2, 3, 4])
rdd2 = sc.parallelize([3, 4, 5, 6])
rdd1.union(rdd2).collect()
[1, 2, 3, 4, 3, 4, 5, 6]

（5）转换操作 intersection

对一个RDD和参数RDD求交集后，返回一个新的RDD

rdd1 = sc.parallelize([1, 2, 3, 4])
rdd2 = sc.parallelize([3, 4, 5, 6])
rdd1. intersection(rdd2).collect()
[3, 4]

（6）转换操作 distinct

列表转成集合（set(a_list)）， distinct在RDD中返回包含不同元素（会去重）的新RDD

rdd2 = sc.parallelize([3, 4, 5, 6, 3, 4])
rdd2.distinct().collect()
[3, 4, 5, 6]

（7）转换操作 sortBy

对一个RDD和根据指定的key进行排序，返回一个新的RDD，默认是升序排列，如果要降序排列，则添加参数ascending=False

tmp = [("a", 1), ("b", 2), ("1", 3), ("d", 4), ("2", 5)]
sc.parallelize(tmp).sortBy(lambda x: x[0]).collect()
[('1', 3), ('2', 5), ('a', 1), ('b', 2), ('d', 4)]
sc.parallelize(tmp).sortBy(lambda x: x[1]).collect()
[('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]
sc.parallelize(tmp).sortBy(lambda x: x[1], ascending=False).collect()
[('2', 5), ('d', 4), ('1', 3), ('b', 2), ('a', 1)]

（8）转换操作 glom

将原RDD中相同分区的元素合并到同一个列表中，合并形成的列表就是新RDD中的一个元素。通过glom转换，可以知道原RDD分区的情况

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
rdd = sc.parallelize(data, 4)
rdd = rdd.glom()
rdd.collect()
[[1, 2], [3, 4], [5, 6], [7, 8, 9]]