Scala学习总结

一、Scala的简介

Scala是一种基于JVM的编程语言，学习目的主要是为了Spark的学习与相关代码的编写。
Scala的六大特征：

        1).Java和scala可以无缝混编，都是运行在JVM上的2).类型推测(自动推测类型)，不用指定类型  3).并发和分布式（Actor，类似Java多线程Thread） 4).特质trait，特征(类似java中interfaces 和 abstract结合)5).模式匹配，match case（类似java switch case）6).高阶函数（函数的参数是函数，函数的返回是函数），可进行函数式编程

二、Scala安装使用

windows安装,配置环境变量

官网下载scala2.10：https://www.scala-lang.org/download/2.10.4.html
下载好后安装。双击msi包安装,记住安装的路径。
配置环境变量（和配置jdk一样）
         ①新建SCALA_HOME，配置好Scala安装的目录位置信息。
         ②编辑Path变量，在后面追加如下：
           ;%SCALA_HOME%\bin;%SCALA_HOME%\jre\bin
打开cmd,输入：scala - version 看是否显示版本号，确定是否安装成功

Scala程序编译工具
    ①Scala ide
     下载网址：http://scala-ide.org/download/sdk.html
    ②推荐使用IDEA中配置scala插件
     1》打开idea项目后，点击Configure->Plugins
     2》搜索scala，点击Install安装
     3》设置jdk，打开Project Structure,点击new 选择安装好的jdk路径
     4》创建scala项目，配置scala sdk(Software Development Kit)

三、Scala基础

1.数据类型

2.变量和常量的声明
Scala中通常用var声明变量，可修改；用val声明常量，不可修改即不可对常量进行再赋值；不用指定数据类型，由Scala自己进行类型推测。
注意点：在scala中每行后面不需要加分号，直接通过换行如来区分；但是一行中写了多个语句，语句与语句之间必须用分号来分割
例如：

var age = 18   ; var name = "angelababy"var heighat,score = 10val sex = "male"

3.类和对象

class :修饰的称为伴生类；定义在class中的属性都是动态的，用于实例化的;scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。class 类属性自带getter ，setter方法。使用class时要new （必须new，除非在对象伴生用apply方法【在加载类的时候默认自动调用】已实经例化好）,并且new的时候，class中除了方法不执行，其他都执行。

object: 修饰的称为伴生对象;定义在object中的属性（字段、方法）都是静态的,main函数写在里面;scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类.object不可以传参数。使用object时，不用new.

创建类

class Person{val name = "zhangsan"val age = 18def sayName() = {"my name is "+ name}
}

