**（转）**pyspark的使用和操作(基础整理)02

RDD间的操作

（1）如果有2个RDD，可以通过下面这些操作，对它们进行集合运算得到1个新的RDD

rdd1.union(rdd2): 所有rdd1和rdd2中的item组合（并集）
rdd1.intersection(rdd2): rdd1 和 rdd2的交集
rdd1.substract(rdd2): 所有在rdd1中但不在rdd2中的item（差集）
rdd1.cartesian(rdd2): rdd1 和 rdd2中所有的元素笛卡尔乘积（正交和）

import pyspark
from pyspark import SparkContext as sc
from pyspark import SparkConf
conf=SparkConf().setAppName(“miniProject”).setMaster(“local[*]”)
sc=SparkContext.getOrCreate(conf)

#初始化两个RDD
numbersRDD = sc.parallelize([1,2,3])
moreNumbersRDD = sc.parallelize([2,3,4])

numbersRDD.union(moreNumbersRDD).collect() #union()取并集

#Output:[1, 2, 3, 2, 3, 4]

numbersRDD.intersection(moreNumbersRDD).collect() #intersection()取交集

#Output:[2, 3]

numbersRDD.subtract(moreNumbersRDD).collect() #substract()取差集

#Output:[1]

numbersRDD.cartesian(moreNumbersRDD).collect() #cartesian()取笛卡尔积

#Output:[(1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4)]

（2）在给定2个RDD后，可以通过一个类似SQL的方式去join它们

from pyspark import SparkContext
from pyspark import SparkConf
conf=SparkConf().setAppName(“miniProject”).setMaster(“local[*]”)
sc=SparkContext.getOrCreate(conf)

Home of different people

homesRDD = sc.parallelize([
(‘Brussels’, ‘John’),
(‘Brussels’, ‘Jack’),
(‘Leuven’, ‘Jane’),
(‘Antwerp’, ‘Jill’),
])

Quality of life index for various cities

lifeQualityRDD = sc.parallelize([
(‘Brussels’, 10),
(‘Antwerp’, 7),
(‘RestOfFlanders’, 5),
])

homesRDD.join(lifeQualityRDD).collect() #join

#Output:
#[(‘Antwerp’, (‘Jill’, 7)),

homesRDD.leftOuterJoin(lifeQualityRDD).collect() #leftOuterJoin

#Output:
#[(‘Antwerp’, (‘Jill’, 7)),

homesRDD.rightOuterJoin(lifeQualityRDD).collect() #rightOuterJoin

#Output:
#[(‘Antwerp’, (‘Jill’, 7)),

homesRDD.cogroup(lifeQualityRDD).collect() #cogroup

#Output:

(homesRDD
.cogroup(lifeQualityRDD)
.map(lambda x:(x[0], (list(x[1][0]), list(x[1][1]))))
.collect())

#Output:

惰性计算，actions方法

特别注意：Spark的一个核心概念是惰性计算。当你把一个RDD转换成另一个的时候，这个转换不会立即生效执行！！！Spark会把它先记在心里，等到真的有actions需要取转换结果时，才会重新组织transformations(因为可能有一连串的变换)。这样可以避免不必要的中间结果存储和通信。

常见的action如下，当它们出现的时候，表明需要执行上面定义过的transform了:

collect(): 计算所有的items并返回所有的结果到driver端，接着 collect()会以Python list的形式返回结果
first(): 和上面是类似的，不过只返回第1个item
take(n): 类似，但是返回n个item
count(): 计算RDD中item的个数
top(n): 返回头n个items，按照自然结果排序
reduce(): 对RDD中的items做聚合

from pyspark import SparkContext
from pyspark import SparkConf
conf=SparkConf().setAppName(“miniProject”).setMaster(“local[*]”)
sc=SparkContext.getOrCreate(conf)

rdd = sc.parallelize(range(1,10+1))
rdd.reduce(lambda x, y: x + y) #reduce(): 对RDD中的items做聚合

#Output:55

reduce的原理：先在每个分区(partition)里完成reduce操作，然后再全局地进行reduce。

有时候需要重复用到某个transform序列得到的RDD结果。但是一遍遍重复计算显然是要开销的，所以我们可以通过一个叫做cache()的操作把它暂时地存储在内存中。缓存RDD结果对于重复迭代的操作非常有用，比如很多机器学习的算法，训练过程需要重复迭代。

from pyspark import SparkContext
from pyspark import SparkConf
conf=SparkConf().setAppName(“miniProject”).setMaster(“local[*]”)
sc=SparkContext.getOrCreate(conf)
import numpy as np
numbersRDD = sc.parallelize(np.linspace(1.0, 10.0, 10))
squaresRDD = numbersRDD.map(lambda x: x**2)

squaresRDD.cache() # Preserve the actual items of this RDD in memory

avg = squaresRDD.reduce(lambda x, y: x + y) / squaresRDD.count()
print(avg)

#Output:38.5

作者：Young_id
来源：优快云
原文：https://blog.youkuaiyun.com/cymy001/article/details/78483723
版权声明：本文为博主原创文章，转载请附上博文链接！