Pyspark: RDD及其常用算子

已于 2022-06-20 22:02:12 修改
阅读量3.7k 收藏 10
点赞数
分类专栏： PySpark 文章标签： PySpark
于 2019-04-25 22:42:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yeshang_lady/article/details/87373280
版权

本文为Pyspark代码

Spark版本：Spark-3.2.1

1. RDD的定义

Spark提供了一种对数据的核心抽象，称为弹性分布式数据集(Resilient Distributed Dataset, RDD)。这个数据集的全部或部分可以缓存在内存中，并且可以在多次计算时重用。RDD其实就是一个分布在多个节点上的数据集合(一个数据集存储在不同的节点上，每个节点存储数据集的一部分)。RDD的主要特征如下： 

  • RDD是不可变的，但可以将RDD转换成新的RDD进行操作；
  • RDD是可分区的。RDD由很多分区组成，每个分区对应一个Task任务来执行。对RDD进行操作，相当于对RDD的每个分区分别进行操作；
  • RDD拥有一系列对分区进行计算的函数，称为算子；
  • RDD之间存在依赖关系，可以实现管道化，避免中间数据的存储；

2. 创建RDD

2.1 Spyder连接PySpark

使用Spyder连接PySpark的代码如下：

from pyspark import SparkContext, SparkConf
import os
os.environ['SPARK_HOME'] ='/Users/sherry/documents/spark/spark-3.2.1-bin-hadoop3.2'
spark_conf = SparkConf().setAppName('Python_Spark_WordCount')\
            .setMaster('local[2]') 
sc = SparkContext(conf=spark_conf)
sc.setLogLevel('WARN')

这里要注意定义sc时spark_conf要明确赋值给conf变量，否则会报如下错误：py4j.protocol.Py4JJavaError: An error occurred while calling None.org.apache.spark.api.java.JavaSparkContext.

2.2 创建RDD

RDD的数据源可以是程序中的对象集合，也可以是外部存储系统中的数据集。例如共享文件系统、HDFS、HBase等。常用的创建RDD的方法主要有以下:

  • parallelize()方法可以将一个对象集合转化为RDD
  • textFile()方法可以读取本地文件系统或外部其他系统中的数据

其用法如下：

#1.创建RDD
rdd_1=sc.parallelize([1,2,3,4,5,6])
rdd_2=sc.textFile(r'test_spark.txt')

另外，在Spark的过往版本中还可以使用makeRDD()方法将对象转化为RDD，但在Spark3.2版本中并没有看到该方法(或者该方法换了位置?)。

在使用parallelize()方法和textFile()方法将数据转化成RDD时，会自动对数据进行分区。parallelize()方法中的numSlices参数和textFile()方法中的minPartitions参数都可以用来指定分区数。若未设置这两个参数，则默认分区数为sc.defaultParallelism(Spark Standalone模式下该值为2)。具体可以使用如下方法查看RDD分区数及各个分区的数据：

a=range(1,11)
rdd_1=sc.parallelize(a)
print('rdd_1分区数量:',rdd_1.getNumPartitions())
print('rdd_1分区结果:',rdd_1.glom().collect())
rdd_2=sc.parallelize(a,numSlices=3)
print('rdd_2分区数量:',rdd_2.getNumPartitions())
print('rdd_2分区结果:',rdd_2.glom().collect())

其执行结果如下：

