pyspark使用小结

 --》org.apache.spark帮助文档
--》帮助文档的使用
在左侧搜索框中输入包名
在右侧中查看相应函数及其用法
例rdd中的RDD类具有函数repartition
则输入rdd则会显示相应类RDD
包-》类-》函数 的搜索
--》sparknet
用于连接caffe需要下载
--》spark-bin-hadoop
含有hadoop的spark
-->
   下载程序包，解压到目录(设解压后的为www)
   gedit /etc/profile之后
XX_HOME=解压的目录/www
PATH=$XX_HOME/bin:$PATH
   source /etc/profile
--》spark-submit用于提交任务
运行成功的一个在.submission.sh文件中有如下，运行./submission.sh即可
/home/jswang/hadoop/spark-1.5.2-bin-hadoop2.6/bin/spark-submit --class com.wang.FlumeEventCount --master spark://DELL-DL:7077 --jars /home/jswang/someconf/spark-streaming-flume_2.10-1.6.0.jar,/home/jswang/someconf/flume-ng-sdk-1.6.0.jar /home/jswang/someconf/savelocal.jar 166.111.135.99 33333

--》submit运行自带例子
 ./bin/spark-submit --class org.apache.spark.examples.SparkPi --master local[2] lib/spark-examples-1.5.2-hadoop2.6.0.jar 100
--》自己的hello,world及其spark-submit运行
1.新建工程：创建hello文件，下面创建src,lib文件
2.编辑文件：在src中创建hello.scala内容为hw.scala内容为
object Hi{def main(args:Array[String])=println("Hi!")}
3.编译代码：在工程目录下执行sbt package,则在target目录下的scala-2.10目录生成了.jar文件
4.运行程序：在工程目录下执行spark-submit --class Hi target/scala-2.10/hello_2.10-0.1-SNAPSHOT.jar（hello为工程文件夹的名称）
则会显示Hi！
--》自己的wordCount及其spark-submit运行
1.新建工程：创建wordCount文件夹，在其下创建,src,lib文件夹
在src下创建 main/scala文件夹，并在其下创建wordCount.scala文件
 将spark-1.5.2-bin-hadoop2.6/lib下的spark-assembly-1.5.2-hadoop2.6.0.jar复制到该工程的lib中
2.在wordCount.scala文件中输入下面的代码：
import org.apache.spark.{SparkContext,SparkConf}
import org.apache.spark.SparkContext._
object wordCount{
def main(args:Array[String]){
        if (args.length == 0) {
        System.err.println("Usage bin/spark-submit [options] --class wordCount wordCount.jar <file1:URI>")
        System.err.println("Usage bin/spark-submit [options] --class wordCount wordCount.jar hdfs://172.16.1.141:9000/test.txt")
        System.exit(1);
}
        val conf = new SparkConf().setAppName("WordCount")
        val sc = new SparkContext(conf)
        val doc = sc.textFile(args(0)) //用textFile来加载一个文件创建RDD
        println(doc.first)
println(doc.count)
        }
}
3.编译：回到工程的目录(必须回到有src的目录)，开始使用下面代码编译
sbt package
则会在wordCount下创建target/scala-2.10/wordcount_2.10-0.1-SNAPSHOT.jar
4.运行：
spark-submit --class wordCount  target/scala-2.10/wordcount_2.10-0.1-SNAPSHOT.jar file:///home/zhaodz/sbt/wordCount/count.txt
则会看到 count.txt的第一行
--》启动spark-shell
直接输入spark-shell即可，其他参数默认
--》使用spark-shell运行计数
textFile.first()
textFile.count()
--》在spark-shell中创建DataFrame
1.输入 spark-shell启动spark shell
2.分别输入如下内容
scala》》scala
res0: org.apache.spark.SparkContext = org.apache.spark.SparkContext@1c3cfced
scala》val sqlContext = new org.apache.spark.sql.SQLContext(sc)
sqlContext: org.apache.spark.sql.SQLContext = org.apache.spark.sql.SQLContext@684f9842
df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
scala》》df.show()
+----+-------+
| age|   name|
+----+-------+
|null|Michael|
|  30|   Andy|
|  19| Justin|
+----+-------+
scala> df.printSchema
root
 |-- age: long (nullable = true)
 |-- name: string (nullable = true)
