pyspark RDD基本操作

# encoding: utf-8
import os
from pyspark import SparkConf, SparkContext

# 指定使用python3
os.environ["PYSPARK_PYTHON"] = "/usr/local/bin/python3"
# 初始化
sc = SparkContext()

# 创建RDD
intRDD = sc.parallelize([1, 2, 3, 4, 5, 1])
stringRDD = sc.parallelize(['a', 'b', 'c', 'd', 'e'])

# RDD数据类型使用collect转为python数据类型
print(intRDD.collect())  # [1, 2, 3, 4, 5, 1]
print(stringRDD.collect())  # ['a', 'b', 'c', 'd', 'e']

# map运算，将每个元素经过函数运算产生另外一个RDD
print(intRDD.map(lambda x: x+1).collect())  # [2, 3, 4, 5, 6, 2]

# filter运算，对RDD内元素进行筛选，并产生另外一个RDD
print(intRDD.filter(lambda x: x < 3).collect())  # [1, 2, 1]
print(stringRDD.filter(lambda y: 'a' in y).collect())  # ['a']

# distinct运算，删除重复的值
print(intRDD.distinct().collect())  # [1, 2, 3, 4, 5]

# randomSplit运算，将RDD按照比例分成多个集合
sRDD = intRDD.randomSplit([0.2, 0.8])
print(len(sRDD))  # 2
print(sRDD[0].collect())  # [1]
print(sRDD[1].collect())  # [1, 2, 3, 4, 5]

# groupBy运算可以按照传入的匿名函数规则，将数据分为多个array
result = intRDD.groupBy(lambda x: x % 2).collect()
print(sorted([(x, sorted(y))for (x, y) in result]))  # [(0, [2, 4]), (1, [1, 1, 3, 5])]

# 多个RDD运算
intRDD1 = sc.parallelize([1, 2, 3, 4, 5])
intRDD2 = sc.parallelize([5, 6, 7, 8])
intRDD3 = sc.parallelize([9, 10])

# union并集运算
print(intRDD1.union(intRDD2).union(intRDD3).collect())  # [1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]

# intersection交集运算
print(intRDD1.intersection(intRDD2).collect())  # [5]

# subtract差集运算
print(intRDD1.subtract(intRDD2).collect())  # [1, 2, 3, 4]

# cartesian笛卡尔积运算
print(intRDD1.cartesian(intRDD2).collect())  # [(1, 5), (1, 6), (1, 7), (1, 8), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8)]

# 读取元素
# 读取第一条数据
print(intRDD.first())  # 1
# 读取前两条数据
print(intRDD.take(2))  # [1, 2]
# 读取前三条数据,升序排序
print(intRDD.takeOrdered(3))  # [1, 1, 2]
# 读取前三条数据，降序排序
print(intRDD.takeOrdered(3, lambda x: -x))  # [5, 4, 3]

# 统计功能
# 统计
print(intRDD.stats())  # (count: 6, mean: 2.6666666666666665, stdev: 1.4907119849998598, max: 5.0, min: 1.0)
# 最小值
print(intRDD.min())  # 1
# 最大值
print(intRDD.max())  # 5
# 标准差
print(intRDD.stdev())  # 1.4907119849998598
# 计数
print(intRDD.count())  # 6
# 求和
print(intRDD.sum())  # 16
# 平均
print(intRDD.mean())  # 2.6666666666666665

# RDD key-value基本转换运算
# 初始化
kvRDD1 = sc.parallelize([(1, 2), (5, 6), (7, 8), (3, 4), (3, 6)])

# 使用keys， values函数分别得到RDD的键和值
print(kvRDD1.collect())  # [(1, 2), (5, 6), (7, 8), (3, 4), (3, 6)]
print(kvRDD1.keys().collect())  # [1, 5, 7, 3, 3]
print(kvRDD1.values().collect())  # [2, 6, 8, 4, 6]

# 可以使用filter筛选元素，可以按照key，也可以按照values来筛选
print(kvRDD1.filter(lambda x: x[0] > 5).collect())  # [(7, 8)]
print(kvRDD1.filter(lambda x: x[1] < 5).collect())  # [(1, 2), (3, 4)]


# 使用mapValues方法处理value值
print(kvRDD1.mapValues(lambda x: x**2).collect())  # [(1, 4), (5, 36), (7, 64), (3, 16), (3, 36)]

# 使用sortByKey按照key进行排序，默认值和true代表从小到大，false代表从大到小
print(kvRDD1.sortByKey().collect())  # [(1, 2), (3, 4), (3, 6), (5, 6), (7, 8)]
print(kvRDD1.sortByKey(True).collect())  # [(1, 2), (3, 4), (3, 6), (5, 6), (7, 8)]
print(kvRDD1.sortByKey(False).collect())  # [(7, 8), (5, 6), (3, 4), (3, 6), (1, 2)]

# 使用reduceByKey函数可以合并具有相同key的数据
print(kvRDD1.reduceByKey(lambda x, y: x+y).collect())  # [(1, 2), (3, 10), (5, 6), (7, 8)]

# 多个RDD， key-values转换运算
kvRDD2 = sc.parallelize([(3, 4), (5, 6), (6, 7), (1, 2)])
kvRDD3 = sc.parallelize([(3, 8), (7, 8)])

# join内连接运算，将两个RDD按照相同的key值join起来
print(kvRDD2.join(kvRDD3).collect())  # [(3, (4, 8))]

# leftOuterJoin 左链接，如果kvRDD2中的key值对应不到kvRDD3,就显示None
print(kvRDD2.leftOuterJoin(kvRDD3).collect())  # [(1, (2, None)), (3, (4, 8)), (5, (6, None)), (6, (7, None))]

# rightOuterJoin 右链接， 如果kvRDD3中的值对应不到kvRDD2，就会显示None
print(kvRDD2.rightOuterJoin(kvRDD3).collect())  # [(3, (4, 8)), (7, (None, 8))]

# subtractByKey运算会删除kvRDD2中key与kvRDD3中相同的数据
print(kvRDD2.subtractByKey(kvRDD3).collect())  # [(1, 2), (5, 6), (6, 7)]


# key-value的动作运算
# 读取第一条数据
print(kvRDD2.first())  # (3, 4)
# 读取前两条数据
print(kvRDD2.take(2))   # [(3, 4), (5, 6)]
# 读取第一条数据的key值
print(kvRDD2.first()[0])  # 3
# 读取第一条数据的vales值
print(kvRDD2.first()[1])  # 4


# countByKey按key值统计
print(kvRDD2.countByKey())  # defaultdict(<class 'int'>, {3: 1, 5: 1, 6: 1, 1: 1})

# lookup查找运算
print(kvRDD2.lookup(3))  # [4]