2.RDD的基本操作

有些时候，我不太喜欢介绍相关概念什么的（其实是你懒吧），而是喜欢直接介绍用法。

所以RDD是什么这里也不再介绍了，可以自行百度，下面直接介绍rdd的一些操作

from pyspark import SparkContext, SparkConf

conf = SparkConf()
sc = SparkContext(conf=conf)

'''
先来介绍一下rdd的一些transformation操作
'''
# 1.map
'''
类似于python里面的map，里面传一个函数，会将函数作用于rdd的每一个元素
'''
def my_map():
    '''rdd有两种模式，一个是transformation，一个是action。
    前者只是记录了相应的操作，并不会真正的执行，类似于python里面的生成器，
    只有当遇到的action，才会真正的计算，产生值，类似于对生成器进行for循环或者__next__'''
    data = [1, 2, 3, 4, 5]
    rdd = sc.parallelize(data)
    rdd1 = rdd.map(lambda x: x*2)
    rdd2 = rdd.map(lambda x: ("古明地盆", 1))
    # rdd在进行map是一个transformation，需要collect才会产生值
    print(rdd1.collect())
    print(rdd2.collect())

my_map()
'''
输出结果：
[2, 4, 6, 8, 10]
[('古明地盆', 1), ('古明地盆', 1), ('古明地盆', 1), ('古明地盆', 1), ('古明地盆', 1)]
'''

# 2.filter
'''
和python的filter一样，里面传一个函数，函数返回一个bool类型，True的话保留，False剔除
'''
def my_filter():
    data = [1, 2, 3, 4, 5]
    rdd = sc.parallelize(data)
    rdd1 = rdd.filter(lambda x: x>3)
    print(rdd1.collect())
    # 也可以进行链式编程
    print(sc.parallelize([1, 2, 3, 4, 5]).map(lambda x: x*2).filter(lambda x: x>5).collect())
my_filter()
'''
输出结果
[4, 5]
[6, 8, 10]
'''

# 3.flatMap
'''
不好解释举个栗子
'''
def my_flatMap():
    data = ["hello world", "hello cruel hello", "hello beautiful world"]
    rdd = sc.parallelize(data)
    print(rdd.map(lambda line: line.split(" ")).collect())
    # 使用flatMap需要每一个元素都是可迭代的
    print(rdd.flatMap(lambda line: line.split(" ")).collect())

my_flatMap()
'''
输出结果
[['hello', 'world'], ['hello', 'cruel', 'hello'], ['hello', 'beautiful', 'world']]
['hello', 'world', 'hello', 'cruel', 'hello', 'hello', 'beautiful', 'world']
可以看到flatMap相当于在map的基础上进行一个扁平化
'''

# 4.groupByKey
'''
把相同的key分发在一起
'''
def my_groupByKey():
    data = ["hello world", "hello cruel hello", "hello beautiful world"]
    rdd = sc.parallelize(data).flatMap(lambda line: line.split(" ")).map(lambda x: (x, 1))
    print(rdd.collect())
    groupByKeyRdd = rdd.groupByKey()
    # 只是这样打印看不出来结果
    print(groupByKeyRdd.collect())
    # 使用这种方法
    print(groupByKeyRdd.map(lambda x: (x[0], list(x[1]))).collect())

my_groupByKey()
'''
输出结果
[('hello', 1), ('world', 1), ('hello', 1), ('cruel', 1), ('hello', 1), ('hello', 1), ('beautiful', 1), ('world', 1)]

[('hello', <pyspark.resultiterable.ResultIterable object at 0x000002E04B3DBEF0>),
('beautiful', <pyspark.resultiterable.ResultIterable object at 0x000002E04B3DBF28>),
 ('world', <pyspark.resultiterable.ResultIterable object at 0x000002E04B3DBF98>),
 ('cruel', <pyspark.resultiterable.ResultIterable object at 0x000002E04B3E2048>)]

[('hello', [1, 1, 1, 1]), ('beautiful', [1]), ('world', [1, 1]), ('cruel', [1])]
因此将返回的迭代器进行一个list，会发现有很多的1，代表hello出现了4次，beautiful出现了1次，world出现了1次，cruel出现了1次

'''

# 5.reduceByKey
'''
把相同的key的数据分发到一起进行一个计算
和groupByKey类似，这个是在前者key出现的次数的基础上进行了一个汇总
'''
def my_reduceByKey():
    data = ["hello world", "hello cruel hello", "hello beautiful world"]
    rdd = sc.parallelize(data).flatMap(lambda line: line.split(" ")).map(lambda x: (x, 1))
    reduceByKeyRdd = rdd.reduceByKey(lambda x, y: x+y)
    print(reduceByKeyRdd.collect())

