RDD操作

RDD创建

从本地文件系统中加载数据创建RDD

1、启动spark

pyspark

• 从文件系统中加载数据创建RDD

sc #SparkContext的创建
lines = sc.textFile("file:///home/hjq/data/text.txt")
lines
lines.foreach(print)

从HDFS加载数据创建RDD

启动hdfs

start-all.sh

上传文件

hdfs dfs -mkdir /user/hjq/shiyan/   #新建文件夹
hdfs dfs -ls /user/hjq/   #查看目录
hdfs dfs -put /home/hjq/data/text.txt /user/hjq/shiyan/    #hdfs dfs -put 要上传的文件路径 上传目的路径

查看文件

hdfs dfs -ls /user/hjq/shiyan/  #查看目录
hdfs dfs -cat /user/hjq/shiyan/text.txt   #输出

加载

spark加载hdfs文件

lines = sc.textFile('hdfs://localhost:9000/user/hjq/shiyan/text.txt')
lines
lines.foreach(print)  #输出

停止hdfs

stop-all.sh
jps #查看是否关闭

通过并行集合（列表）创建RDD

输入列表、字符串、numpy生成数组

array = [1,2,3,4,5]
rdd = sc.parallelize(array)
rdd.foreach(print)

RDD操作

转换操作

filter(func)

筛选出满足函数func的元素，并返回一个新的数据集

显式定义函数

def f(line):
    b = "map" in line
    return(b)
 
lines = sc.textFile('file:///home/hjq/data/text.txt')
t = lines.filter(f)
t.foreach(print)

lambda函数

lines = sc.textFile('file:///home/hjq/data/text.txt')
linesWithSpark = lines.filter(lambda line: "map" in line)
linesWithSpark.foreach(print)

map(func)

将每个元素传递到函数func中，并将结果返回为一个新的数据集

字符串分词

显式定义函数

lines = sc.textFile('file:///home/hjq/data/text.txt')
def tt1(line):
	line = line.split(" ")
	return line

words = lines.map(tt1)
words.foreach(print)

lambda函数

lines = sc.textFile("file:///home/hjq/data/text.txt")
words = lines.map(lambda line:line.split(" "))
words.foreach(print)

数字加100

显式定义函数

data = [1,2,3,4,5]                                                          
rdd = sc.parallelize(data)
def add(x):
     return x+100

line = rdd.map(add)
line.foreach(print)

lambda函数

data = [1,2,3,4,5]
rdd1 = sc.parallelize(data)
rdd2 = rdd1.map(lambda x:x+100)
rdd2.foreach(print)

字符串加固定前缀

显示定义函数

data = ['python', 'hadoop', 'spark']
rdd = sc.parallelize(data)
def zz(x):
    return "good"+x

rdd2 = rdd.map(zz)
rdd2.foreach(print)

lambda函数

data = ['python', 'hadoop', 'spark']
rdd1 = sc.parallelize(data)
rdd2 = rdd1.map(lambda x:"good"+x)
rdd2.foreach(print)

flatMap(func)

分词

lines = sc.textFile('file:///home/hjq/data/text.txt')
words = lines.flatMap(lambda line:line.split(" "))
words.foreach(print)

单词映射成键值对

lines = sc.textFile('file:///home/hjq/data/text.txt')
words = lines.flatMap(lambda line:line.split()).map(lambda word:(word,1))
words.foreach(print)

reduceByKey()

统计词频，累加

data = [('python',1),('spark',1),('rdd',1),('big',1),('python',1),('spark',1),('rdd',1),('data',1),('big',1)]
words = sc.parallelize(data)
words2  = words.reduceByKey(lambda a,b:a+b)
words2.foreach(print)

乘法规则

data = [('python',3),('python',4),('spark',5),('rdd',1),('data',2),('big',3)]
words = sc.parallelize(data)
words2  = words.reduceByKey(lambda a,b:a*b)
words2.foreach(print)

groupByKey()

单词分组

data = [('python',3),('python',3),('spark',5),('rdd',1),('data',2),('spark',5),('rdd',1),('data',2),('big',4)]
words = sc.parallelize(data)
words2.groupByKey().foreach(print)

查看分组的内容

data = [('python',3),('spark',5),('rdd',1),('data',2),('big',4)]
words = sc.parallelize(data)
for i in words.groupByKey().collect():
	print(str(i[0])+':'+str([x for x in i[1]]))

分组之后做累加 map

data = [('python',3),('spark',5),('spark',5),('rdd',1),('big',4),('rdd',1),('data',2),('big',4)]
words = sc.parallelize(data)
words.groupByKey().map(lambda x: (x[0],sum(x[1]))).foreach(print)

sortByKey()

词频统计按单词排序

data = [('python',3),('spark',5),('rdd',1),('data',2),('big',4)]
words = sc.parallelize(data)
words.sortByKey().foreach(print)

sortBy()

词频统计按词频排序

data = [('python',3),('spark',5),('rdd',1),('data',2),('big',4)]
words.sortBy(lambda x:x[1], True).collect()  #升

words.sortBy(lambda x:x[1], False).collect()  #降

行动操作

foreach(print)

通过函数func(输入两个参数并返回一个值)聚合数据集中的元素

a_data = [1,2,3,4,5]
rdd = sc.parallelize(a_data)
rdd.foreach(print)

foreach(lambda a:print(a.upper())

el="hello world"
add=sc.parallelize(el)
add.foreach(lambda a:print(a.upper()))

collect()

以数组的形式返回数据集的所有元素

b_data = [1,2,3,4,5]
rdd = sc.parallelize(b_data)
rdd.collect()

count()

返回数据集中的元素个数

c_data =[1,2,3,4,5]
rdd =sc.parallelize(c_data)
rdd.count()

take(n)

以数组的形式返回数据集中的前n个元素

e_data = ['a','b','c','d','e']
rdd = sc.parallelize(e_data)
rdd.take(3)

reduce(func)

通过函数func(输入两个参数并返回一个值)聚合数据集中的元素

数值型的rdd元素做累加

e_data = [1,2,3,4,5]
rdd = sc.parallelize(e_data)
rdd.reduce(lambda a,b:a+b)

与reduceByKey区别

reduce——将RDD中元素前两个传给输入函数，产生一个新的return值，新产生的return值与RDD中下一个元素（第三个元素）组成两个元素，再被传给输入函数，直到最后只有一个值为止。

redeceByKey——对元素为KV对的RDD中Key相同的元素的Value进行binary_function的reduce操作，因此，Key相同的多个元素的值被reduce为一个值，然后与原RDD中的Key组成一个新的KV对。