scala> df.select("name").show()

+-------+
|   name|
+-------+
|Michael|
|   Andy|
| Justin|
+-------+
就像sql（或者）表格的查询语句一样
scala> val df_filter = df.filter("age>20")
scala> df_filter.show
+---+----+
|age|name|
+---+----+
| 30|Andy|
+---+----+
就像sql语句的过滤语句
scala>var df2 = df.repartition(2)
scala>df2.foreachPartition(a=>println(a.size))
2
1
3.注意
若是用$SPARK_HOME则软件中必须设置
--》集合（数组）创建RDD
启动spark-shell，分别输入
val data = Array(1,2,3,4,5)
data: Array[Int] = Array(1, 2, 3, 4, 5)
val distData = sc.parallelize(data)
distData: org.apache.spark.rdd.RDD[Int]
distData.reduce((a,b)=>a+b)
--》spark常用包
org.apache.spark.rdd.RDD
import org.apache.spark.SparkContext
import 
import org.apache.spark.SparkConf
import org.apache.spark.sql.DataFrame

--》saveAsTextFile的理解
>val a = Array(1,2,3,4,5)
>b = sc.parallelize(a)
将会在文件夹中看到很多part-n的文件，其中一些是没有内容的，其余的分别为1-5个数值的存储
>b.repartition(1).saveAsTextFile("file:///home/zhaodz/keshan/keshantwo")
  则只会看到一个part-00000文件里面分别有1 2 3 4 5 个数
>b.repartition(3).saveAsTextFile("file:///home/zhaodz/keshan/keshanthree")
则会看到数据保存到三个文件中
--》对repartition的理解
将一堆平行平等的数据，分成几个部分，分成多少部分是用户自定义，至于怎么存储，是平均存还是一个个的存则交给电脑自行处理（交给worker进行处理，一般为worker的数量，请自行脑补）
--》对foreachrepartition的理解
-经典语录
spark的一切都是基于RDD的
--》似乎dataFrame不能进行增删改查，只能进行打碎这些形式上的操作
--》使用mapPartitions进行操作
scala> var rdd1 = sc.makeRDD(1 to 5,2)
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at makeRDD at <console>:21
scala> var rdd3 = rdd1.mapPartitions{x=>{
     | var result = List[Int]()
     |    var i= 0
     |    while(x.hasNext){
     |        i+=x.next()
     |    }
     |    result.::(i).iterator  //相当于result.::(i)变成一个新的列表之后，再变成包含列表所有元素的迭代器List.iterator
     | }}
rdd3: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[1] at mapPartitions at <console>:23
res0: Array[Int] = Array(3, 12) 其中3为1和2的和，12为3,4,5的和

显示数据块的数量
scala> rdd3.partitions.size
res1: Int = 2

显示RDD
scala>println(rdd3.collect.mkString(" "))
3 12
--》显示RDD内容
scala> var rdd1 = sc.makeRDD(1 to 5,2)
显示全部
scala>rdd1.collect().foreach(println)
1
2
3
4
5
显示部分行
scala>rdd1.take(2).foreach(println)
1
2

--》RDD的操作
--》将RDD转化为一个scala数组并返回
scala> val a = sc.makeRDD(1 to 5 ,2)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[2] at makeRDD at <console>:21
scala> a.collect //将分散的收集起来
res3: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.count //返回RDD的元素个数
res4: Long = 5
--》org.apache.rdd.RDD函数foreach的使用
scala> var rdd = sc.makeRDD(1 to 10,2)
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at makeRDD at <console>:21
scala> rdd.foreach(println)
6
1
7
2
8
9
3
10
4
5
scala> rdd.collect.foreach(println)
1
2
3
4
5
6
7
8
9
10

--》StructType类的使用
import org.apache.spark.sql.types._  
val schema = StructType(StructField("data", ArrayType(FloatType), false) :: StructField("label", IntegerType, false) :: Nil) //::两侧必需有空格，必需有Nil，必须有_(先声明再使用，_表示代替了所有的名词)
scala> struct("data").dataType
res1: org.apache.spark.sql.types.DataType = ArrayType(FloatType)

