2021-02-17 大数据课程笔记 day28

最新推荐文章于 2021-11-08 14:46:03 发布
最新推荐文章于 2021-11-08 14:46:03 发布
阅读量228 收藏
点赞数
分类专栏： 西行日记 文章标签： 编程语言 大数据 多线程 Scala Spark WordCount
I love 段奥娟
本文链接：https://blog.csdn.net/qq_44745905/article/details/113831407
版权

时间煮雨
@R星校长

Scala第二天【Scala内容】

主要内容

  1. Scala 迭代器模式处理数据
  2. ScalaTrait 特质特性
  3. Scala 模式匹配
  4. Scala 偏函数
  5. Scala 样例类
  6. Scala 隐式转换
  7. Scala Actor 通信模型
  8. Spark WordCount

学习目标在这里插入图片描述

第一节 Scala 迭代器模式 + Trait 特质特性

Scala迭代器模式处理数据

scala 中创建集合需要内存，集合与集合之间的转换时，每次转换生成新的集合时，新的集合也需要内存。如果有一个非常大的初始集合，需要经过多次转换，每次转换都生成一个新的集合，才能得到最终的结果，那么这时，在集合转换过程中内存开销非常大。Scala 迭代器模式处理数据，很好的解决了内存占用大的问题。
Scala 迭代器模式处理数据每次将集合的转换转变成了迭代器之间的转换，迭代器是不需要占用内存存储的，迭代器只是一个指针，指向了最初的原始数据，这样，数据处理过程中内存占用非常小。

迭代器模式处理示例：

1.	//非迭代器模式处理，浪费内存
2.	val list1 = List[String]("hello java","hello python","hello scala")
3.	val list2 = list1.flatMap(one=>{one.split(" ")})
4.	val list3 = list2.map(one=>{one+"#"})
5.	list3.foreach(println)
6.	
7.	println("********************")
8.	
9.	//迭代器模式处理，内存小
10.	val list = List[String]("hello java","hello python","hello scala")
11.	val iter1 = list.iterator
12.	val iter2 = iter1.flatMap(one=>{one.split(" ")})
13.	val iter3 = iter2.map(one=>{one+"#"})
14.	while(iter3.hasNext){
15.	  val one = iter3.next()
16.	  println(one)
17.	}

Trait 特质特性

  1. 概念理解
    Scala Trait (特质) 相当于 Java 的接口，实际上它比接口还功能强大。与接口不同的是，它还可以定义属性和方法的实现。
    一般情况下 Scala 的类可以继承多个 Trait，从结果来看就是实现了多重继承。第一个关键字使用 extends，之后使用 with。
    Trait (特质) 定义的方式与类类似，但它使用的关键字是 trait。
  2. 举例：trait 中带属性带方法实现
    注意：
  • 继承的多个 trait 中如果有同名的方法和属性，必须要在类中使用 “override” 重新定义。
  • trait 中不可以传参数
1.	trait Read {
2.	  val readType = "Read"
3.	  val gender = "m"
4.	  def read(name:String){
5.	    println(name+" is reading")
6.	  }
7.	}
8.	
9.	trait Listen {
10.	  val listenType = "Listen"
11.	  val gender = "m"
12.	  def listen(name:String){
13.	    println(name + " is listenning")
14.	  }
15.	}
16.	
17.	class Person() extends Read with Listen{
18.	  override val gender = "f"
19.	}
20.	
21.	object test {
22.	  def main(args: Array[String]): Unit = {
23.	    val person = new Person()
24.	    person.read("zhangsan")
25.	    person.listen("lisi")
26.	    println(person.listenType)
27.	    println(person.readType)
28.	    println(person.gender)
29.	
30.	  }
31.	}
  1. 举例：trait 中带方法不实现
1.	object Lesson_Trait2 {
2.	  def main(args: Array[String]): Unit = {
3.	    val p1 = new Point(1,2)
4.	    val p2 = new Point(1,3)
5.	    println(p1.isEqule(p2))
6.	    println(p1.isNotEqule(p2))
7.	  }
8.	}
9.	
10.	trait Equle{
11.	  def isEqule(x:Any) :Boolean 
12.	  def isNotEqule(x : Any) = {
13.	     !isEqule(x)
14.	  }
15.	}
16.	
17.	class Point(x:Int, y:Int) extends Equle {
18.	  val xx = x
19.	  val yy = y
20.	
21.	  def isEqule(p:Any) = {
22.	    p.isInstanceOf[Point] && p.asInstanceOf[Point].xx==xx
23.	  }
24.	
25.	}
第二节 Scala 模式匹配+偏函数

