大数据spark常用算子用法总结（个人学习笔记）

#coding=utf-8
#!/usr/bin/python

# from pyspark.sql import SQLContext, Row         #导入pyspark模块          
from pyspark import SparkContext, SparkConf
from pyspark.sql import SparkSession            #SparkSession 是 Spark SQL 的入口

“”"
该代码用于练习spark的各种算子操作，了解各种算子的具体用法
“”"

1.map算子

#map算子
def test_map():
    # map() 接收一个函数，把这个函数用于 RDD 中的每个元素，将函数的返回结果作为新的RDD
    spark = SparkSession.builder.appName("map").getOrCreate()  
    sc = spark.sparkContext  

    #map
    x= sc.parallelize([1,2,3])      #parallelize函数将列表转化为一个RDD对象
    y =x.map(lambda x:(x,x**2))
    print(x.collect())              
    print(y.collect())              
    #[1,2,3]
    #[(1,1),(2,4),(3,9)]

2.filter算子

在这里插入代码片def test_filter():
    #filter 挑选符合条件的结果
    spark =SparkSession.builder.appName("filter").getOrCreate()
    sc = spark.sparkContext
    
    # filter
    x = sc.parallelize([1,2,3])
    y = x.filter(lambda x: x %2 == 1)
    print(x.collect())          
    print(y.collect())

    #[1,2,3]
    #[1,3]

3.flatMap算子

def test_flatMap():
    # 与map类似，将原RDD中的每个元素通过函数f转换为新的元素，并将这些元素放入一个集合，构成新的RDD
    spark =SparkSession.builder.appName("flatMap").getOrCreate()
    sc = spark.sparkContext

    #flatMap
    x = sc.parallelize([[1,2,3],[4,5,6]])
    y = x.flatMap(lambda x :x)
    print(x.collect())
    print(y.collect())

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

4.reduceByKey算子

def test_reduceByKey():
    """ 
    reduceByKey将相同key的前两个value传给输入函数，产生一个新的return值，
    新产生的return值与下一个value（第三个元素）组成两个元素，再被传给输入函数，直到最后只有一个值为止。
    """
    spark =SparkSession.builder.appName("reduceByKey").getOrCreate()
    sc = spark.sparkContext

    x = sc.parallelize([('B',1),('B',2),('A',3),('A',4),('A',5)])
    y = x.reduceByKey(lambda x,y:x+y)
    print(x.collect())
    print(y.collect())

    # [('B',1),('B',2),('A',3),('A',4),('A',5)]
    # [('A', 12), ('B', 3)]

5.groupByKey算子

def test_groupByKey():
    # groupByKey 按照key进行分组，直接进行shuffle
    spark =SparkSession.builder.appName("groupByKey").getOrCreate()
    sc = spark.sparkContext

    x = sc.parallelize([('B',1),('B',2),('A',3),('A',4),('A',5)])
    y = x.groupByKey()
    print(x.collect())
    print([(j[0],[i for i in j[1]]) for j in y.collect()])
    
    #[('B',1),('B',2),('A',3),('A',4),('A',5)]
    #[('A', [3, 4, 5]), ('B', [1, 2])]

6.aggregateByKey算子

def test_aggregateByKey():
    """
    aggregateByKey， 先说分为三个参数的：
    第一个参数是， 每个key的初始值
    第二个是个函数， Seq Function， 经测试这个函数就是用来先对每个分区内的数据按照key分别进行定义进行函数定义的操作
    第三个是个函数， Combiner Function， 对经过 Seq Function 处理过的数据按照key分别进行进行函数定义的操作
    """
    # 按分区聚合,再总的聚合,每次要跟初始值交流
    spark =SparkSession.builder.appName("aggregateByKey").getOrCreate()
    sc = spark.sparkContext

    x = sc.parallelize([('B',1),('B',2),('A',3),('A',4),('A',5)])
    zeroValue = []
    mergeVal = (lambda aggregated,el:aggregated + [(el,el**2)])
    mergeComb = (lambda agg1,agg2: agg1+agg2)
    y = x.aggregateByKey(zeroValue,mergeVal,mergeComb)
    print(x.collect())
    print(y.collect())

    # [('B',1),('B',2),('A',3),('A',4),('A',5)]
    # [('A', [(3, 9), (4, 16), (5, 25)]), ('B', [(1, 1), (2, 4)])]

7.union算子

def test_union():
    # 将两个RDD合并，不去重
    spark =SparkSession.builder.appName("union").getOrCreate()
    sc = spark.sparkContext

    #union
    x = sc.parallelize(['A','A','B'])
    y = sc.parallelize(['D','C','A'])
    z = x.union(y)
    print(x.collect())
    print(y.collect())
    print(z.collect())

    # ['A','A','B'] ['D','C','A']
    # ['A', 'A', 'B', 'D', 'C', 'A']

8.take算子

def test_take():
    # take函数用于获取RDD中从0到num-1下标的元素（不排序）
    spark =SparkSession.builder.appName("take").getOrCreate()
    sc = spark.sparkContext

    #take
    x = sc.parallelize([1,3,1,2,3])
    y = x.take(num=3)
    print(x.collect())
    print(y)
    
    #[1, 3, 1, 2, 3]
    #[1, 3, 1]

9.first算子

def test_first():
    # first返回RDD中的第一个元素，不排序
    spark =SparkSession.builder.appName("first").getOrCreate()
    sc = spark.sparkContext

    #first
    x = sc.parallelize([1,3,1,2,3])
    y = x.first()
    print(x.collect())
    print(y)

    # [1, 3, 1, 2, 3]
    # 1

10.foreach算子

def test_foreach():
    # foreach:用于遍历RDD,将函数f应用于每一个元素，无返回值(action算子)。
    spark =SparkSession.builder.appName("foreach").getOrCreate()
    sc = spark.sparkContext

    #foreach
    def f(x) :
        print(x)
    x = sc.parallelize([1,2,3,4,5])
    y = x.foreach(f)        #先输出y值，因为y调用了f函数，里面包含了print
    print(x.collect())      #这一步才会执行打印x
    print(y)            

    # 1
    # 2
    # 3
    # 4
    # 5
    # [1, 2, 3, 4, 5]
    # None

11.count算子

def test_count():
    # count用于统计RDD中元素个数
    spark =SparkSession.builder.appName("count").getOrCreate()
    sc = spark.sparkContext

    #count
    x = sc.parallelize([1,3,2])
    y = x.count()
    print(x.collect())
    print(y)

    # [1, 3, 2]
    # 3

12.collect算子

def test_collect():
    """
    如果数据量比较大的时候，尽量不要使用collect函数，因为这可能导致Driver端内存溢出问题。
    建议使用rdd.take(100).foreach(println)，
    而不使用rdd.collect().foreach(println)
    """
    spark =SparkSession.builder.appName("collect").getOrCreate()
    sc = spark.sparkContext

    #collect
    x = sc.parallelize([1,2,3])
    y = x.collect()
    print(x)
    print(y)
    
    # ParallelCollectionRDD[0] at parallelize at PythonRDD.scala:184
    # [1, 2, 3]

13.sample算子

def test_sample():