my_reduceByKey()
'''
输出结果
[('hello', 4), ('beautiful', 1), ('world', 2), ('cruel', 1)]
可以看到可以将出现的次数进行一个汇总
'''

# 6.sortByKey
'''
在reduceByKey的基础上进行排序
'''
def my_sortByKey():
    data = ["hello world", "hello cruel hello", "hello beautiful world"]
    rdd = sc.parallelize(data).flatMap(lambda line: line.split(" ")).map(lambda x: (x, 1))
    reduceByKeyRdd = rdd.reduceByKey(lambda x, y: x+y)
    sortByKeyRdd = reduceByKeyRdd.map(lambda x: (x[1], x[0])).sortByKey(False).map(lambda x: (x[1], x[0]))
    print(sortByKeyRdd.collect())

my_sortByKey()
'''
输出结果
[('hello', 4), ('world', 2), ('beautiful', 1), ('cruel', 1)]
'''

# 7.union
'''
将两个rdd进行合并
'''
def my_union():
    rdd1 = sc.parallelize([1, 2, 3])
    rdd2 = sc.parallelize([4, 5, 6])
    print(rdd1.union(rdd2).collect())

my_union()
'''
输出结果
[1, 2, 3, 4, 5, 6]
'''

# 8.distinct
'''
对rdd进行去重
'''
def my_distinct():
    rdd1 = sc.parallelize([1, 3, 3, 4, 4, 6])
    print(rdd1.distinct().collect())

my_distinct()
'''
输出结果
[4, 1, 6, 3]
注意，因为是并行计算所以不一定会有序
'''

# 9.join
'''
类似于关系型数据库里面的join
'''
def my_join():
    rdd1 = sc.parallelize([("A", "a1"), ("B", "b1"), ("C", "c1"), ("D", "d1")])
    rdd2 = sc.parallelize([("A", "a2"), ("C", "c2"), ("C", "c3"), ("E", "e1")])
    # 内连接
    print(rdd1.join(rdd2).collect())
    # 左外连接
    print(rdd1.leftOuterJoin(rdd2).collect())
    # 右外连接
    print(rdd1.rightOuterJoin(rdd2).collect())
    # 全连接
    print(rdd1.fullOuterJoin(rdd2).collect())
my_join()
'''
输出结果
[('C', ('c1', 'c2')), ('C', ('c1', 'c3')), ('A', ('a1', 'a2'))]

[('B', ('b1', None)), ('C', ('c1', 'c2')), ('C', ('c1', 'c3')), ('A', ('a1', 'a2')), ('D', ('d1', None))]

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

[('B', ('b1', None)), ('C', ('c1', 'c2')), ('C', ('c1', 'c3')),
('A', ('a1', 'a2')), ('D', ('d1', None)), ('E', (None, 'e1'))]
'''

'''
上面的是一些rdd的transformation操作，下面介绍rdd的action操作
'''
# 10.action
'''
action的常用操作主要有：collect，count，take，reduce，saveAsTextFile，foreach
'''
def my_action():
    data = list(range(10))
    rdd = sc.parallelize(data)
    # collect, 查看所有元素
    print("rdd.collect():", rdd.collect())
    # count, 获取元素的个数
    print("rdd.count():", rdd.count())
    # take, 获取元素的前几个
    print("rdd.take(3):", rdd.take(3))
    # max, 获取元素的最大值
    print("rdd.max(): ", rdd.max())
    # min, 获取元素的最小值
    print("rdd.min(): ", rdd.min())
    # sum, 获取元素的总和
    print("rdd.sum(): ", rdd.sum())
    # reduce, 和python里面的reduce类似，对每两个相邻的元素进行操作
    print("rdd.reduce(lambda x, y: x*y): ", rdd.reduce(lambda x, y: x*y))  # 如果改成x+y，那么等同于rdd.sum()
    print("rdd.reduce(lambda x, y: x+y): ", rdd.reduce(lambda x, y: x+y))

    # foreach, 可以用来打印每一个元素
    rdd.foreach(lambda x: print(x))
my_action()
'''
输出结果
rdd.collect(): [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
rdd.count(): 10
rdd.take(3): [0, 1, 2]
rdd.max():  9
rdd.min(): 0
rdd.sum(): 45
rdd.reduce(lambda x, y: x-y):  0, 因为我们列表里面含有0，所以相乘的结果是零
rdd.reduce(lambda x, y: x+y):  45
1
6
7
8
9
2
3
4
5  依旧是无序的
'''