python + spark （一）

最新推荐文章于 2025-10-28 12:09:43 发布

原创最新推荐文章于 2025-10-28 12:09:43 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#pysprk #RDD基础

Spark 专栏收录该内容

30 篇文章

订阅专栏

本文深入解析了Spark中RDD的各种操作，包括转换、行动操作、集合操作等，通过实例展示了如何使用map、filter、reduceByKey等函数，以及如何利用Broadcast变量和accumulator累加器提升并行处理效率。

from pyspark import SparkContext

sc = SparkContext()

intRdd = sc.parallelize([2,3,1,4,5])
intRdd.collect()

[2, 3, 1, 4, 5]

strRdd = sc.parallelize(['apple','orange','banana','apple'])
strRdd.collect()

['apple', 'orange', 'banana', 'apple']

def addOne(x):
    return x + 1

intRdd.map(addOne).collect()

[3, 4, 2, 5, 6]

intRdd.map(lambda x: x + 1).collect()

[3, 4, 2, 5, 6]

strRdd.map(lambda x: 'frult:' + x).collect()

['frult:apple', 'frult:orange', 'frult:banana', 'frult:apple']

intRdd.filter(lambda x : x < 3).collect()

[2, 1]

intRdd.filter(lambda x: x == 3).collect()

[3]

intRdd.filter(lambda x : 1 < x < 5).collect()

[2, 3, 4]

intRdd.filter(lambda x : x < 3 or x >= 5).collect()

[2, 1, 5]

strRdd.filter(lambda x : 'ra' in x).collect()

['orange']

intRdd.distinct().collect()

[4, 1, 5, 2, 3]

strRdd.distinct().collect()

['orange', 'banana', 'apple']

sRdd = intRdd.randomSplit([0.4,0.6])
sRdd[0].collect()

[2]

sRdd[1].collect()

[3, 1, 4, 5]

gRdd = intRdd.groupBy(lambda x: 'even' if(x%2 == 0) else 'odd').collect()

print(gRdd[0][0],sorted(gRdd[0][1]))

even [2, 4]

print(gRdd[1][0],sorted(gRdd[1][1]))

odd [1, 3, 5]

print(gRdd[0][0],sorted(gRdd[0][1]))

even [2, 4]

print(gRdd[1][0],sorted(gRdd[1][1]))

odd [1, 3, 5]

intRdd1 = sc.parallelize([3,1,2,5,5])
intRdd2 = sc.parallelize([5,6])
intRdd3 = sc.parallelize([2,7])

intRdd1.union(intRdd2).union(intRdd3).collect()

[3, 1, 2, 5, 5, 5, 6, 2, 7]

intRdd1.intersection(intRdd2).collect()

[5]

intRdd1.intersection(intRdd3).collect()

[2]

intRdd1.subtract(intRdd2).collect()

[1, 2, 3]

intRdd1.subtract(intRdd3).collect()

[1, 3, 5, 5]

intRdd1.cartesian(intRdd2).collect()

[(3, 5),
 (3, 6),
 (1, 5),
 (1, 6),
 (2, 5),
 (2, 6),
 (5, 5),
 (5, 5),
 (5, 6),
 (5, 6)]

intRdd2.cartesian(intRdd3).collect()

[(5, 2), (5, 7), (6, 2), (6, 7)]

intRdd1.cartesian(intRdd3).collect()

[(3, 2),
 (3, 7),
 (1, 2),
 (1, 7),
 (2, 2),
 (2, 7),
 (5, 2),
 (5, 2),
 (5, 7),
 (5, 7)]

intRdd.first()

intRdd.take(2)

[2, 3]

intRdd.takeOrdered(3)

[1, 2, 3]

intRdd.takeOrdered(3,key=lambda x:-x)

[5, 4, 3]

intRdd.stats

<bound method RDD.stats of ParallelCollectionRDD[0] at parallelize at PythonRDD.scala:194>

intRdd.stats()

(count: 5, mean: 3.0, stdev: 1.4142135623730951, max: 5.0, min: 1.0)

intRdd.min()

intRdd.max()

intRdd.stdev()

1.4142135623730951

intRdd.count()

intRdd.mean()

3.0

intRdd.sum()

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

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

kvRdd.keys()

PythonRDD[81] at RDD at PythonRDD.scala:52

kvRdd.keys().collect()

[3, 3, 5, 1]

kvRdd.values().collect()

[4, 6, 6, 2]

kvRdd.values

<bound method RDD.values of ParallelCollectionRDD[80] at parallelize at PythonRDD.scala:194>

kvRdd.filter(lambda keyValue:keyValue[0] < 5).collect()

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

kvRdd.filter(lambda kv:kv[0] <= 3).collect()

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

kvRdd.filter(lambda kv:kv[1] < 5).collect()

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

kvRdd.filter(lambda kv:kv[1] >= 2).collect()

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

kvRdd.mapValues(lambda x: x**x).collect()

[(3, 256), (3, 46656), (5, 46656), (1, 4)]

kvRdd.mapValues(lambda x: x*x).collect()

[(3, 16), (3, 36), (5, 36), (1, 4)]

kvRdd.sortByKey(ascending=True).collect()

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

kvRdd.sortByKey().collect()

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

kvRdd.sortByKey(ascending=False).collect()

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

kvRdd.reduceByKey(lambda x,y:x+y).collect()

