Spark RDD常用操作

Transformation（转换操作）算子使用

map 算子

map可以让将func（函数）对数据集中的每一个元素进行处理，并生成一个新的数据集。


data = [1,2,3,4,5]
rdd1 = sc.parallelize(data)
# 使用map操作将每个元素乘以2
rdd2 = rdd1.map(lambda x:x*2)
print(rdd2.collect())

#链式编程
print(sc.parallelize(data).map(lambda x:x*2).collect())

运行结果

[2,4,5,8,10]

filter算子

filter可以筛选数据集中符合特定条件的元素，并生成一个新的数据集。

data = [1,2,3,4,5]
rdd1 = sc.parallelize(data)
# 使用filter操作筛选出大于3的元素
rdd2 = rdd1.filter(lambda x:x>3)
print(rdd2.collect())

# 链式编程
 print(sc.parallelize(data).filter(lambda x:x>3).collect())

运行结果

[4,5]

flatMap算子

flatMap可以将文本数据中的句子拆分成单词，并返回一个 Sequence（序列）

data = ["hello spark", "hello flink", "hello java"]
rdd = sc.parallelize(data)
# 使用flatMap将每个字符串按空格拆分成单词
rdd2 = rdd.flatMap(lambda line: line.split(" "))
print(rdd2.collect())

#链式编程
print(rdd.flatMap(lambda line: line.split(" ")).collect())

运行结果

['hello', 'spark', 'hello', 'world', 'hello', 'world']

union算子

返回一个包含两个RDD元素的并集的新RDD

 a = sc.parallelize([1,2,3])
 b = sc.parallelize([3,4,5])
 # 使用 union 操作将两个 RDD 合并
 print(a.union(b).collect())

运行结果

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

join算子


# 创建两个RDD
a = sc.parallelize([("A", "a1"), ("C", "c1"), ("D", "d1"), ("F", "f1"), ("F", "f2")])
b = sc.parallelize([("A", "a2"), ("C", "c2"), ("C", "c3"), ("E", "e1")])

# 使用 join 操作，返回具有相同键的元素的对
result = a.join(b).collect()
print(result)

# 使用 leftOuterJoin 操作，返回具有左侧RDD的所有元素和右侧RDD匹配的元素的对
# result = a.leftOuterJoin(b).collect()

# 使用 rightOuterJoin 操作，返回具有右侧RDD的所有元素和左侧RDD匹配的元素的对
# result = a.rightOuterJoin(b).collect()

# 使用 fullOuterJoin 操作，返回所有元素的对，左侧RDD没有匹配的元素用None填充，右侧RDD没有匹配的元素用None填充
# result = a.fullOuterJoin(b).collect()

print(result)

运行结果

[('A', ('a1', 'a2')), ('C', ('c1', 'c2')), ('C', ('c1', 'c3'))] [('A', ('a1', 'a2')), ('C', ('c1', 'c2')), ('C', ('c1', 'c3'))]

groupByKey算子
1. 对键值对RDD按键进行分组，返回一个包含键和相应值列表的元组的RDD
```
data = ["hello spark", "hello world", "hello world"]
rdd = sc.parallelize(data)
mapRdd = rdd.flatMap(lambda line: line.split(" ")).map(lambda x: (x, 1))
groupByRdd = mapRdd.groupByKey()
print(groupByRdd.collect())
print(groupByRdd.map(lambda x: {x[0]: list(x[1])}).collect())
```
运行结果

[('world', <pyspark.resultiterable.ResultIterable object at 0x000002773EEBF8D0>), ('hello', <pyspark.resultiterable.ResultIterable object at 0x000002773EEBF668>), ('spark', <pyspark.resultiterable.ResultIterable object at 0x000002773EEBF710>)]

[{'world': [1, 1]}, {'hello': [1, 1, 1]}, {'spark': [1]}]

reduceByKey算子

对键值对RDD中相同键的值进行合并，使用指定的函数进行聚合


data = ["hello spark", "hello world", "hello world"]
rdd = sc.parallelize(data)

# 使用flatMap将每个字符串按空格拆分成单词，并使用map将每个单词映射为键值对 (单词, 1)
mapRdd = rdd.flatMap(lambda line: line.split(" ")).map(lambda x: (x, 1))

# 使用reduceByKey对相同键的值进行累加，即执行单词计数
reduceByKeyRdd = mapRdd.reduceByKey(lambda a, b: a + b)
print(reduceByKeyRdd.collect())

运行结果

[('world', 2), ('hello', 3), ('spark', 1)]

sortByKey算子

对键值对RDD按键进行排序

data = ["hello spark", "hello world", "hello world"] rdd = sc.parallelize(data)
# 使用flatMap将每个字符串按空格拆分成单词，并使用map将每个单词映射为键值对 (单词, 1) 
mapRdd = rdd.flatMap(lambda line: line.split(" ")).map(lambda x: (x, 1))

# 使用reduceByKey对相同键的值进行累加，即执行单词计数 
reduceByKeyRdd = mapRdd.reduceByKey(lambda a, b: a + b)

# 对结果按照键（单词）降序排序 
sortedByKeyRdd = reduceByKeyRdd.sortByKey(False).collect()

# 对结果按照值（计数）降序排序 
sortedByValueRdd = reduceByKeyRdd.map(lambda x: (x[1], x[0])).sortByKey(False).map(lambda x: (x[1], x[0])).collect() 
# 打印排序后的结果
print("Sorted by Key:") 
print(sortedByKeyRdd) 
print("\nSorted by Value:") 
print(sortedByValueRdd)

Sorted by Key:[('world', 2), ('spark', 1), ('hello', 3)]

Sorted by Value:[('hello', 3), ('world', 2), ('spark', 1)]

distinct算子

返回一个包含唯一元素的新RDD。

# 创建两个RDD 
a = sc.parallelize([1, 2, 3]) 
b = sc.parallelize([3, 4, 2]) 
# 对两个RDD执行并集操作 
unionRdd = a.union(b) 
# 对并集结果进行去重 
distinctRdd = unionRdd.distinct() 

result = distinctRdd.collect() print(result)

运行结果

[4, 1, 2, 3]

Spark Transformation

Spark RDD常用操作

Transformation（转换操作） 算子使用

Transformation（转换操作）算子使用