PySpark RDD 基本操作

Python Spark RDD

创建RDD

# 从本地文件加载
stringRDD = sc.textFile("file:/usr/local/spark/README.md")
# 从HDFS加载
stringRDD = sc.textFile("hdfs://master:9000/user/hduser/input/test.txt")
# 通过并行集合创建（列表）
intRDD = sc.parallelize([1, 2, 3, 4, 5])
# 以上全是lazy操作，不会直接创建，直到遇到动作运算

RDD保存

# 保存只能指定目录，文件名会自动指定（根据RDD所在分区不同会有多个不同的文件名）
intRDD.saveAsTextFile('指定目录')
# 读取文件时也可仅指定目录，会自动读取目录下所有文件

基本转换运算

# 创建intRDD 转换运算不会立即执行
intRDD = sc.parallelize([3, 1, 2, 5, 5])
# 转换为list，collect为动作运算，即将分布在各台机器的数据集合起来，立即执行（从头开始运算）
intRDD.collect()
# 创建StringRDD
stringRDD = sc.paralleliae(['apple', 'orange', 'banana', 'grape', 'apple'])
# map运算，对RDD中每个元素，应用传入的函数
intRDD.map(lambda x: x + 1)
# flatmap运算，先对RDD中每个元素应用传入的函数（跟map一样），再将得到的元素全部推平（拍扁）
例如：
stringRDD = sc.parallelize(['apple is sweet', 'orange is sour', 'banana is good'])
fRDD = stringRDD.flatmap(lambda x: x.split(' '))
fRDD.collect()
output: ['apple', 'is', 'sweet', 'orange', 'is', 'sour', 'banana', 'is', 'good']
# filter运算，筛选出满足条件的元素
intRDD.filter(lambda x: x < 3)
# distinct运算，删除重复元素
intRDD.distinct()
# randomSplit运算，将整个集合按照给定的比例随机分割
sRDD = intRDD.randomSplit([0.4, 0.6])
# groupby运算，按照传入的匿名函数将数据分为多个list
gRDD = intRDD.groupby(lambda x: 'even' if (x % 2 == 0) else 'odd')
# 多个RDD的运算
# union合并运算，将多个RDD合并
intRDD1.union(intRDD2).union(intRDD3)
# intersection交集运算，求多个RDD的交集
intRDD1.intersection(intRDD2)
# subtract差集运算，求intRDD1与intRDD2的差集
intRDD1.subtract(intRDD2)
# cartesian运算，求笛卡尔积
intRDD1.cartesian(intRDD2)

基本动作运算

# first，取出第一项数据
intRDD.first()
# take，取出前n个数据
intRDD.take(n)
# takeOrdered，从小到大排序，取出前n项
intRDD.takeOrdered(n)
# 根据指定的排序方法去除前n项
intRDD.takeOrdered(n, key=lambda x: -x)
# stats，统计
intRDD.stats()
# min，最小
intRDD.min()
# max，最大
intRDD.max()
# stdev，标准差
intRDD.stdev()
# count，计数
intRDD.count()
# sum，总和
intRDD.sum()
# mean，均值
intRDD.mean()
# collect，以列表的形式返回数据集中所有元素
intRDD.collect()
# reduce，通过函数func（输入两个参数返回一个值）聚合数据集中的元素
intRDD.reduce(lambda x,y: x + y) # 就是将数据集中所有元素相加
# foreach，对每一个元素执行传入的函数（跟map类似）
intRDD.foreach(print)

RDD Key-Value 键值对运算

# 根据已有的RDD通过map函数创建键值对RDD
pairRDD = stringRDD.map(lambda x: (x, 1))

# groupByKey运算，将RDD中具有相同键的元素归并成一个<Key, <Value-list>>
gRDD = intRDD.groupByKey()

# reduceByKey运算，将RDD中具有相同键的元素和并成一个<Key, Value>，其中每个值是具有相同键的值经过传入函数运算后所得
rRDD = intRDD.groupByKey(lambda x,y: x + y)

# 列出全部Key值
pairRDD.keys().collect()
# 列出全部Value值
pairRDD.values().collect()
# 使用filter筛选出Key < 5的元素，x[0]表示每个元素的key值
pairRDD.filter(lambda x: x[0] < 5)
# 使用filter筛选出Value > 5的元素，x[1]表示每个元素的value值
pairRDD.filter(lambda x: x[1] > 5)
# mapValues，对Value进行map运算（每个值加1）
pairRDD.mapValues(lambda x: x+1)
# sortByKey，按照Key值从小到大排序（默认）
pairRDD.sortByKey()
# 传参ascending=False，按照Key值从大到小排序
pairRDD.sortByKey(ascending=False)

# 多个键值对RDD的转换运算，join
# 将两个RDD按照相同的key值join起来
pairRDD1.join(pairRDD2)
例如：
pairRDD1 = sc.parallelize([('spark', 1), ('spark', 2)])
pairRDD2 = sc.parallelize([('spark', 'fast')])
pairRDD1.join(pairRDD2).collect()
output: [('spark', (1, 'fast')), ('spark', (2, 'fast'))]
# 还可以leftOuterJoin和rightOuterJoin，以左项（右项）为基础进行连接
pairRDD1.leftOuterJoin(pairRDD2).collect()
# subtractByKey，删除所有Key值相同的元素
pairRDD1.subtractByKey(pairRDD2)

# 键值对RDD 动作运算，一般RDD的动作运算也可用于键值对RDD
# 计算RDD中每一个Key值的项数
pairRDD.countByKey()
# 将键值对RDD转化为Python字典 注意：Key值相同的只会留一个，其他的会被忽略
pairRDD.collectAsMap()
# 通过Key值查找Value
pairRDD.lookup(anyKey)

RDD Persistence 持久化

# 将需要重复运算的RDD存储在内存中，以便大幅提高运算效率。为什么？ spark程序每遇到一个动作运算都会将之前的所有转换运算从头到尾全部执行一遍，持久化之后，就不用重复计算了。
RDD.persist()
# 还可以指定存储等级，默认是MEMORY_ONLY
MEMEORY_ONLY：默认选项，存储RDD的方式是以JAVA对象反串行化在JVM内存中，如果RDD太大无法完全存储在内存中，多余的RDD partitions不会缓存在内存中，而是需要是再计算。
MEMORY_AND_DISK：跟MEMORY_ONLY类似，不过其多余的RDD partitions是存储在磁盘上，需要时再读取。
MEMORY_ONLY_SER：存储RDD的方式是以JAVA对象串行化在JVM内存中，因为需要再进行反串行化，所以会多使用CPU的计算资源，但比较节省内存。如果RDD太大无法完全存储在内存中，多余的RDD partitions不会缓存在内存中，而是需要是再计算。
MEMORY_AND_DISK_SER：跟MEMORY_ONLY_SER类似，不过其多余的RDD partitions是存储在磁盘上，需要时再读取。
DISK_ONLY：RDD存储在磁盘上。
MEMEORY_ONLY_2，MEMEORY_AND_DISK_2：跟上面两个一样，只是每一个RDD分区都复制到两个节点。
RDD.cache() == RDD.persist(MEMORY_ONLY)
# 取消持久化
RDD.unpersist()