/home/zhaodz/program/spark_source/spark/sql/catalyst/src/main/scala/org/apache/sql/types/StructType.scala
--》SQLContext类的使用
val sqlContext = new org.apache.spark.sql.SQLContext(sc)
或者
import org.apache.spark.sql._
val sqlContext = new SQLContext(sc)
-->RDD类的使用
scala> val a = sc.parallelize(1 to 9, 3) //从普通数组创建RDD，里面包含了9个数字，分别在3个分区
scala>a.saveAsTextFile("file:///home/zhaodz/keshan/keshankdks") //可看到并行存储到了三个文件中
scala> val b = a.map(x => x*2)          //map函数的使用，map即使用函数进行映射
scala> a.collect //收集并行的返回scala的数组
res10: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> b.collect //可看到b是a的映射
res11: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18)
或者通过mkStrig函数进行查看
scala> println(b.collect().mkString(" "))
--》区域org.apache.spark.sql中类的使用
使用方法
1.import法,import org.apache.spark.sql._即可以使用下面所有的类
2.全名称法 如val sqlContext = new org.apache.spark.sql.SQLContext(sc)
ROW类使用
scala> val row = Row("str1","str2")
row: org.apache.spark.sql.Row = [str1,str2]
scala> row(0)
res10: Any = str1
SQLContext类使用
def  createDataFrame(rowRDD: RDD[Row], schema: StructType): DataFrame
DataFrame类使用
def  repartition(numPartitions: Int): DataFrame
def  cache()
def  foreach(f: (Row) ? Unit): Unit
def  foreachPartition(f: (Iterator[Row]) ? Unit): Unit
def  mapPartitions[R](f: (Iterator[Row]) ? Iterator[R])(implicit arg0: ClassTag[R]): RDD[R]
--》区域org.apache.spark中类的使用
  SparkConf类的使用
  SparkContext类的使用
def  broadcast[T](value: T)(implicit arg0: ClassTag[T]): Broadcast[T]
  一般使用方法
import org.apache.spark.{SparkContext,SparkConf}
val conf = new SparkConf().setAppName("WordCount")
val sc = new SparkContext(conf)
sc.parallelize（）
-->初始化spark
import org.apache.spark.{SparkContext,SparkConf}
val conf = new SparkConf().setAppName("name")
val sc = new SparkContext(conf)
--》从一般数据创建DataFrame实例
scala> var name = Array("zhao")  //都为Array形式
scala> var score = Array(98)
scala> var rdd = sc.parallelize(name.zip(score))
scala> import org.apache.spark.sql.types._
//（下面）表格个列每个单元格的数据类型
scala> var schema = StructType(StructField("name",StringType,false)::StructField("score",IntegerType,false)::Nil)
scala> val sqlContext = new org.apache.spark.sql.SQLContext(sc) //固定
scala> import org.apache.spark.sql.{DataFrame, Row} //固定
scala> var dataFrame = sqlContext.createDataFrame(rdd.map{case(a,b)=>Row(a,b)},schema)
scala> dataFrame.show
-->从一般数据创建DataFrame实例2
spark-shell中直接复制如下
import org.apache.spark.sql._
import org.apache.spark.sql.types._

val row1 = Row("Bruce Zhang", "developer", 38 )
val row2 = Row("Zhang Yi", "engineer", 39)
val table = List(row1, row2)
val rows = sc.parallelize(table)

val schema = StructType(Array(StructField("name", StringType, true),StructField("role", StringType, true), StructField("age", IntegerType, true)))
val dd  = sqlContext.createDataFrame(rows, schema)
dd.show
+-----------+---------+---+
|       name|     role|age|
+-----------+---------+---+
|Bruce Zhang|developer| 38|
|   Zhang Yi| engineer| 39|
+-----------+---------+---+
//固定
--》从list中分割子list
slice(from: Int, until: Int): List[A] 提取列表中从位置from到位置until(不含该位置)的元素列表
scala> val nums = List(1,2,3,4,5)
nums: List[Int] = List(1, 2, 3, 4, 5)

scala> nums.slice(2,4)
res20: List[Int] = List(3, 4)
posted @ 2018-04-17 09:57  开往春天的拖拉机  阅读(1560)  评论(0)  编辑  收藏  举报