模式匹配

  1. 概念理解：
    Scala 提供了强大的模式匹配机制，应用也非常广泛。
    一个模式匹配包含了一系列备选项，每个都开始于关键字 case。
    每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。
  2. 代码及注意点
  • 模式匹配不仅可以匹配值还可以匹配类型
  • 从上到下顺序匹配，如果匹配到则不再往下匹配
  • 都匹配不上时，会匹配到 case _ ,相当于 default
  • match 的最外面的 “{ }” 可以去掉看成一个语句
1.	object Lesson_Match {
2.	  def main(args: Array[String]): Unit = {
3.	    val tuple = Tuple6(1,2,3f,4,"abc",55d)
4.	    val tupleIterator = tuple.productIterator
5.	    while(tupleIterator.hasNext){
6.	      matchTest(tupleIterator.next())
7.	    }
8.	  
9.	   }
10.	  /**
11.	   * 注意点：
12.	   * 1.模式匹配不仅可以匹配值，还可以匹配类型
13.	   * 2.模式匹配中，如果匹配到对应的类型或值，就不再继续往下匹配
14.	   * 3.模式匹配中，都匹配不上时，会匹配到 case _ ，相当于default
15.	   */
16.	  def matchTest(x:Any) ={
17.	    x match {
18.	      case x:Int=> println("type is Int")
19.	      case 1 => println("result is 1")
20.	      case 2 => println("result is 2")
21.	      case 3=> println("result is 3")
22.	      case 4 => println("result is 4")
23.	      case x:String => println("type is String")
24.	      // case x :Double => println("type is Double")
25.	      case _ => println("no match")
26.	    }
27.	  }
28.	
29.	}

偏函数

如果一个方法中没有 match 只有 case，这个函数可以定义成 PartialFunction 偏函数。偏函数定义时，不能使用括号传参，默认定义 PartialFunction 中传入一个值，匹配上了对应的 case,返回一个值，只能匹配同种类型。

1.	/**
2.	 * 一个函数中只有case 没有match ，可以定义成PartailFunction 偏函数
3.	 */
4.	 object Lesson_PartialFunction {
5.	  def MyTest : PartialFunction[String,String] = {
6.	     case "scala" =>{"scala"}
7.	     case "hello"=>{"hello"}
8.	     case _=> {"no match ..."}
9.	  }
10.	  def main(args: Array[String]): Unit = {
11.	     println(MyTest("scala"))
12.	  }
13.	}
第三节 Scala样例类+隐式转换

样例类(case classes)

  1. 概念理解
    使用了 case 关键字的类定义就是样例类 (case classes)，样例类是种特殊的类。实现了类构造参数的 getter 方法（构造参数默认被声明为 val），当构造参数是声明为 var 类型的，它将帮你实现 setter 和 getter 方法。
  • 样例类默认帮你实现了 toString , equals , copy 和 hashCode 等方法。
  • 样例类可以 new, 也可以不用 new
  1. 例子：结合模式匹配的代码
1.	case class Person1(name:String,age:Int)
2.	
3.	object Lesson_CaseClass {
4.	  def main(args: Array[String]): Unit = {
5.	    val p1 = new Person1("zhangsan",10)
6.	    val p2 = Person1("lisi",20)
7.	    val p3 = Person1("wangwu",30)
8.	
9.	    val list = List(p1,p2,p3)
10.	    list.foreach { x => {
11.	       x match {
12.	          case Person1("zhangsan",10) => println("zhangsan")
13.	          case Person1("lisi",20) => println("lisi")
14.	          case _ => println("no match")
15.	       }
16.	    } }
17.	
18.	  }
19.	}

隐式转换

隐式转换是在 Scala 编译器进行类型匹配时，如果找不到合适的类型，那么隐式转换会让编译器在作用范围内自动推导出来合适的类型。

  1. 隐式值与隐式参数
    隐式值是指在定义参数时前面加上 implicit。隐式参数是指在定义方法时，方法中的部分参数是由 implicit 修饰【必须使用柯里化的方式，将隐式参数写在后面的括号中】。隐式转换作用就是：当调用方法时，不必手动传入方法中的隐式参数，Scala 会自动在作用域范围内寻找隐式值自动传入。