在创建类时，可以在类名后面加入一个括号，括号中写定义的参数类型，括号中的参数就表示类的构造函数由括号内的参数组成。补充： ①当参数用var修饰那么可以通过对象修改其值；当参数用val修饰那么无法通过对象来修改值；当参数没有修饰符，那么在外部无法通过对象来调用。
②若想增加一个类的传入参数，则需要在声明的类中重写构造函数，这样就可以在mian函数中声明有增加的属性的对象，当然原来的对象也可以声明。
重写this函数：

  /**  重写的构造函数，参数不能有修饰符*/def this (id:Int,name:String,facePower:Double ){//首先要调用父构造函数this(id,name)fcp = facePower}

创建对象

object Lesson_Class {def main(args: Array[String]): Unit = {val person = new Person()println(person.age);println(person.sayName())}
}

Apply方法
使用此方法时，可以在main函数中不通过new来创建一个对象，即可以不用专门的一次一次地进行实例化，加载创建对象的这个类的时候，会自动调用apply这个方法，类似Java中的static静态块。
Apply方法的使用用例：

object ScalaDemo01 {def main(args: Array[String]): Unit = {val p = new Person("zs",19)val person = Person("wagnwu",10)   //不用使用new来创建一个实例}
}class Person(xname :String , xage :Int){val name = "zs"val age = xagevar gender = "m"def this(name:String,age:Int,g:String){this(name,age)gender = g}
}object Person{def apply(name:String,age:Int)={new Person(name,age)  }
}

4.if{…}else{…}语句

    /*** if else */val age =18 if (age < 18 ){println("no allow")}else if (18<=age&&age<=20){println("allow with other")}else{println("allow self")}

5.for ,while,do…while
①to和until 的用法（不带步长，带步长区别）

 /*** to和until* 例：* 1 to 10 返回1到10的Range数组，包含10* 1 until 10 返回1到10 Range数组 ，不包含10*/println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10println(1 to (10 ,2))//步长为2，从1开始打印 ，1,3,5,7,9println(1 until 10 ) //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9println(1 until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7

②for循环（可加判断条件）

    //可以分号隔开，写入多个list赋值的变量，构成多层for循环//scala中 不能写count++ count-- 只能写count+//可以在for循环中加入条件判断var count = 0;for(i <- 1 to 10; j <- 1 until 10;if (i%2) == 0){println("i="+ i +",j="+j)count += 1}println(count);//例子： 打印小九九for(i <- 1 until 10 ;j <- 1 until 10){if(i>=j){print(i +" * " + j + " = "+ i*j+" ")  }if(i==j ){println()}}

补充： for循环用yield 关键字返回一个集合

/**  yield 关键字*  1-100集合中的偶数存储到另一个集合*  yield关键字能够将符合要求的元素自动封装到一个集合中*/
val rest = for(i <- 1 to 100; if i%2 == 0) yield i     //此时rest就为选择出的i构成的一个集合
for(elem <- rest) println(elem)

③while循环，while（）{}，do {}while()

   /*** while 循环*/var index = 0 while(index < 100 ){println("第"+index+"次while 循环")index += 1 }index = 0 do{index +=1 println("第"+index+"次do while 循环")
}while(index <100 )

6.函数
①普通函数

def fun (a: Int , b: Int ) : Unit = {println(a+b)}
fun(1,1)def fun1 (a : Int , b : Int)= a+bprintln(fun1(1,2))

②递归函数

 /*** 递归函数 * 5的阶乘*/def fun2(num :Int) :Int= {  //必须写返回值类型if(num ==1)numelse num * fun2(num-1)}print(fun2(5))

③包含参数默认值的函数

 /*** 包含参数默认值的函数*    1.  函数的参数有默认值，在调函数的时候可以传参，也可以不传参，*     2.  若不传参使用的默认值，*     3.  如果传参，默认值会被覆盖*/def fun2(num1:Int = 10,num2:Int = 20) = {num1 + num2}def fun3(num1:Int,num2:Int = 20) = {num1 + num2}def fun4(num1:Int=10,num2:Int) = {num1 + num2}调用：println(fun2())println(fun3(100))println(fun4(num2=1000))

④可变参数个数的函数：函数参数可以是一个也可以是多个，随机灵活的

 def fun5(args:Double*) = {/*** 在scala中*        +=前后的数值类型必须一致*        +前后的数值类型可以不一致*/var sum = 0.0for(arg <- args) sum += argsum}

⑤匿名函数：没有函数名的函数

/*** 匿名函数* 1.有参数匿名函数* 2.无参数匿名函数* 3.有返回值的匿名函数* 注意：* 可以将匿名函数返回给定义的一个变量* 匿名函数不能显式声明函数的返回类型*/
//有参数匿名函数
val value1 = (a : Int) => {println(a)
}
value1(1)
//无参数匿名函数
val value2 = ()=>{println("我爱Angelababy")
}
value2()
//有返回值的匿名函数
val value3 = (a:Int,b:Int) =>{a+b
}
println(value3(4,4))

⑥嵌套函数

    /*** 嵌套函数：*       在函数体内有定义了一个函数*/def fun7(num:Int)={def fun8(a:Int,b:Int):Int={if(a == 1){b}else{fun8(a-1,a*b)}}fun8(num,1)}

⑦偏应用函数：偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。在多个函数调用时，有共同的参数被使用，则可提取出来默认写死，只需要为函数提供部分的参数。

/*** 偏应用函数*/
def log(date :Date, s :String)= {println("date is "+ date +",log is "+ s)
}val date = new Date()
log(date ,"log1")
log(date ,"log2")
log(date ,"log3")//想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
val logWithDate = log(date,_:String)    //下划线相当于占位符的作用，手动传入即可
logWithDate("log11")
logWithDate("log22")
logWithDate("log33")

⑧ 高阶函数：函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型是函数的函数。

 //函数的参数是函数def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {f(a,100)}def f(v1 :Int,v2: Int):Int  = {v1+v2}println(hightFun(f, 1))//函数的返回是函数//1，2,3,4相加def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {def f2 (v1: Int,v2:Int) :Int = {v1+v2+a+b}f2}println(hightFun2(1,2)(3,4))//函数的参数是函数，函数的返回是函数def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {f} println(hightFun3(f)(100,200))println(hightFun3((a,b) =>{a+b})(200,200))//以上这句话还可以写成这样//如果函数的参数在方法体中只使用了一次 那么可以写成_表示println(hightFun3(_+_)(200,200))

⑨柯里化函数

    /*** 柯里化函数*      可以理解为高阶函数的简化*       klhFun函数就是对嵌套函数这种情况的高阶函数的简化版*/def klhFun(a:Int)(b:Int) = a*b具体：def klhAllFun(a:Int):(Int)=>Int = {val fun = (b:Int)=>a*bfun}

7.Scala字符串

val str1 = "hello bi"val str2 = "hello sh"val flag = str1.equalsIgnoreCase(str2)    println(flag)str1.split(" ")val strBuilder = new StringBuilderstrBuilder.append("hello\t")strBuilder.append("bj")println(strBuilder)println("hello Angelababy".hashCode())

string操作方法举例
1.比较:equals
2.比较忽略大小写:equalsIgnoreCase
3.indexOf：如果字符串中有传入的assci码对应的值，返回下标

  /*** String && StringBuilder*/val str = "abcd"val str1 = "ABCD"println(str.indexOf(97))println(str.indexOf("b"))println(str==str1)/*** compareToIgnoreCase* * 如果参数字符串等于此字符串，则返回值 0；* 如果此字符串小于字符串参数，则返回一个小于 0 的值；* 如果此字符串大于字符串参数，则返回一个大于 0 的值。* */println(str.compareToIgnoreCase(str1))val strBuilder = new StringBuilderstrBuilder.append("abc")
//    strBuilder.+('d')strBuilder+ 'd'
//    strBuilder.++=("efg")strBuilder++= "efg"
//    strBuilder.+=('h')strBuilder+= 'h' strBuilder.append(1.0)strBuilder.append(18f)println(strBuilder)

8.数组

 //数组  new String[10]/*** Array关键词 创建一个长度为10 的Int类型的数组* 如果创建了一个Int类型的数组，那么初始值都是0* String类型的数组，初始是null* Boolean类型的数组，初始是false*/val nums = new Array[Int](10)for(index <- 0 until nums.length){nums(index) = index * index}nums.foreach {println }//二维数组val secArray = new Array[Array[String]](10)for(index <- 0 until secArray.length){secArray(index) = new Array[String](10)}//往二维数组中填充数据    /* for(i <- 0 until secArray.length){for(j <- 0 until secArray(i).length){secArray(i)(j) = i*j + ""}}*/for(i <- 0 until secArray.length;j <- 0 until secArray(i).length){secArray(i)(j) = i*j + ""}

9.List集合

   /*** list集合* * list集合是一个不可变的集合* 可变的list集合*/println("=========List==========")val list = List(1,2,3,4,5)list.contains(6)val dropList = list.drop(2)dropList.foreach { println }list.reverselist.take(3).foreach(println)val mapList1 = list.map { x=> x +"" }mapList1.foreach { x=>println(x) }println(list.exists { x => x > 300 })println(list.mkString("\t"))val logList = List("hello bj","hello sh")val mapList = logList.map { _.split(" ") }
//    mapList.foreach { x => x.foreach { println } }//flatMap方法   flat扁平 val flatMapList = logList.flatMap{_.split(" ")}flatMapList.foreach { println }/*** 不可变的list集合* 创建list集合的方式：*         1、List（1,2,3）*        2、Nil关键创建  Nil：空List*                ::往集合中添加元素*/val list = 2::1::Nil/*** 可变的list集合*/val listBuffer = new ListBuffer[String]listBuffer.+=("hello")listBuffer.+=("bj")listBuffer.foreach { println }listBuffer.-=("hello")

10.set集合

   //创建 val set1 = Set(1,2,3,4,4)val set2 = Set(1,2,5)//遍历//注意：set会自动去重set1.foreach { println}for(s <- set1){println(s)}println("*******")/*** 方法举例*///交集val set3 = set1.intersect(set2)set3.foreach{println}val set4 = set1.&(set2)set4.foreach{println}println("*******")//差集set1.diff(set2).foreach { println }set1.&~(set2).foreach { println }//子集set1.subsetOf(set2)//最大值println(set1.max)//最小值println(set1.min)println("****")//转成数组，listset1.toArray.foreach{println}println("****")set1.toList.foreach{println}//mkStringprintln(set1.mkString)println(set1.mkString("\t"))

11.Map集合

 val map = Map("1" -> "bj",2 -> "sh",3 -> "gz")val keys = map.keysval keyIterator = keys.iteratorwhile(keyIterator.hasNext){val key = keyIterator.next()/*** map集合的get方法返回值是一个Option类型的对象* Option类型有两个子类型  分别为some None*/Map中的方法 ：1. filter:过滤，留下符合条件的记录2.    count:统计符合条件的记录数3.  contains：map中是否包含某个key4. exist：符合条件的记录存在不存在println(key + "\t" + map.get(key).get)}/*** getOrElse 原理：*      去集合中去取数据，若不存在返回默认值*/println(map.get(4).getOrElse("default"))for(k <- map)println(k._1 + "\t" + k._2)     //分别取第一个位置的数据和第二个位置的数据，即Key-Valuemap.foreach(x=>println(x._1 + "\t" + x._2))    map.filter(x=>{Integer.parseInt(x._1 + "") >= 2}).foreach(println)val count = map.count(x=>{Integer.parseInt(x._1 + "") >= 2})println(count)/**合并Map的操作：1.++  例：map1.++(map2)  --map1中加入map22.++:  例：map1.++:(map2) –map2中加入map1注意：合并map会将map中的相同key的value替换**/

12.元组

 /*** 元组 vs list* list创建的时候指定了泛型，那么集合中必须是这个泛型的对象* 元祖中可以包含任意类型的元素，这些元素使用一对小括号来封装，Tuple关键字* * */val t2 = Tuple2(1,"hello")val tt2 = (1,"hello")val t3 = Tuple3(1,true,"hello")  //可以存放Int、boolean、String多种不同的类型val tt3 = (1,true,"hello")val moreTuple = (1,2,3)   val tupleIterator = tt3.productIterator    //元组的遍历while(tupleIterator.hasNext){println(tupleIterator.next())}//toString方法println(tt3.toString())//swap交换    注意只有二元组对象才会有这个方法val swapt2 = tt2.swapprintln(swapt2._1 + "\t" + swapt2._2)

13.Trait特性
①Trait的概念理解
1》 Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大。
2》与接口不同的是，它还可以定义属性和方法的实现。抽象类和接口的结合。
3》一般情况下Scala的类可以继承多个Trait，从结果来看就是实现了多重继承。Trait的继承用exten关键字继承，多继承时多个Trait之间用with连接。
4》Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。
5》继承的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。
6》trait中不可以传参数

trait Read {val readType = "Read"val gender = "m"def read(name:String){println(name+" is reading")}
}trait Listen {val listenType = "Listen"val gender = "m"def listen(name:String){println(name + " is listenning")}
}class Person() extends Read with Listen{override val gender = "f"
}object test {def main(args: Array[String]): Unit = {val person = new Person()person.read("zhangsan")person.listen("lisi")println(person.listenType)println(person.readType)println(person.gender)}
}

14.模式匹配Match…Case…
①概念理解
=>Java中的模式匹配为 switch case ；
=>Scala 提供了强大的模式匹配机制，应用也非常广泛，除了匹配值还可以匹配类型，类型的匹配必须要有变量名。
=>一个模式匹配包含了一系列备选项，每个都开始于关键字 case。
=>每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

object Lesson_Match {def main(args: Array[String]): Unit = {val tuple = Tuple6(1,2,3f,4,"abc",55d)val tupleIterator = tuple.productIteratorwhile(tupleIterator.hasNext){matchTest(tupleIterator.next())}}/*** 注意点：* 1.模式匹配不仅可以匹配值，还可以匹配类型* 2.模式匹配中，从上到下顺序匹配，如果匹配到对应的类型或值，就不再继续往下匹配* 3.模式匹配中，都匹配不上时，会匹配到 case _ ，相当于default* 4. 模式匹配的时候，模式范围小的在最前面*/def matchTest(x:Any) ={x match {case x:Int=> println("type is Int")    //类型匹配，必须要有变量名case 1 => println("result is 1")case 2 => println("result is 2")case 3=> println("result is 3")case 4 => println("result is 4")case x:String => println("type is String")
//      case x :Double => println("type is Double")case _ => println("no match")}}
}

15.样例类（case class）
     ①概念理解
       使用了case关键字的类定义就是样例类(case classes)，样例类是种特殊的类。实现了类构造参数的getter方法（构造参数默认被声明为val），当构造参数是声明为var类型的，它将帮你实现setter和getter方法。
       样例类默认帮你实现了toString,equals，copy和hashCode等方法。
       样例类可以new, 也可以不用new

/*** 样例类* 使用case 来修饰的类就叫样例类* * 样例类和普通类有什么区别？* 样例类默认帮你实现了toString,equals，copy和hashCode等方法。样例类可以new, 也可以不用new */val s1 = Student(1,1)val s2 = Student(2,2)val s3 = Student(3,3)val s4 = Student(4,4)val s5 = Student(5,5)val sl = List(s1,s2,s3,s4,s5)//样例类+match casesl.foreach { x => x match {case Student(1,1) => println("1 1")    //值匹配，且使用了样例类已经写好了的toString方法。case s:Student => println("Student" + s)    //类型匹配case _ => println("_______")} }}
}
//样例类
case class Student(val id :Int ,val age :Int)

16.Actor Model
①概念理解
Actor Model是用来编写并行计算或分布式系统的高层次抽象（类似java中的Thread）让程序员不必为多线程模式下共享锁而烦恼,被用在Erlang 语言上, 高可用性99.9999999 % 一年只有31ms 宕机Actors将状态和行为封装在一个轻量的进程/线程中，但是不和其他Actors分享状态，每个Actors有自己的世界观，当需要和其他Actors交互时，通过发送事件和消息，发送是异步的，非堵塞的(fire-andforget)，发送消息后不必等另外Actors回复，也不必暂停，每个Actors有自己的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，可以建立性能很好的事件驱动系统。

Actor的特征：
1.ActorModel是消息传递模型,基本特征就是消息传递
2.消息发送是异步的，非阻塞的
3.消息一旦发送成功，不能修改，类似于邮件的发送来往
4.Actor之间传递时，自己决定决定去检查消息，而不是一直等待，是异步非阻塞的

//Actor与Actor之间通信
case class Message(actor:Actor,msg:Any)class Actor1 extends Actor{def act(){while(true){receive{case  msg :Message => {      //类型匹配println("i sava msg! = "+ msg.msg)msg.actor!"i love you too !"}case msg :String => println(msg)case  _ => println("default msg!")}}}
}class Actor2(actor :Actor) extends Actor{actor ! Message(this,"i love you !")def act(){while(true){receive{case msg :String => {if(msg.equals("i love you too !")){println(msg)actor! "could we have a date !"}}case  _ => println("default msg!")}}}
}object Lesson_Actor2 {def main(args: Array[String]): Unit = {val actor1 = new Actor1()actor1.start()val actor2 = new Actor2(actor1)actor2.start()}
}

17.Scala的隐式转换系统
隐式转换，在编写程序的时候可以尽量少的去编写代码，让编译器去尝试在编译期间自动推导出这些信息来，这种特性可以极大的减少代码量，提高代码质量.
①隐式值+隐式视图
通过implicit进行隐式的声明

  object Scala09 {def main(args: Array[String]): Unit = {
//隐式值：
//  implicit var abc = "Dilireba"implicit var cba = "Angelababy"sayName   //直接调用，不用传参 /* 将变量声明为implicit，编译器在执行sayName方法时发现缺少一个String类型的参数，此时会搜索作用域内类型为String的隐式值并且将搜索到的隐式值作为sayName的参数值*///    1.隐式转换必须满足无歧义规则//    2.声明隐式参数的类型最好是自定义的数据类型，//    3.不要使用Int,String这些常用类型，防止碰巧冲突//    4.一般要将自定义的对象设置为隐式的//  隐式视图  --》隐式转换为目标类型：把一种类型自动转换到另一种类型implicit def string2Int(num:String) = Integer.parseInt(num) //addNum参数是tring，不符合要求，那么他在编译的时候，发现作用域内//    有一个隐式方法，正好这个方法的参数是String 返回值是Int  此时//调用隐式方法，返回一个Int值，在将Int传给addNumprintln(addNum("1000"))}def addNum(num:Int) = {num + 1000}def sayName(implicit name:String) = {println("I Love " + name)}}

②隐式类

   注意点：1.其所带的构造参数有且只能有一个2.隐式类必须被定义在类，伴生对象和包对象里3.隐式类不能是case class（case class在定义会自动生成伴生对象与2矛盾）4.作用域内不能有与之相同名称的标示符package com.hpe.scalaobject Scala10 {def main(args: Array[String]): Unit = {//  隐式类   导包要从包名开始import com.hpe.scala.Util._     //Util下的所有类"abc".getLength()/*** "abc"这个字符串想要调用getLength，但是自己没有实现这个方法* 发现作用域内有一个隐式转换的类，类的构造函数的参数是String类型* 自己传给构造函数，得到这个类的对象，近而调用getLength方法*/}
}object Util{implicit class Int2String(s:String){def getLength() = s.length}
}

补充点：“_”在scala中的意义

_表示所有、2.占位符、3.简写模式

Scala编程语言学习总结相关推荐

Scala编程语言入门（3）
文章目录 Scala编程语言入门 Scala进阶 trait特质 1. 作为接口使用 2. 定义具体方法 3. 定义具体方法和抽象方法 4. 定义具体字段和抽象字段 5. 实例对象混入 trait 模 ...
Scala编程语言入门（1）
文章目录 Scala编程语言入门 Scala简介搭建开发环境安装JDK 安装 Scala SDK 安装IDEA的scala插件 scala的REPL交互式解释器 Scala语法基础 scala中声 ...
Scala 递归学习的例子
Scala 递归学习的例子为了学习Spark,我开始了学习Scala.加油! 递归的一个题目: 代码: // Why x is Float, but when we use 3.0 for exam ...
Python编程语言学习：包导入和模块搜索路径简介、使用方法之详细攻略
Python编程语言学习:包导入和模块搜索路径简介.使用方法之详细攻略目录包导入和模块搜索路径简介 1.Pyhon搜索模块路径的机制 2.自定义配置搜索路径
Python编程语言学习：在根目录的py文件内调用某叶目录文件内的包/库或者函数(常用在GUI编程)之详细攻略
Python编程语言学习:在根目录的py文件内调用某叶目录文件内的包/库或者函数(常用在GUI编程)之详细攻略目录
Python编程语言学习：for循环实现对多个不同的DataFrame数据执行相同操作(可用于对分开的测试集、训练集实现执行相同逻辑任务)
Python编程语言学习:for循环实现对多个不同的DataFrame数据执行相同操作(可用于对分开的测试集.训练集实现执行相同逻辑任务) 目录
Python编程语言学习：两行代码输出根目录下所有子文件夹的绝对路径、相对路径
Python编程语言学习:两行代码输出根目录下所有子文件夹的绝对路径.相对路径目录两行代码输出根目录下所有子文件夹的绝对路径.相对路径两行代码输出根目录下所有子文件夹的绝对路径.相对路径 #Py ...
Python编程语言学习：在for循环中如何同时使用2个变量或者3个变量
Python编程语言学习:在for循环中如何同时使用2个变量或者3个变量目录在for循环中如何同时使用2个变量或者3个变量在for循环中如何同时使用2个变量
Python编程语言学习：列表与字典互转的几大方法集锦、从列表中按顺序循环抽走一个元素输出剩余元素之详细攻略
Python编程语言学习:列表与字典互转的几大方法集锦.从列表中按顺序循环抽走一个元素输出剩余元素之详细攻略目录列表与字典互转的几大方法集锦 T1.基于两个列表利用zip函数来构造字典 <

Scala编程语言学习总结

Scala学习总结

一、Scala的简介

二、Scala安装使用

三、Scala基础

Scala编程语言学习总结相关推荐

最新文章

热门文章