基础代码：
01.start-all.sh 启动Hadoop集群
02.start-master.sh 启动spark节点master
03.start-slaves.sh 启动spark节点slaves
04.pyspark --help：获取完整命令
05.pyspark ：获取版本信息
06.exit() :退出环境
一.进入环境
pyspark --master <master-url> （进入环境） -- jars code.jar (可以使用jar包)
<master-url> == 本地：
local、默认local【*】
local[*]使用逻辑cpu数量本地化运行spark、
local[K]使用k个线程本地化spark、
spark://HOST:PORT 连接Spark standalone master、
<master-url> == yarn ：
yarn - 默认client
yarn-client 以客户端连接yarn集群一般用于调试程序、
yarn-cluster 以集群模式连接yarn集群一般用于生产上线、集群位置在HADOOP_CONF_DIR
mesos://HOST:PORT
二. 使用集群命令
三. 使用pyspark命令
导入pyspark
读取文件
例子：
1 from pyspark import SparkConf,SparkContext
2 conf = SparkConf().setMasTer("local").setAppName("My App")
3 sc = SparkContext(conf=conf)
4 logFile = '数据位置'
5 logData = sc.textFile(logFile,2).cache()
6 numAs = logData.filter(lambda line:'a' in line).count()
7 numAs = logData.filter(lambda line:'b' in line).count()
8 print('Lines with a:%s,Lines with b:%s'%(numAs,numBs))综合rdd编程实例：
四. RDD编程（交互式窗口 ）
1.RDD创建==
文件系统加载（SparkContext(路径、AWS等)）：
本地路径 = （"hdfs://localhost:9000/..../work.txt"） = （''/user/hadoop/work.txt"） #9000为系统设置 = ("work.txt")
#例子
1 line = sc.textFile("路径") #sc默认
2 line.foreach(print)通过并行集合（数组）创建RDD：
parallelize方法
1 array = [1,2,3,4,5]
2 rdd = sc.parallelize(array)
3 rdd.foreach(print)#查看并打印2.转换操作（filter，map，flatMap，groupByKey()，reduceByKey(func)）惰性机制不会计算
filter，筛选满足func的元素，返回新的数据集
line_new = line.filter(lambda line:"Spark" in line)map，传递
line_new = line.map(lambda line:line.split(" "))flatMap，映射将map得到的array里的每一个元素flat得到一个个单独的元素
line_new = line.flatMap(line:line.split(" "))groupByKey()，对键值对的rdd进行操作
1
2 words = sc.parallelize([(key,value),(key,value)])
3 word1 = woreds.groupByKey()
4 word1.foreach(print)#查看并打印reduceByKey(func)
words1 = words.reduceByKey(lambda a,b:a+b)
words1.foreach(print)#查看并打印3.行动操作-进行计算（从头到尾计算：多次行动操作会多次计算rdd，解决办法持久化）
* count() 返回元素数量
* collect() 以数组形式返回数据集中所有元素
* frist() 返回数据集中第一个元素
* take(n) 以数组返回数据集中前n个元素
* reduce(func) 通过函数func（输入两个参数返回一个值）聚合数据集中的元素
* foreach(func) 将数据集中每个元素传递到函数func中运行
五、持久化
什么是持久化：第一次行动操作后被标记的rdd计算后会持久化放入缓存中
rdd.persist()方法：标记为持久化
参数：rdd.persist(MEMORY_ONLY) = rdd.cache()，内存不足替换内容（最近最少使用原则）
rdd.persist(MEMORY_AND_DISK)，内存不足存放磁盘
rdd.unpersist()方法：消除持久化的rdd
六、分区
1.优点
增加并行度：分区后可以在多个节点进行同时计算
减少通讯开销：进行两表连接时不用对不同分块的数据进行挑选会有昂贵的通讯开销，分区后可以在块里的数据提前分好在进行连接时不用再去不同块挑选而是直接使用。
2.使用分区
默认分区数：默认本地cpu数
设置参数：data = sc.parallelize(list,2) #设置分区数量为2
rdd = data.repartition(1) #重新分区
len(rdd.glom().collect()) #查看分区数量
3.自定义分区方式：
根据key的尾数分区：
from pyspark import sparkconf,sparkcontext
def MyPartitioner(key):
print("MyPartitioner is running")
print("the key is %d"%key)
return key%10
def main():
print("the main is running")
conf = SparkConf().setMaster("local").setAppName("MyApp")
sc = SparkContext(conf = conf)
data = sc.parallelize(range(10),5)
data.map(lambda x:(x,1))\ #将data转换为键值对
.partitionBy(10,MyPartitoner)\ #只接受键值对
.map(lambda x:x[0])\ #把键值对取出再把键值对的第一个元素给x
.saveAsTextFile("file://usr/local/spark/mycode/rdd/partitooner") #由于有10个分区#那么会生成10个文件
if __name__ =='__main__':
main()运行自定义分区函数：python3 TesPartitioner.py（py文件名称）
进入spark的bin/spark-submit TesyPartitioner.py
七、键值对RDD
1.创建rdd
文件加载
line = sc.textFile("路径")
pairRdd = line.flatMap(lambda line:line.split(" ").map(lambda word:(word,1)))
pairRdd.foreach(print)通过并行集合（列表）创建Rdd
list = ['python','spark']
rdd = sc.parallelize(list)
pairRdd = rdd,map(lambda word :(word,1))
pairRdd.foreach(print)2.转换操作
keys、values：
groupByKey()：
reduceByKey(func):通过key使用func进行聚合计算
PairRdd.reduceByKey(lambda a,b:a+b).foreach(print)combineByKey：
join：
mapValues(func)：
sortByKey()：
八、数据读写
1.本地文件数据读写