隐式值和隐式参数注意：

1). 同类型的参数的隐式值只能在作用域内出现一次，同一个作用域内不能定义多个类型一样的隐式值。
2). implicit 关键字必须放在隐式参数定义的开头
3). 一个方法只有一个参数是隐式转换参数时，那么可以直接定义 implicit 关键字修饰的参数，调用时直接创建类型不传入参数即可。
4). 一个方法如果有多个参数，要实现部分参数的隐式转换,必须使用柯里化这种方式,隐式关键字出现在后面，只能出现一次

1.	object Lesson_ImplicitValue {
2.	
3.	  def Student(age:Int)(implicit name:String,i:Int)= {
4.	    println( s"student :$name ,age = $age ,score = $i")
5.	  }
6.	  def Teacher(implicit name:String) ={
7.	    println(s"teacher name is = $name")
8.	  }
9.	
10.	  def main(args: Array[String]): Unit = {
11.	    implicit val zs = "zhangsan"
12.	    implicit val sr = 100
13.	
14.	    Student(18)
15.	    Teacher
16.	  }
17.	}
  1. 隐式转换函数
    隐式转换函数是使用关键字 implicit 修饰的方法。当 Scala 运行时，假设如果 A 类型变量调用了 method() 这个方法，发现 A 类型的变量没有 method() 方法，而 B 类型有此 method() 方法，会在作用域中寻找有没有隐式转换函数将 A 类型转换成 B 类型，如果有隐式转换函数，那么 A 类型就可以调用 method() 这个方法。
    隐式转换函数注意：隐式转换函数只与函数的参数类型和返回类型有关，与函数名称无关，所以作用域内不能有相同的参数类型和返回类型的不同名称隐式转换函数。
1.	class Animal(name:String){
2.	  def canFly(): Unit ={
3.	    println(s"$name can fly...")
4.	  }
5.	}
6.	class Rabbit(xname:String){
7.	  val name = xname
8.	}
9.	object Lesson_ImplicitFunction {
10.	
11.	  implicit def rabbitToAnimal(rabbit:Rabbit):Animal = {
12.	     new Animal(rabbit.name)
13.	  }
14.	
15.	  def main(args: Array[String]): Unit = {
16.	    val rabbit = new Rabbit("RABBIT")
17.	    rabbit.canFly()
18.	  }
19.	}
  1. 隐式类
    使用 implicit 关键字修饰的类就是隐式类。若一个变量 A 没有某些方法或者某些变量时，而这个变量 A 可以调用某些方法或者某些变量时，可以定义一个隐式类，隐式类中定义这些方法或者变量，隐式类中传入 A 即可。
    隐式类注意：
    1).隐式类必须定义在类，包对象，伴生对象中。
    2).隐式类的构造必须只有一个参数，同一个类，包对象，伴生对象中不能出现同类型构造的隐式类。