[(5, 6), (1, 2), (3, 10)]

kvRdd1 = sc.parallelize([(3,4),(3,6),(5,6),(1,2)])
kvRdd2 = sc.parallelize([(3,8)])

kvRdd1.collect()

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

kvRdd2.collect()

[(3, 8)]

kvRdd1.join(kvRdd2).collect()

[(3, (4, 8)), (3, (6, 8))]

kvRdd.leftOuterJoin(kvRdd2).collect()

[(1, (2, None)), (3, (4, 8)), (3, (6, 8)), (5, (6, None))]

kvRdd1.rightOuterJoin(kvRdd2).collect()

[(3, (4, 8)), (3, (6, 8))]

kvRdd1.subtractByKey(kvRdd2).collect()

[(1, 2), (5, 6)]

kvRdd1.first()

(3, 4)

kvRdd1.take(2)

[(3, 4), (3, 6)]

kvFirst = kvRdd1.first()

kvFirst

(3, 4)

kvFirst[1]

kvRdd1.countByKey()

defaultdict(int, {3: 2, 5: 1, 1: 1})

KV = kvRdd1.collectAsMap()
KV

{3: 6, 5: 6, 1: 2}

type(KV)

dict

KV[3]

KV[1]

kvRdd1.lookup(3)

[4, 6]

kvRdd1.lookup(1)

[2]

kvRdd1.lookup(5)

[6]

kvFrult = sc.parallelize([(1,'apple'),(2,'orange'),(3,'banana'),(4,'grape')])

frultMap = kvFrult.collectAsMap()
print('字典:'+str(frultMap))

字典:{1: 'apple', 2: 'orange', 3: 'banana', 4: 'grape'}

frultds = sc.parallelize([2,4,1,3])
print('水果编号：'+str(frultds.collect()))

水果编号：[2, 4, 1, 3]

frultName = frultds.map(lambda x: frultMap[x]).collect()

print('使用字典进行转换=>')
print('水果名称：'+str(frultName))

使用字典进行转换=>
水果名称：['orange', 'grape', 'apple', 'banana']

使用Broadcast广播变量的范例
Broadcast广播变量使用规则如下：
1.可以使用SparkContext.broadcast([初始值])创建
2.使用.value的方法来读取广播变量的值
3.Broadcast广播变量被创建后不能修改
使用Broadcast广播变量的范例与之前的范例类似，不同之处是使用sc.broadcast传入fruitMap作为参数，创建bcFruitMap广播变量，使用bcFruitMap.value(x)广播变量转换为fruitName水果名称

创建kvFruit
*这是水果编号与名称的Key-Value RDD *

kvFruit = sc.parallelize([(1,'apple'),(2,'orange'),(3,'banana'),(4,'grape')])

创建fruitMap
使用collectAsMap创建fruitMap字典

frultMap = kvFrult.collectAsMap()
print('对照表：' + str(frultMap))

对照表：{1: 'apple', 2: 'orange', 3: 'banana', 4: 'grape'}

将fruitMap字典转换为bcFrultMap广播变量
使用sc.broadcast传入frultMap参数，创建bcFrultMap广播变量

frultMap = kvFrult.collectAsMap()
bcFrultMap = sc.broadcast(frultMap)  # 使用sc.broadcast传入frultMap参数，创建bcFrultMap广播变量
print('字典：'+str(frultMap))

字典：{1: 'apple', 2: 'orange', 3: 'banana', 4: 'grape'}

创建frultlds

frultlds = sc.parallelize([2,4,1,3])
print('水果编号：'+str(frultlds.collect()))

水果编号：[2, 4, 1, 3]

使用bcFruitMap.value字典进行转换

print('使用Broadcast 广播变量进行转换=>')
frultNames = frultlds.map(lambda x: bcFrultMap.value[x]).collect()
print('水果名称：'+str(frultNames))

使用Broadcast 广播变量进行转换=>
水果名称：['orange', 'grape', 'apple', 'banana']

在并行处理中，bcFruitMap广播变量会传到Worker Node机器，并且存储在内存中，后续在此Worker Node都可以使用这个bcFruitMap广播变量进行转换，这样可以节省很多内存和传送时间

accumulator累加器

计算总和是MapReduce常用的运算。为了方便进行处理，Spark特别提供了accumulator累加器共享变量（Shared variable），使用规则如下：

accumulator累加器的介绍

accumulator累加器可以使用SparkContext.accumulator([初始值])来创建
使用.add()进行累加
在task中，类如foreach循环中，不能读取累加器的值
只有驱动程序，也就是循环外，才可以使用.value来读取累加器的值

accumulator累加器范例

使用下列范例计算RDD的求和、计数

# 创建范例RDD
intRDD = sc.parallelize([3,1,2,5,5])
# 创建total累计器，初始值使用0.0，所以是Double类型
total = sc.accumulator(0.0)
# 创建num累加器，初始值使用0，所以是Int类型
num = sc.accumulator(0)
# 使用foreach传入i,针对没一下数据执行
# total累加intRDD元素的值、num累加intRDD元素的数量
intRDD.foreach(lambda i: [total.add(1),num.add(1)])

# 计算平均 = 求和 / 计数， 并显示总合、数量
avg = total.value / num.value
print('total =' + str(total.value) + ';num=' + str(num.value) +';avg=' + str(avg))

total =5.0;num=5;avg=1.0