rdd_1分区数量: 2
rdd_1分区结果: [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
rdd_2分区数量: 3
rdd_2分区结果: [[1, 2, 3], [4, 5, 6], [7, 8, 9, 10]]

3.常用算子

Spark中提供了丰富的操作RDD的方法，这些方法被称为算子。目前RDD支持两种算子：转化(Transformation)算子和行动(Action)算子。这两种算子的区别如下：

  • 转化算子：负责对RDD中的数据进行计算并转化为新的RDD。但所有的转化算子都是惰性的，即这些算子不会立即计算结果，而只是记住对某个RDD的具体操作过程，直到遇到行动算子才会与行动算子一起执行。
  • 行动算子：行动算子会触发Spark的任务调度。

3.1 行动算子

  • reduce()算子、fold()算子和aggregate()算子

reduce(func)算子可以对RDD中的元素进行聚合运算。其执行过程如下：先对每个分区的数据aList执行reduce(func,aList)，将各个分区获得的中间结果组合形成bList，再次执行reduce(func,bList)，其结果即为最终的reduce(func)算子结果。假如aList=[9,10,11,12],func=lambda x,y:x+y,那么reduce(func,aList)的执行过程如下：现将aList的第1个元素值9和第2个元素值10传给func，将其计算的中间结果与第3个元素值11再次传给func，直至得到最后一个结果。举例如下：

a=range(1,11)
#只有1个分区时的结果
rdd_1=sc.parallelize(a,numSlices=1)
red_1=rdd_1.reduce(lambda x,y:x+y)
red_2=rdd_1.reduce(lambda x,y:x-y)
print("1个分区时的结果:{} {}".format(red_1,red_2))
#2个分区时的结果
rdd_2=sc.parallelize(a)
red_1=rdd_2.reduce(lambda x,y:x+y)
red_2=rdd_2.reduce(lambda x,y:x-y)
print("2个分区时的结果:{} {}".format(red_1,red_2))
#3个分区时的结果
rdd_3=sc.parallelize(a,numSlices=3)
red_1=rdd_3.reduce(lambda x,y:x+y)
red_2=rdd_3.reduce(lambda x,y:x-y)
print("3个分区时的结果:{} {}".format(red_1,red_2))

其结果如下，当func=lambda x,y:x-y时，分区数不同时其结果也不同。

1个分区时的结果:55 -53
2个分区时的结果:55 15
3个分区时的结果:55 23

fold(zeroValue,op)算子的执行过程与reduce(func)算子基本相同，区别在于fold()算子给每一次的reduce()计算都提供了一个初始值zeroValue。fold()源码如下：

   def fold(self, zeroValue, op):
        op = fail_on_stopiteration(op)
        def func(iterator):
            acc = zeroValue
            for obj in iterator:
                acc = op(acc, obj)
            yield acc
        vals = self.mapPartitions(func).collect()
        return reduce(op, vals, zeroValue)

fold()用法举例如下：

a=range(1,11)
rdd_1=sc.parallelize(a)
fold_1=rdd_1.fold(2,lambda x,y:x+y)
fold_2=rdd_1.fold(2,lambda x,y:x-y)
print(fold_1,fold_2)

其结果fold_1=61，fold_2=53。这里只说一下fold_2的计算过程：第1个分区的计算结果=2(即为zeroValue)-1-2-3-4-5=-13；第2个分区的计算结果=2-6-7-8-9-10=-38；最后的结果=2-(-13)-(-38)=53

aggregate(zeroValue, seqOp, combOp)其计算过程如下：先对每个分区执行seqOp函数，然后再对所有分区的结果执行combOp函数。zeroValue仍然是每次计算的初始值。其用法举例如下：

rdd_1=sc.parallelize(range(1,11))
agg_1=rdd_1.aggregate(2,seqOp=lambda x,y:x+y,combOp=lambda x,y:x+y)
agg_2=rdd_2.aggregate((0,0),seqOp=lambda x,y:(x[0]+y,x[1]+1),
                      combOp=lambda x,y:(x[0]+y[0],x[1]+y[1]))
print(agg_1,agg_2)

 其计算结果如下(agg_2可以同时统计rdd_1中元素的值的总和及元素个数)

61  (55, 10)

  • count()算子

count()算子可以统计RDD集合中元素的数量。具体代码如下：

rdd_1=sc.parallelize(range(1,11))
print(rdd_1.count())#输出10
rdd_2=sc.parallelize([[1,2],[3,4]])
print(rdd_2.count())#输出2

除了count()算子之外，spark还为数值型的RDD提供了如下描述性统计算子。

方法含义
mean()元素的平均值
sum()总和
max()最大值
min()最小值
variance()方差
sampleVariance()采样方差
stdev()标准差
sampleStdev()采样的标准差
  • collect()算子

collect()算子会把所有元素返回给驱动程序，然后由驱动程序序列化成一个list。collect()要求所有数据必须同一同放入单台机器的内存中，所以一般只会在单元测试中使用。

rdd_1=sc.parallelize(range(1,11))
print("rdd_1中的元素:",rdd_1.collect())

其执行结果如下：

rdd_1中的元素: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

  • take()算子、first()算子和top()算子

take(n)算子返回包含数据集前n个元素组成的数组。first()算子是take()算子的特例，其执行结果与take(1)相同。take()算子用法举例如下：

rdd_1=sc.parallelize(range(1,11),numSlices=5)
print(rdd_1.glom().collect())
print(rdd_1.take(5))

其执行结果如下：

[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
[1, 2, 3, 4, 5]

top(num,key)算子的用法与Python中的sorted()用法相同，但top()算子只支持逆序排序。其具体用法举例如下：

rdd_1=sc.parallelize([5,3,7,19,6,2])
print(rdd_1.top(2))
rdd_2=sc.parallelize([('a',19),('z',4),('c',7),('f',24)])
print(rdd_2.top(3))
print(rdd_2.top(3,key=lambda x:x[1]))

其执行结果如下：

[19, 7]
[('z', 4), ('f', 24), ('c', 7)]
[('f', 24), ('a', 19), ('c', 7)]

  • forecah()算子

foreach(func)算子可以对RDD中的每一个元素运行指定的函数func。但是这个算子不会返回任何结果给驱动器程序。通常情况下，使用该算子可以将RDD中的数据以JSON格式把数据发送到一个网络服务器上，或者把数据存到数据库中。

  • takeSample()算子

takeSample(withReplacement,num,seed)算子可以对RDD中的数据进行采样。withReplacement参数控制是否需要重复采用。num控制采样数量。其用法如下：

rdd_1=sc.parallelize(range(1,20),numSlices=3)
result=rdd_1.takeSample(withReplacement=True,num=10)
print("可放回采样时的结果:",result)
result=rdd_1.takeSample(withReplacement=False, num=10)
print("不可放回采样时的结果:",result)

其结果如下：

可放回采样时的结果: [19, 15, 14, 9, 9, 19, 16, 6, 7, 16]
不可放回采样时的结果: [4, 1, 12, 5, 19, 8, 16, 11, 9, 10]

3.2 转化算子

因为转化算子都是惰性的，所以下文中通过转化算子形成的新的RDD的结果主要是通过collect()算子和glom().collect()算子来展示。后者主要是为了展示新旧RDD之间分区的变化情况。

  • map()算子和flatMap()算子

map()算子接收一个函数做为参数，并把这个函数应用于RDD中的每个元素，最后将函数的返回结果作为结果RDD中对应元素的值。flatMap()算子与map()算子类似，但是每个传入给函数func的RDD元素会返回0到多个元素，最终会将返回的所有元素合并到一个RDD中。其具体用法如下：

rdd_1=sc.parallelize(['hello hadoop world','spark helllo','hello world'])
map_1=rdd_1.map(lambda x:x.split())
map_2=rdd_1.flatMap(lambda x:x.split())
print(rdd_1.collect())
print(map_1.collect())
print(map_2.collect())
print(rdd_1.glom().collect())
print(map_1.glom().collect())
print(map_2.glom().collect())

其计算结果如下：

['hello hadoop world', 'spark helllo', 'hello world']
[['hello', 'hadoop', 'world'], ['spark', 'helllo'], ['hello', 'world']]
['hello', 'hadoop', 'world', 'spark', 'helllo', 'hello', 'world']
[['hello hadoop world'], ['spark helllo', 'hello world']]
[[['hello', 'hadoop', 'world']], [['spark', 'helllo'], ['hello', 'world']]]
[['hello', 'hadoop', 'world'], ['spark', 'helllo', 'hello', 'world']]

  • filter()算子

filter()算子通过函数func对源RDD中的元素进行过滤，并返回一个新的RDD。其用法如下：

rdd_1=sc.parallelize(range(1,11))
rdd_2=rdd_1.filter(lambda x:x>=5)
print(rdd_1.glom().collect())
print(rdd_2.glom().collect())

其计算结果如下：

[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
[[5], [6, 7, 8, 9, 10]]

  • distinct()算子

disinct()算子对RDD中的数据进行去重操作并返回一个新的RDD。当需要验证数据集时非常有用，但开销较大，因为该方法需要将所有数据通过网络进行混洗。其用法如下：

rdd_1=sc.parallelize(([2,3,4,4,5,6]))
rdd_2=rdd_1.distinct()
print(rdd_1.glom().collect())
print(rdd_2.glom().collect())

其结果如下。distinct()算子不仅对数据进行了去重，而且数据的分区也发生了变化。

[[2, 3, 4], [4, 5, 6]]
[[2, 4, 6], [3, 5]]

  • union()算子、intersection()算子、subtract()算子和cartesian()算子

这四个算子是集合类操作。union()算子可以将两个RDD合并成一个新的RDD，该算子主要用于对不同的数据来源进行合并(只做简单的合并不去重)。但合并的两个RDD的数据类型必须一致(因为Python是动态语言，对这一点的要求没有scala这么高)。其用法举例如下：

rdd_1=sc.parallelize([[1,2],[3,4],2])
rdd_2=sc.parallelize([1,2,4])
rdd_3=rdd_1.union(rdd_2)
print(rdd_3.collect())
print(rdd_3.glom().collect())

其结果如下(union操作没有破坏源RDD的数据分区)：

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

intersection()算子对两个RDD进行交集操作，即将两个RDD中共有的元素去重之后形成新的RDD。但是RDD中的数据的类型必须是可Hash的，即整型、浮点型、字符串、tuple和不可变集合，否则程序报错(遇到行动算子时才会显示出报错信息)。其用法如下：

rdd_1=sc.parallelize([1,2,4,2,(1,2),'hello',frozenset([1,3])])
rdd_2=sc.parallelize([1.0,3.6,2,(1,2),'hello',frozenset([1,3])])
rdd_3=rdd_1.intersection(rdd_2)
print(rdd_3.collect())

其结果如下：

[1, (1, 2), 'hello', 2, frozenset({1, 3})]

cartesian()算子对两个RDD进行笛卡尔积操作，该算子返回的结果为(a,b)对，其中a来自第一个RDD中，而b来自第二个RDD中，结果不去重。该操作的开销较大。其用法具体如下：

rdd_1=sc.parallelize([1,2,4])
rdd_2=sc.parallelize([3,3])
rdd_3=rdd_1.cartesian(rdd_2)
print(rdd_3.collect())

其结果如下：

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

subtract()算子对两个RDD进行求差集操作，该算子将第1个RDD中有的元素而第2个RDD中没有的元素组成一个新的RDD。其用法如下：

rdd_1=sc.parallelize([1,2,4,2,(1,2)])
rdd_2=sc.parallelize([1.0,3.6,(1,2)])
rdd_3=rdd_1.subtract(rdd_2)
print(rdd_3.collect())

其结果如下：

[4, 2, 2]

  • repartition()算子

该算子会对RDD重新进行分组分区。该操作会对数据重新混洗，所以开销比较大。另外，该操作可能会产生空白分区。其具体用法如下：

rdd_1=sc.parallelize(range(1,20),numSlices=3)
print(rdd_1.glom().collect())
rdd_2=rdd_1.repartition(4)
print(rdd_2.glom().collect())
rdd_3=rdd_1.repartition(2)
print(rdd_3.glom().collect())

其结果如下：

[[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12], [13, 14, 15, 16, 17, 18, 19]]
[[13, 14, 15, 16, 17, 18, 19], [7, 8, 9, 10, 11, 12], [], [1, 2, 3, 4, 5, 6]]
[[1, 2, 3, 4, 5, 6, 13, 14, 15, 16, 17, 18, 19], [7, 8, 9, 10, 11, 12]]

  • sample()算子

sample()算子与takeSample()算子效果相同，但sample()算子为转化算子，且使用参数fraction控制采样样本数。其用法如下：

rdd_1=sc.parallelize(range(1,20),numSlices=3)
rdd_2=rdd_1.sample(withReplacement=True,fraction=0.3)
print("可放回采样时的结果:",rdd_2.collect())
rdd_3=rdd_1.sample(withReplacement=False, fraction=0.3)
print("不可放回采样时的结果:",rdd_3.collect())

其结果如下：

可放回采样时的结果: [8, 12, 12, 12, 14, 15, 19]
不可放回采样时的结果: [1, 3, 4, 8, 12, 19]

  • sortBy()算子

sortBy()算子可以将RDD中的元素按照某个规则进行排序，第一个参数keyfunc为排序函数，第二个参数指定升序(默认)或降序。其用法如下：

rdd_1=sc.parallelize([[1,2],[4,2],[3,9]])
rdd_2=rdd_1.sortBy(keyfunc=lambda x:x)
print(rdd_2.collect())
rdd_3=rdd_1.sortBy(keyfunc=lambda x:x[1],ascending=False)
print(rdd_3.collect())

其结果如下：

[[1, 2], [3, 9], [4, 2]]
[[3, 9], [1, 2], [4, 2]]

  • groupBy()算子

groupBy()算子可以对RDD中的数据重新进行分组。其具体用法如下：

rdd_1=sc.parallelize(range(1,20))
rdd_2=rdd_1.groupBy(lambda x:x//5)
res_1=[[item[0],list(item[1])]for item in rdd_2.collect()]
print(res_1)

其结果如下：

[[0, [1, 2, 3, 4]], [2, [10, 11, 12, 13, 14]], [1, [5, 6, 7, 8, 9]], [3, [15, 16, 17, 18, 19]]]

  • mapPartitions()算子

mapPartitions()算子与其他算子的不同之处在于，其他算子是作用在RDD的每一个分区的每一个元素上的，而mapPartitions()算子则是作用在RDD的每个分区上的，并将各个分区的计算结果组合成一个新的RDD。其具体用法如下：

rdd_1=sc.parallelize(range(1,10))
def f(x): yield sum(x)
rdd_2=rdd_1.mapPartitions(f)
print(rdd_2.collect())

其结果如下：

[10, 35]

这里要注意的是传入mapPartitions()函数f的写法，这里要使用yield，这样可以将这个函数看作是一个生成器。

参考文献

  1. 《Spark大数据分析实战》
Sun_Sherry
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pyspark学习笔记（五）RDD操作(四)_RDD连接/集合操作
朝花&夕拾
08-18 1652
朋友
02_pyspark_rdd常见算子
bug_creat的博客
06-26 440
rdd的创建
PySpark(二）RDD 常见算子及RDD运行model
HouLei
08-20 1329
五、RDD 常见算子 transformation: RDDA ====》 RDDB 的中间过程为transformation 例如，map是一个转换，它通过一个函数传递每个数据集元素，并返回一个表示结果的新RDD 特点：Spark中的所有转换都是惰性的，因为它们不会立即计算结果。相反，他们只记得应用于某些基础数据集的转换（例如文件）。仅当操作需要将结果返回到驱动程序时才会计算转换。这种设计使S...
Spark：PySpark的RDD算子操作-基于JupyterNotebook
maoyuanming0806的博客
02-11 1155
完整的Spark算子操作演示，基于PySpark，整合Jupyternotebook演示，每个算子调用方式，参数列表、行动算子或变换算子说明，功能说明，演示代码，输出结果一应俱全，方便查验
PySpark算子处理空间数据全解析（2）： 啥是算子（2）
01-30 353
上篇文章说到，算子实际上就是一种操作，在计算机里面就是一个函数，这篇文章说说Spark里面的算子的分类：Spark里面的算子一共有两种，一种称之为Tranformati...
pyspark-examples:Python语言中的Pyspark RDD，DataFrame和Dataset示例
05-02
PySpark DataFrame示例PySpark –创建一个DataFrame PySpark –创建一个空的DataFrame PySpark –将RDD转换为DataFrame PySpark –将DataFrame转换为PandasPySpark – StructType和StructField 在DataFrame和RDD上...
PySpark_Day04：RDD Operations & Shared Variables.pdf
03-24
知识点5：PySpark 实战案例 PySpark 提供了多种实战案例，例如文本文件处理、数据聚合、机器学习等。这些实战案例可以帮助开发者更好地理解 PySpark 的使用方法。 知识点6：Spark 内核调度 Spark 内核调度是 ...
PySpark_Day03：RDD（弹性分布式数据集）.pdf
03-24
PySpark_Day03：RDD（弹性分布式数据集） PySpark_Day03：RDD（弹性分布式数据集）是 PySpark 项目的第三天的课程内容，主要讲解 Spark Core 的核心概念，即 RDD（弹性分布式数据集）。RDD 是 Spark 的基础构建块，...
PySpark RDD cheat Sheet
01-29
在PySpark中，RDD（Resilient Distributed Datasets）是数据处理的核心抽象，它是一个不可变、分区的数据集，可以在集群中的多个节点上并行处理。PySpark是Python语言对Spark API的封装，使得Python开发者可以方便地...
DummyRDD:pyspark的RDD的纯Python模拟
05-11
有关实现的功能及其注意事项的详细列表，请参见下文。 请注意，目前这只是实验性的，以后可能对测试或开发有用，但是使用此工具开发的任何东西都应始终在真实的火花上进行检查，以确保在那里确实可以正常工作。 ...
pyspark count计数小案例
weixin_42357472的博客
10-11 4009
1、spark大体原理介绍，特别rdd重点，两块trans和action，spark懒加载只有最后执行了action操作才产生计算 参考文章，写的很好： https://blog.csdn.net/dsdaasaaa/article/details/94181269 转换操作 RDD 的转换操作是返回新的 RDD 的操作。转换出来的 RDD 是惰性求值的，只有在行动操作中用到这些 RDD 时才...
PySpark RDD 之 reduce
Gscsd的博客
12-11 1916
1. pyspark 版本 2.3.0版本 2. 官网 reduce(f)[source] Reduces the elements of this RDD using the specified commutative and associative binary operator. Currently reduces partitions lo...
Spark双集合（RDD）之间的操作-差集，交集，合集，笛卡尔积等
梦里蓝天
09-28 2019
def main(args:Array[String]){ // 1. 创建 SparkConf对象, 并设置 App名字 val conf:SparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount"); // 2. 创建SparkContext对象 val sc = new SparkContext(conf); // 3. 使用sc创建RD
pyspark RDD reduce、reduceByKey、reduceByKeyLocally用法
花木兰
02-26 6184
一、reduce Reduces the elements of this RDD using the specified commutative and associative binary operator. Currently reduces partitions locally. a=sc.parallelize([1,2,3,4,5],2).reduce(add) print(a) ...
pyspark的RDD代码纪录
weixin_30468137的博客
05-16 356
pyspark rdd.py文件代码纪录 代码版本为 spark 2.2.0 1.RDD及常见算子 class RDD(): #这里简单介绍几个典型的算子,其余的算子代码可以自己去看一看 def __init__(self, jrdd, ctx, jrdd_deserializer=AutoBatchedSerializer(PickleSerializer())): ...
Apache Spark实战教程(三)：两个RDD求交集 差集 并集
UncleTian的博客
01-17 1658
一.前言 spark中两个rdd，经常需要做交集，差集，并集等操作。好比任何一门编程语言中两个集合，交并差也是常见的需求。现在我们看看在spark中怎么实现两个rdd的这种操作。 为了方便看到结果，在spark shell中测试如下代码。 生成两个RDD scala> val rdd1 = sc.parallelize(List("a", "b","c")) rdd1: org.apache...
【Python】PySpark 数据计算 ③ ( RDD#reduceByKey 函数概念 | RDD#reduceByKey 方法工作流程 | RDD#reduceByKey 语法 | 代码示例 )
最新发布
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-02 7095
一、RDD#reduceByKey 方法 1、RDD#reduceByKey 方法概念 2、RDD#reduceByKey 方法工作流程 3、RDD#reduceByKey 函数语法 二、代码示例 - RDD#reduceByKey 方法 1、代码示例 2、执行结果 三、代码示例 - 使用 RDD#reduceByKey 统计文件内容 1、需求分析 2、代码示例
PySpark-RDD聚合算子reduce\fold\aggregate比较和理解
Toby的博客
04-24 1400
比较和理解对RDD进行聚合操作的几种方法： reduce()\reduceByKey()\fold()\aggregate() rdd.reduce(func) #reduce() ：rdd.reduce(func)，对同类型的数据的RDD进行聚合操作,返回值是一个同类型的数值结果 num=sc.parallelize([1,2,3,4]) sum=num.reduce(lambda x,y...
PySpark基础入门（2）：RDD及其常用算子
WHY的博客
05-02 1449
PySpark基础入门第二篇，主要介绍了RDD的基础内容以及常用算子，包括transformation算子，action算子以及一些分区操作算子
spark RDD常用算子
07-15
RDD算子调优是Spark性能调优的重要方面之一。以下是一些常见的RDD算子调优技巧： 1. 避免使用过多的shuffle操作，因为shuffle操作会导致数据的重新分区和网络传输，从而影响性能。 2. 尽量使用宽依赖操作（如reduceByKey、groupByKey等），因为宽依赖操作可以在同一节点上执行，从而减少网络传输和数据重分区的开销。 3. 使用合适的缓存策略，将经常使用的RDD缓存到内存中，以减少重复计算和磁盘读写的开销。 4. 使用合适的分区数，分区数过多会导致

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值