1.	class Rabbit(s:String){
2.	  val name = s
3.	}
4.	
5.	object Lesson_ImplicitClass {
6.	
7.	  implicit class Animal(rabbit:Rabbit){
8.	    val tp = "Animal"
9.	    def canFly() ={
10.	      println(rabbit.name +" can fly...")
11.	    }
12.	  }
13.	
14.	  def main(args: Array[String]): Unit = {
15.	    val rabbit = new Rabbit("rabbit")
16.	    rabbit.canFly()
17.	    println(rabbit.tp)
18.	  }
19.	}
第四节 Scala Actor 通信模型
  1. 概念理解
  • Java 中的并发编程
    Java 中的并发编程是基于共享数据和加锁的一种机制，即会有一个共享的数据，然后有若干个线程去访问这个共享的数据(主要是对这个共享的数据进行修改)，同时 Java 利用加锁的机制(即 synchronized)来确保同一时间只有一个线程对我们的共享数据进行访问,进而保证共享数据的一致性。Java 中的并发编程存在资源争夺和死锁等多种问题，因此程序越大问题越麻烦。
  • Scala 中的并发编程
    Scala 中的并发编程思想与 Java 中的并发编程思想完全不一样，Scala 中的 Actor 是一种不共享数据，依赖于消息传递的一种并发编程模式， 避免了死锁、资源争夺等情况。在具体实现的过程中，Scala 中的 Actor 会不断的循环自己的邮箱，并通过 receive 偏函数进行消息的模式匹配并进行相应的处理。
    如果 Actor A 和 Actor B 要相互沟通的话，首先 A 要给 B 传递一个消息，B 会有一个收件箱，然后 B 会不断的循环自己的收件箱， 若看见 A 发过来的消息，B 就会解析 A 的消息并执行，处理完之后就有可能将处理的结果通过邮件的方式发送给 A。
    Actor Model 是用来编写并行计算或分布式系统的高层次抽象（类似 java 中的Thread）让程序员不必为多线程模式下共享锁而烦恼,被用在 Erlang 语言上, 高可用性 99.9999999 % 一年只有 31ms 宕机 Actors 将状态和行为封装在一个轻量的进程/线程中，但是不和其他 Actors 分享状态，每个 Actors 有自己的世界观，当需要和其他 Actors 交互时，通过发送事件和消息，发送是异步的，非堵塞的 (fire-andforget)，发送消息后不必等另外 Actors 回复，也不必暂停，每个 Actors 有自己的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，可以建立性能很好的事件驱动系统。
    Actor 的特征：
  • ActorModel 是消息传递模型,基本特征就是消息传递
  • 消息发送是异步的，非阻塞的
  • 消息一旦发送成功，不能修改
  • Actor 之间传递时，自己决定决定去检查消息，而不是一直等待，是异步非阻塞的
    什么是 Akka
    Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和Scala 的 Actor 模型应用，底层实现就是 Actor , Akka 是一个开发库和运行环境，可以用于构建高并发、分布式、可容错、事件驱动的基于 JVM 的应用。使构建高并发的分布式应用更加容易。
    spark1.6 版本之前，spark 分布式节点之间的消息传递使用的就是 Akka，底层也就是 actor 实现的。1.6 之后使用的 netty 传输。
  1. 例：Actor简单例子发送接收消息
1.	import scala.actors.Actor
2.	
3.	class myActor extends Actor{
4.	
5.	  def act(){
6.	    while(true){
7.	      receive {
8.	        case x:String => println("get String ="+ x)
9.	        case x:Int => println("get Int")
10.	        case _ => println("get default")
11.	      }
12.	    }
13.	  }
14.	}
15.	
16.	object Lesson_Actor {
17.	  def main(args: Array[String]): Unit = {
18.	
19.	    //创建actor的消息接收和传递
20.	    val actor =new myActor()
21.	    //启动
22.	    actor.start()
23.	    //发送消息写法
24.	    actor ! "i love you !"
25.	
26.	  }
27.	}
  1. 例：Actor 与 Actor 之间通信
1.	case class Message(actor:Actor,msg:Any)
2.	
3.	class Actor1 extends Actor{
4.	  def act(){
5.	    while(true){
6.	      receive{
7.	        case msg :Message => {
8.	          println("i sava msg! = "+ msg.msg)
9.	
10.	          msg.actor!"i love you too !"
11.	        }
12.	        case msg :String => println(msg)
13.	        case _ => println("default msg!")
14.	      }
15.	    }
16.	  }
17.	}
18.	
19.	class Actor2(actor :Actor) extends Actor{
20.	  actor ! Message(this,"i love you !")
21.	  def act(){
22.	    while(true){
23.	      receive{
24.	        case msg :String => {
25.	         if(msg.equals("i love you too !")){
26.	            println(msg)
27.	            actor! "could we have a date !"
28.	         }
29.	        }
30.	        case _ => println("default msg!")
31.	      }
32.	    }
33.	  }
34.	}
35.	
36.	object Lesson_Actor2 {
37.	  def main(args: Array[String]): Unit = {
38.	    val actor1 = new Actor1()
39.	    actor1.start()
40.	    val actor2 = new Actor2(actor1)
41.	    actor2.start()
42.	  }
43.	}
第五节 WordCount
  1. 创建 Maven 项目导入 pom.xml 文件
    安装 Maven 仓库管理工具，版本要求是 3.2 版本以上。新建 Maven 项目，配置 pom.xml。导入必要的包。
  2. Spark-Scala 版本的 WordCount
