SPARKapi 的python版本

由于公司数据处理的主要语言是python，虽然前段时间用java做过一段时间，但是为了与我司保持步，所以对python的主要算法进行了下了解　

发现python还是比java要简洁一些

本文主要是讲解spark里RDD的基础操作。RDD是spark特有的数据模型，谈到RDD就会提到什么弹性分布式数据集，什么有向无环图，本文暂时不去展开这些高深概念，在阅读本文时候，大家可以就把RDD当作一个数组，这样的理解对我们学习RDD的API是非常有帮助的。

Spark里的计算都是操作RDD进行，那么学习RDD的第一个问题就是如何构建RDD，构建RDD从数据来源角度分为两类：第一类是从内存里直接读取数据，第二类就是从文件系统里读取，当然这里的文件系统种类很多常见的就是HDFS以及本地文件系统了。

## Spark Application - execute with spark-submit
#coding:utf-8
## Imports


from pyspark import SparkConf, SparkContext
APP_NAME="hello spark"

if __name__ == "__main__":
    # Configure Spark
    conf = SparkConf().setMaster("local[*]").setAppName(APP_NAME)
    sc = SparkContext(conf=conf)

    #将原RDD中每个元素代入带入func
    rdd =sc.parallelize([1,2,3,4,5])
    rdd = rdd.map(lambda x:x*x).collect()
    print rdd
    #[1, 4, 9, 16, 25]

    #filter(func) 返回包含所有在func中结果为True
    rdd = sc.parallelize([1, 2, 3, 4, 5])
    rdd=rdd.filter(lambda x:x>2).collect()
    print rdd
    #[3, 4, 5]

    #flatMap(func)将原RDD中的每一个元素映射为0个或者多个元素，每次map过程的返回值必须是集合（可空）
    rdd = sc.parallelize([1, 2, 3])
    rdd=rdd.flatMap(lambda x:range(1,x)).collect()
    print rdd
    #[1,1,2]

    #mapPartitions(func)
    #将func方法分别应用于各个分区
    def f(x):
        yield sum(x)
    rdd = sc.parallelize([1, 2, 3],2)
    rdd=rdd.mapPartitions(f).collect()
    print rdd
    #[1, 5]

    #mapPartitionsWithIndex(func)
    #和mapPartitions方法一样， func传入参数增加index
    def f(i,x):
        yield i*sum(x)


    rdd = sc.parallelize([1, 2, 3, 4], 2)
    rdd = rdd.mapPartitionsWithIndex(f).collect()
    print rdd
    #[0*1*3,1*(3+4)]
    #[0, 7]

    #sample(withReplacement, fraction, seed)
    #对已有的RDD进行采样,
    #withReplacement 布尔型， 表示是否用随机值替换
    #fraction 采样比例
    #seed 随机种子数
    rdd = sc.parallelize(range(100))
    rdd=rdd.sample(False, 0.2, 81).count()
    print rdd
    #19


    #union(RDD)
    #合并两个已有的RDD，返回新一个的新的RDD

    rdd1=sc.parallelize([1,2,3,4,5])
    rdd2=sc.parallelize([6,7,8,9,10])
    rdd2=rdd1.union(rdd2).collect()
    print rdd2
    #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    #intersection(RDD)
    #求两个RDD的交集，并去重，会引发洗牌操作
    rdd1=sc.parallelize([1,2,3,4,5])
    rdd2=sc.parallelize([4,5,6,7,8,9,10])
    rdd2=rdd2.intersection(rdd1).collect()
    print rdd2
    #[4,5]

    #distinct()
    #对RDD的元素去重
    rdd1=sc.parallelize([1,2,3,4,5,1,3])
    rdd1=rdd1.distinct().collect()
    print rdd1
    #[4, 1, 5, 2, 3]

    #reduceByKey()
    from operator import add

    rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
    rdd=rdd.reduceByKey(add).collect()
    print rdd
    #[('a', 2), ('b', 1)]

    #groupByKey()
    data = [('tom', 90), ('jerry', 97), ('luck', 92), ('tom', 78), ('luck', 64), ('jerry', 50)]
    rdd = sc.parallelize(data)
    print rdd.groupByKey().map(lambda x: (x[0], list(x[1]))).collect()
    #[('jerry', [97]), ('luck', [92, 64]), ('tom', [90, 78])]


    #sortByKey
    #对key的值进行排序
    data = [(5, 90), (1, 92), (3, 50)]
    rdd = sc.parallelize(data)
    rdd = rdd.sortByKey().collect()
    print rdd    
    #[(1, 92), (3, 50), (5, 90)]

SPARKapi 的python版本

猜你喜欢