Spark常用RDD操作总结
aggregate
- 函数原型：
aggregate(zeroValue, seqOp, combOp)
- seqOp相当于Map
- combOp相当于Reduce
- zeroValue是seqOp每一个partion的初始值，是一个元组，默认为0。
- 计算列表中总数：
sc.parallelize( [[123],[4,5,6],[7,8,9]] )\
.aggregate(0, lambda: x,y: sum(y)+x, lambda x,y: x+y)
# [('world', 1), ('hello', 2), ('morning', 1)]
seqOp的输入值为x,y，其中x为初始值或中间值（如果当前partion有多个列表那就有中间值了，即上一个seqOp返回的值），而y就是第一个输入，比如：[1,2,3],[4,5,6],[7,8,9]。。。 combOp的输入值也为x,y，其中y为初始值或中间值（超过2个partion时肯定会产生中间值），x为输入值。比如1+2+3=6,4+5+6=15,7+8+9=24。那6,15,24都会作为输入值计算。当然此处的combOp在调用过程中也并非是串行的挨个把6，15，24加起来，中间也会有先汇总再求和的过程。但对用户来说此处是透明的。 我们看到aggregate中把每一个物理上的输入行作为一个计算单位输入并输出，他比较适合计算总数，行数等类似与列中所蕴含值无关的统计维度。
aggregateByKey
- 函数原型：
aggregateByKey(zeroValue, seqFunc, combFunc, numPartitions=None)
- 参数与aggregate相同
-
根据key进行合并
-
上例稍加改动可以完成一个wordcounts
sc.parallelize(["hello world", "hello morning"])\
.flatMap(lambda line: line.split())\
.map(lambda letter: (letter, 1)).aggregateByKey(0, lambda x,y: y+x, lambda x,y: x+y)\
.collect()
# [(1, 1), (1, 2), (2, 1), (2, 2)]
cartesian
- 返回两个rdd的笛卡儿积
rdd1 = sc.parallelize([1, 2])
rdd2 = sc.parallelize([3, 4, 5])
rdd1.catesian(rdd2).cellect()
# [(1, 1), (1, 2), (2, 1), (2, 2)]
glom
- 将一个一维横向列表，划分为多个块
sc.parallelize([1,2,3,4,5], 1).collect()
# [1, 2, 3, 4, 5]
sc.parallelize([1,2,3,4,5], 1).glom().collect()
# [[1, 2, 3, 4, 5]]
sc.parallelize([1,2,3,4,5], 2).glom().collect()
# [[1, 2], [3, 4, 5]]
coalesce
- 将多个块组合成n个大的列表
sc.parallelize([1,2,3,4,5], 3).coalesce(2).glom().collect()
# [[1], [2, 3, 4, 5]]
sc.parallelize([1,2,3,4,5], 3).coalesce(2).collect()
# [1, 2, 3, 4, 5]
sc.parallelize([1,2,3,4,5], 3).glom().collect()
# [[1], [2, 3], [4, 5]]
cogroup
-
函数原型：
cogroup(other, numPartitions=None) -
按key聚合后，求两个RDD的并集。
x = sc.parallelize([("a", 1), ("b", 4)])
y = sc.parallelize([("a", 2)])
map((lambda (x,y): (x, (list(y[0]), list(y[1])))), sorted(list(x.cogroup(y).collect())))
# [('a', ([1], [2])), ('b', ([4], []))]
collectAsMap
- 将rdd数据按KV对形式返回
sc.parallelize([(1,2), (3,4)]).collectAsMap()
# {1: 2, 3: 4}
sc.parallelize([(1, (2, 6666)), (3, 4)]).collectAsMap()
# {1: (2, 6666), 3: 4}
combineByKey
-
函数原型：
combineByKey(createCombiner, mergeValue, mergeCombiners, numPartitions=None) -
根据key进行
count
- 返回rdd中元素的数目
sc.parallelize([2,3,4]).count()
# 3
countByKey
- 按key聚合后计数
rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
rdd.countByKey().items()
# [('a', 2), ('b', 1)]
countByValue
- 按value聚合后再计数
sc.parallelize(["hello", "world", "hello", "china", "hello"]).countByValue().items()
# [('world', 1), ('china', 1), ('hello', 3)]
countApprox
- countApprox(timeout, confidence=0.95) 貌似在公司版本中还未提供 count的一个升级版（实验中），当超过timeout时，返回一个未完成的结果。
rdd = sc.parallelize(range(1000), 10)
rdd.countApprox(1000, 1.0)
# 1000
distinct
- distinct(numPartitions=None) 返回rdd中unique的元素
sorted(sc.parallelize([1, 1, 2, 3]).distinct().collect()
# [1, 2, 3]
filter
- 过滤一个RDD中，其每一行必须瞒住filter的条件
rdd = sc.parallelize([1, 2, 3, 4, 5])
rdd.filter(lambda x: x%2==0).collect()
# [2, 4]
first
- 返回rdd中的第一个元素
sc.parallelize([2, 3, 4]).first()
flatMap
- flatMap(f, preservesPartitioning=False) 返回rdd中的所有元素，并把flatMap中返回的列表拉平。
rdd = sc.parallelize([2, 3, 4])
rdd.flatMap(lambda x: range(1, x)).collect()
# [1, 1, 1, 2, 2, 3]
flatMapValues
- 同flatMap，但按照key进行flat，并最终拉平。
x = sc.parallelize([("a", ["x", "y", "z"]), ("b", ["p", "r"])])
def f(x): return x
x.flatMapValues(f).collect()
# [('a', 'x'), ('a', 'y'), ('a', 'z'), ('b', 'p'), ('b', 'r')]
fold
- fold(zeroValue, op) 聚合RDD的每一个分区，最后再合并计算，每一个函数默认值为"zeroValue"。 op(t1,t2)函数可以更改t1并且将更改后的t1作为返回值返回以减少对象内存占用。切记不可个性t2的值。
def add(x,y): return x+y
sc.parallelize([1, 2, 3, 4, 5]).fold(0, add)
# 15