1.	val conf = new SparkConf()
2.	conf.setMaster("local")
3.	conf.setAppName("scala-wc")
4.	val sc = new SparkContext(conf)
5.	val lines = sc.textFile("./data/words")
6.	val words = lines.flatMap(line=>{line.split(" ")})
7.	val pairWords = words.map(word=>{new Tuple2(word,1)})
8.	val result = pairWords.reduceByKey((v1:Int,v2:Int)=>{v1+v2})
9.	result.foreach(println)
  1. Spark-Java 版本的 WordCount
1.	SparkConf conf = new SparkConf();
2.	conf.setMaster("local");
3.	conf.setAppName("java-wc");
4.	JavaSparkContext sc = new JavaSparkContext(conf);
5.	JavaRDD<String> lines = sc.textFile("./data/words");
6.	JavaRDD<String> words = lines.flatMap(new   FlatMapFunction<String, String>() {
7.	  @Override
8.	  public Iterator<String> call(String s) throws Exception {
9.	    String[] split = s.split(" ");
10.	    return Arrays.asList(split).iterator();
11.	  }
12.	});
13.	JavaPairRDD<String, Integer> pairWords = words.mapToPair(new PairFunction<String, String, Integer>() {
14.	  @Override
15.	  public Tuple2<String, Integer> call(String word) throws Exception {
16.	    return new Tuple2<>(word, 1);
17.	  }
18.	});
19.	JavaPairRDD<String, Integer> result = pairWords.reduceByKey(new Function2<Integer, Integer, Integer>() {
20.	  @Override
21.	  public Integer call(Integer v1, Integer v2) throws Exception {
22.	    return v1 + v2;
23.	  }
24.	});
25.	result.foreach(new VoidFunction<Tuple2<String, Integer>>() {
26.	  @Override
27.	  public void call(Tuple2<String, Integer> tuple2) throws  Exception {
28.	    System.out.println(tuple2);
29.	  }
30.	});
31.	sc.stop();

本节作业

  1. 掌握Scala迭代器处理数据模式
  2. 掌握Trait特质特性
  3. 掌握Scala 模式匹配
  4. 掌握Scala隐式转换
  5. 了解Actor通信模型
  6. 了解Spark WordCount
  7. 所有代码至少敲一遍
