pyspark.RDD

RDD全称为弹性分布式数据集，是Spark中的基本概念， 表示可以并行操作的不可变的分区元素集合。

coalesce(numPartitions, shuffle=False）

• 返回一个缩减为numPartitions分区的新RDD。

sc.parallelize([1, 2, 3, 4, 5], 3).glom().collect()
#[[1], [2, 3], [4, 5]]
sc.parallelize([1, 2, 3, 4, 5], 3).coalesce(1).glom().collect()
#[[1, 2, 3, 4, 5]]

collectAsMap()

• 将此RDD中的键值对作为字典返回到master。

sc.parallelize([(1, 2), (3, 4)]).collectAsMap()
#{1: 2, 3: 4}

countByKey()、countByValue()

• 为每个key或者value计算元素的数目，返回字典

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

filter()

• 过滤操作

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

flatMap()

• 通过首先将函数应用于此RDD的所有元素，然后展平结果，返回新的RDD

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

glom()

• 返回通过将每个分区中的所有元素合并到列表中而创建的RDD。

rdd = sc.parallelize([1, 2, 3, 4], 2)
rdd.glom().collect()
#[[1, 2], [3, 4]]

groupBy()

• 分组

rdd = sc.parallelize([1, 1, 2, 3, 5, 8])
result=rdd.groupBy(lambda x: x % 2).collect()
sorted([(x, sorted(y)) for (x, y) in result])
#[(0, [2, 8]), (1, [1, 1, 3, 5])]

groupByKey()

• 根据key对value进行分组

rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
rdd.groupByKey().mapValues(len).collect()
# [('a', 2), ('b', 1)]
rdd.groupByKey().mapValues(list).collect()
# [('a', [1, 1]), ('b', [1])]

map()

• 太简单，就不讲了

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

mapValues()

• 对每个key的value执行函数，并返回

x = sc.parallelize([("a", ["apple", "banana", "lemon"]), ("b", ["grapes"])])
def f(x): return len(x)
x.mapValues(f).collect()
#[('a', 3), ('b', 1)]

reduce()

• 对RDD中的所有元素使用特定的函数进行聚合操作

from operator import add
>>> sc.parallelize([1, 2, 3, 4, 5]).reduce(add)
15

reduceByKey()

• 对所有相同key的value进行聚合操作

>>> from operator import add
>>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
>>> sorted(rdd.reduceByKey(add).collect())
[('a', 2), ('b', 1)]

sample()

• 对RDD进行采样，返回子集

>>> rdd = sc.parallelize(range(100), 4)
>>> rdd.sample(False, 0.1, 81).collect()
[4, 26, 39, 41, 42, 52, 63, 76, 80, 86, 97]

sortBy()、sortByKey()

• 按关键字/函数排序

>>> 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)]
>>> tmp = [('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]
>>> sc.parallelize(tmp).sortByKey().first()
('1', 3)

takeOrdered()

• 从RDD中获取N个元素，这些元素按升序排列或由可选键函数指定。

>>> sc.parallelize([10, 1, 2, 9, 3, 4, 5, 6, 7]).takeOrdered(6)
[1, 2, 3, 4, 5, 6]
>>> sc.parallelize([10, 1, 2, 9, 3, 4, 5, 6, 7], 2).takeOrdered(6, key=lambda x: -x)
[10, 9, 7, 6, 5, 4]

以上总结是一些RDD中常见函数的基本用法，后面会陆续更新一些高阶用法。