Rich Dad
关注
专栏目录
Scala集合总结
u010920561的博客
09-26 325
Scala集合总结 最近有时间看了一下Scala，总结了一下Scala集合，和大家分享一下。 1.基本概念 scala中的集合类可以分为三大类： 1.Seq，是一组有序的元素，比如List，Array 2.Set，是一组没有重复元素的集合。 3.Map，是一组k-v对。 Scala集合有三个基本操作： head 返回集合第一个元素 tail 返回一个集合，包含除了第一元素之外的其他元素 isEmp...
spark（04）
weixin_30653023的博客
08-06 93
join leftOuterjoin rightOuterJoin cogroup scala> var arr = Array(("zhangsan",200),("lisi",300),("wangwu",350)) arr: Array[(String, Int)] = Array((zhangsan,200), (lisi,300), (wa...
Scala 集合篇笔记（三）
VanasWang的博客
06-07 294
文章目录集合数组不可变数组可变数组foreach & 数组的操作Seq序列Nil可变Seq 增删改Set 数据集可变集合Map 映射可变Map遍历元组Tuple集合常用方法数据操作相关案例wordcountScala的练习作业:自定义排序交差合集 拉链 滑动计算相关简化规约reduce折叠fold扫描scan队列并行练习 集合 Scala都同时提供了可变和不可变的版本 scala.collection.immutable scala.collection.mutable 数组 不可变数组 pac
十、元组、集合
xk1761299425的博客
07-23 436
一、元组 1、元组的类型是tuple 2、元组是一个只读的文件。只能查看，不能修改、添加和删除。 3、元组是有长度的： 元组的操作同列表的操作是一样的，只是元组是只能读的，不能被修改 4、str()方法可以将元组转换为字符串： 总结： 通过将一个字符串转换为元组，首想：你要转换成的数据类型+（），示例： 比如说想要转换成字典，那就是dict(变量名)； 比如说想要转换...
spark（03）
weixin_30781107的博客
08-06 131
map遍历每一个元素 mapPartitions每次遍历一个分区 foreach action算子 foreachPartitions action算子 collect nginx flume hdfs hbase spark mysql 如果是插入数据，那么foreachPartition比较好，因为每个分区建立一个连接 提交的一个任务中，存在几个job...
2021-02-20 大数据课程笔记 day31
qq_44745905的博客
02-20 180
@R星校长 Spark 第三天【SparkCore内容】 主要内容 Spark-Core中的术语 RDD的宽窄依赖 Spark Stage & Spark计算模式 Spark资源调度和任务调度 Spark补充算子 Spark PV&UV 案例 Spark-Submit提交参数 学习目标 第一节 术语与宽窄依赖 术语解释 窄依赖和宽依赖 RDD 之间有一系列的依赖关系，依赖关系又分为窄依赖和宽依赖。 窄依赖 父 RDD 和子 RDD partition 之间的关系是一对一的。或者父 R.
2021-02-06 大数据课程笔记 day17
qq_44745905的博客
02-06 492
@R星校长 Hive Lateral View、视图与索引 Hive Lateral View Lateral View 用于和 UDTF 函数（explode、split）结合来使用。 首先通过 UDTF 函数拆分成多行，再将多行结果组合成一个支持别名的虚拟表。 主要解决在 select 使用 UDTF 做查询过程中，查询只能包含单个 UDTF，不能包含其他字段、以及多个 UDTF 的问题 语法： LATERAL VIEW udtf(expression) tableAlias AS columnA.
2021-02-02 大数据课程笔记 day13
qq_44745905的博客
02-02 239
@R星校长 MapReduce实战案例-1 课程内容 好友推荐 天气案例 好友推荐 需求 该给 hadoop 推荐哪个间接好友呢？ 两个人之间不认识，但是共同好友数越多，推荐的可能性越大 数据集 QQ： tom hello hadoop cat hadoop tom hive world world hadoop hello hive cat tom hive mr hive hello hive cat hadoop world hello mr hello tom world hive mr 特点 .
2021-03-17~18 大数据课程笔记 day56day57
qq_44745905的博客
03-18 765
@R星校长 1 基础概念和Kylin简介 1.1 OLTP与OLAP   数据处理大致可以分成两大类：联机事务处理OLTP（on-line transaction processing）、联机分析处理OLAP（On-Line Analytical Processing）。 1.1.1 OLTP   OLTP(On-Line Transaction Processing):联机事务处理，OLTP是传统的关系型数据库的主要应用，主要是基本的、日常的事务处理，例如银行交易。主要用于业务类系统，主要供基层人员使.
2021-02-13 大数据课程笔记 day24
qq_44745905的博客
02-13 1010
@R星校长 Lucene 与 ElasticSearch 概述 Lucene 全文检索 Lucene 概述 Lucene 是一个全文搜索框架，而不是应用产品。因此它并不像http://www.baidu.com/ 或者 google Desktop 那么拿来就能用，它只是提供了一种工具让你能实现这些产品。 lucene 能做什么 ： 本质就是给搜索内容定位 要回答这个问题，先要了解lucene的本质。实际上lucene的功能很单一，说到底，就是你给它若干个字符串，然后它为你提供一个全文搜索服务，告诉你你.
2021-02-11 大数据课程笔记 day22
qq_44745905的博客
02-11 1071
第3天 离线项目-3 新增用户数据处理 时间维度 浏览器维度 平台维度 KPI 一个工具维度 通过以上四个维度的各种组合，计算它的新增用户指标 课程大纲 项目模块设计思路 新增用户指标 mapper 开发 新增用户指标 reducer 开发 新增用户指标 Runner 开发 MapReduce 结果存 MySQL 新增用户指标运行结果 hbase uuid,servertime,browser,platform,kpi 事件 lanuch 时间 浏览器 平台 kpi 模块 时间
Spark基础之Scala知识总结
Jason_YBK的博客
09-24 1146
史上最全的Scala知识点整理第一章 变量及基本数据类型1.1 注释1.2 标识符命名规范1.3 变量1.4 字符串1.5 数据读取1.6 数据类型1.6.1 概述1.6.2 类型转换1.7 运算符第二章 流程控制2.1 块表达式2.2 If判断2.3 For循环2.3.1 Scala中方法调用的两种方式2.3.2 基本语法2.3.3 循环返回值2.4 While循环2.5 Switch2.6 中断循环第三章 面向函数编程3.1 概念3.2 函数的定义3.2.1 基本语法3.2.2 方法与函数3.2.3 参
Scala基础语法
xinlinliu
11-08 713
一、Scala介绍 1.Spark1.6中使用的是Scala2.10。Spark2.0版本以上使用是Scala2.11版本。 2.Scala官网6个特征。 * 1).Java和scala可以混编 * 2).类型推测(自动推测类型) * 3).并发和分布式（Actor） * 4).特质，特征(类似java中interfaces 和 abstract结合) * 5).模式匹配（类似java sw...
mount: 在 /dev/sr0 上找不到媒体 & mount: 挂载点 /mnt/cdrom 不存在
热门推荐
qq_44745905的博客
02-04 2万+
@R星校长 遇到两个问题： mount: 在 /dev/sr0 上找不到媒体 mount: 挂载点 /mnt/cdrom 不存在 问题 1： 灰色显示表示这个没有连接上 可移动设备 勾选启动时连接，如果设备是启动状态就还要勾选已连接 ，并且连接处要选择好ISO映像文件，点击浏览，选择电脑对应位置的镜像文件。 问题 2： 挂在目录不存在，说明缺少文件目录，我们这个时候需要新建目录，mkdir -p 中的 - p 表示 可以在父目录中创建子目录 mkdir -p /mnt/cdrom .
2021-02-08/09 大数据课程笔记 day19day20 某大型网站日志分析离线系统
qq_44745905的博客
02-10 4428
@R星校长 某大型网站日志分析离线系统 项目需求分析 概述 该部分的主要目标就是描述本次项目最终七个分析模块的界面展示。 工作流   在我们的 demo 展示中，我们使用 jquery+echarts 的方式调用程序后台提供的 rest api 接口，获取 json 数据，然后通过 jquery+css 的方式进行数据展示。工作流程如下： 分析 总述 在本次项目中我们分别从七个大的角度来进行分析，分别为： 用户基本信息分析模块 浏览器信息分析模块 地域信息分析模块 用户浏览深度分析模块 外链数据分析模块 .
2021-02-26~27~28 大数据课程笔记 day37day38day39
qq_44745905的博客
02-28 3561
@R星校长 音乐数据中心平台 1.1 数据库与ER建模 1.1.1 数据库（DataBase） 数据库是按照数据结构来组织、存储和管理数据的仓库，是一个长期存储在计算机内的、有组织的、可共享的、统一管理的大量数据的集合。 数据库是以一定方式储存在一起、能与多个用户共享、具有尽可能小的冗余度、与应用程序彼此独立的数据集合，可视为电子化的文件柜，存储电子文件的处所，用户可以对文件中的数据进行新增、查询、更新、删除等操作，数据组织主要是面向事务处理任务。 1.1.2 数据库三范式 关系型数据库设计时，遵照一定的.
2021-11-08-动画讲编程 算法训练营5步学习法
qq_44745905的博客
11-08 3566
@R星校长 下面给大家介绍算法训练营的五步学习法，分别是 01. 先思考，后刷题 02. 看动画，初学习 03. 学习后，再尝试 04. 细听课，克难点 05. 勤复习，三遍过 学习流程表 我们先来看算法训练营的学习流程表， 周 课程名称 类别 第一步：先思考后刷题 第二步：看动画，出学习 … 第1周 1.1-链表的基础知识，单链表 链表 第1周 1.2-链表逆序 链表 第1周 1.3-链表求交点 链表 第1周 1.4- 两个排序链表的合并 链表 第.
sklearn数据预处理（三）归一化
qq_44745905的博客
11-05 2491
@R星校长 第3关：归一化 任务描述 本关任务：利用sklearn对数据进行归一化。 相关知识 为了完成本关任务，你需要掌握：1.为什么使用归一化，2.L1范式归一化，3.L2范式归一化。 为什么使用归一化 归一化是缩放单个样本以具有单位范数的过程。归一化实质是一种线性变换，线性变换有很多良好的性质，这些性质决定了对数据改变后不会造成“失效”，反而能提高数据的表现，这些性质是归一化的前提。归一化能够加快模型训练速度，统一特征量纲，避免数值太大。 值得注意的是，归一化是对每一个样本做转换，所以是对数据的每一.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值