“古之善为士者，微妙玄通，深不可识。
夫唯不可识。
故强为之容:豫兮，若冬涉川；犹兮，若畏四邻；俨兮，其若客；涣兮，若冰之将释；孰兮，其若朴；旷兮，其若谷；浑兮，其若浊。
孰能浊以止，静之徐清？
孰能安以久，动之徐生？”¹

在数据挖掘和数据分析中，经常会遇到需要知道个体数据间差异的大小，进而需要得到个体数据间的相似度，最常见的就是电商平台中对于物品的推荐以及内容平台中对于信息的推送等等。
相似度就是两个item之间的相似性，一般就是计算两个item的特征之间的距离，距离越大，相似度越小；距离越小，相似度越大；也可以两个向量间的夹角来表示，夹角越大，相似度越小；夹角越小，相似度越大；
常用的有以下四种方法：

• 欧几里得距离（Eucledian Distance）或称 欧氏距离
• 余弦相似度 （Cosine Similarity）
• 杰卡德相似系数（Jaccard Similarity coefficient）
• 皮尔逊相关系数（Pearson correlation）

欧几里得距离 or 欧氏距离

两个n维向量a(x11,x12,…,x1n)与 b(x21,x22,…,x2n)间的欧氏距离：

python代码常用的有两种，一种使用numpay，一种使用scipy：

1

import numpy as np

2

x=np.random.random(8)

3

y=np.random.random(8)

4

d1=np.sqrt(np.sum(np.square(x-y)))

5

d1

输出：

1

1.1282380087788222

1

from scipy.spatial.distance import pdist

2

z=np.vstack([x,y])

3

d2=pdist(z)

4

d2

输出：

1

array([ 1.12823801])

余弦相似度 （Cosine Similarity）

也可以叫余弦相似度。 几何中夹角余弦可用来衡量两个向量方向的差异，机器学习中借用这一概念来衡量样本向量之间的差异。余弦取值范围为[-1,1]。求得两个向量的夹角，并得出夹角对应的余弦值，此余弦值就可以用来表征这两个向量的相似性。夹角越小，趋近于0度，余弦值越接近于1，它们的方向更加吻合，则越相似。当两个向量的方向完全相反夹角余弦取最小值-1。当余弦值为0时，两向量正交，夹角为90度。因此可以看出，余弦相似度与向量的幅值无关，只与向量的方向相关。
两个n维样本点a(x11,x12,…,x1n)和b(x21,x22,…,x2n)的夹角余弦:

1

d3=np.dot(x,y)/(np.linalg.norm(x)*np.linalg.norm(y))

2

d3

输出：

1

0.70543665237781283

1

z=np.vstack([x,y])

2

d4=1-pdist(z,'cosine')

3

d4

输出：

1

array([ 0.70543665])

杰卡德相似系数（Jaccard Similarity coefficient）

杰卡德相似系数

两个集合A和B的交集元素在A，B的并集中所占的比例，称为两个集合的杰卡德相似系数，用符号J(A,B)表示。杰卡德相似系数是衡量两个集合的相似度一种指标。

杰卡德距离

与杰卡德相似系数相反的概念是杰卡德距离(Jaccard distance)。杰卡德距离用两个集合中不同元素占所有元素的比例来衡量两个集合的区分度。

杰卡德相似系数代码实现：

1

import numpy as np

2

from scipy.spatial.distance import pdist

3

x=np.random.random(8)>0.5

4

y=np.random.random(8)>0.5

5

6

x=np.asarray(x,np.int32)

7

y=np.asarray(y,np.int32)

8

9

#方法一：根据公式求解

10

up=np.double(np.bitwise_and((x != y),np.bitwise_or(x != 0, y != 0)).sum())

11

down=np.double(np.bitwise_or(x != 0, y != 0).sum())

12

d1=(up/down)

13

14

15

#方法二：根据scipy库求解

16

X=np.vstack([x,y])

17

d2=pdist(X,'jaccard')

皮尔逊相关系数（Pearson correlation）

皮尔逊相关系数的定义

前面提到的余弦相似度只与向量方向有关，但它会受到向量的平移影响，在夹角余弦公式中如果将 x 平移到 x+1, 余弦值就会改变。怎样才能实现平移不变性？这就要用到皮尔逊相关系数（Pearson correlation），有时候也直接叫相关系数。
如果将夹角余弦公式写成：

表示向量x和向量y之间的夹角余弦，则皮尔逊相关系数则可表示为：

皮尔逊相关系数具有平移不变性和尺度不变性，计算出了两个向量（维度）的相关性。

1

import numpy as np

2

x=np.random.random(8)

3

y=np.random.random(8)

4

5

#方法一：根据公式求解

6

x_=x-np.mean(x)

7

y_=y-np.mean(y)

8

d1=np.dot(x_,y_)/(np.linalg.norm(x_)*np.linalg.norm(y_))

9

10

#方法二：根据numpy库求解

11

X=np.vstack([x,y])

12

d2=np.corrcoef(X)[0][1]

相关系数是衡量随机变量X与Y相关程度的一种方法，相关系数的取值范围是[-1,1]。相关系数的绝对值越大，则表明X与Y相关度越高。当X与Y线性相关时，相关系数取值为1（正线性相关）或-1（负线性相关）。

1:老子《道德经》第十五章，老子故里，中国鹿邑。

“将欲歙之，必固张之；将欲弱之，必固强之；将欲废之，必固举之；将欲取之，必固予之。
是谓微明。
柔弱胜刚强。
鱼不可脱于渊，国之利器不可以示人。”¹

模式匹配

关于scala的模式匹配在上篇博客《从java(python)到scala的n种记忆》中有提及，但是模式匹配在scala中应用的地方太多了，有必要单独攒一篇文字来记录它。

模式匹配跟java中的switch-case绝对的相似，只是java中只能匹配值，而scala中的这个不仅能匹配值，而且可以匹配类型和类。

• 按值匹配

  1	def bigData(content:String):Unit = {
  2	content match{
  3	case "spark" => println("yeah!spark!")
  4	case "kafka" => println("wow!kafka!")
  5	case _ => println("anything else?")
  6	}
  7	}
  8	def main(args: Array[String]) {
  9	bigData("spark")
  10	bigData("kafka")
  11	bigData("zipkin")
  12	}

  输出：

  1	yeah!spark!
  2	wow!kafka!
  3	anything else?

  case 后面还可以加条件判断，不过貌似不会很常用。

• 类型模式匹配

  1	object Demo {
  2	def main(args: Array[String]) {
  3	println(matchTest("two"))
  4	println(matchTest("test"))
  5	println(matchTest(1))
  6	}
  7
  8	def matchTest(x: Any): Any = x match {
  9	case 1 => "one"
  10	case "two" => 2
  11	case y: Int => "scala.Int"
  12	case _ => "many"
  13	}
  14	}

  输出：

  1	2
  2	many
  3	one

• 样例类(case class)模式匹配
  Scala Case类只是常规类，默认情况下是不可变的，可通过模式匹配可分解。它使用相等(equal)方法在结构上比较实例。它不使用new关键字实例化对象。默认情况下，case类中列出的所有参数默认使用public和immutable修辞符。
  语法：

  1	case class className(parameters)

  1	case class CaseClass(a:Int, b:Int)
  2
  3	object Demo{
  4	def main(args:Array[String]){
  5	var c = CaseClass(13,14) // Creating object of case class
  6	println("a = "+c.a) // Accessing elements of case class
  7	println("b = "+c.b)
  8	}
  9	}

  输出：

  1	a = 13
  2	b = 14

  Case类支持模式匹配。 所以，可以在模式中使用它。没有参数的case类将被声明为case对象而不是case类。 默认情况下，case对象是可序列化的。

  1	trait SuperTrait
  2	case class CaseClass1(a:Int,b:Int) extends SuperTrait
  3	case class CaseClass2(a:Int) extends SuperTrait // Case class
  4	case object CaseObject extends SuperTrait // Case object
  5	object Demo{
  6	def main(args:Array[String]){
  7	callCase(CaseClass1(10,10))
  8	callCase(CaseClass2(10))
  9	callCase(CaseObject)
  10	}
  11	def callCase(f:SuperTrait) = f match{
  12	case CaseClass1(f,g)=>println("a = "+f+" b ="+g)
  13	case CaseClass2(f)=>println("a = "+f)
  14	case CaseObject=>println("No Argument")
  15	}
  16	}

  输出：

  1	a = 10 b =10
  2	a = 10
  3	No Argument

  类型参数

  Scala中的类型参数，与java中的泛型类似。

  1	class Person[T](val content:T){
  2	def getContent(id:T)=id+"_"+content
  3	}
  4	……
  5	def main(args: Array[String]) {
  6	val person_Str = new Person[String]("String")
  7	println(person_Str.getContent("spark"))
  8	val person_Int = new Person[Int](14)
  9	println(person_Int.getContent(13))
  10	}

  输出：

  1	spark_String
  2	13_14

  所以，我们使用类型参数，可以很好的指定特定值得输入类型，然后基于该类型进行一些操作，增加了程序的健壮性。Spark中的RDD就是这样的。
  上面只是一个简单的例子，scala的泛型[T]有如下六种方式：

• scala的类和方法、函数都可以是泛型。

• 关于对类型边界的限定分为上边界和下边界（对类进行限制）
  上边界：表达了泛型的类型必须是某种类型或者某种类的子类，语法为<:,例如T <: AnyVal表示泛型T的类型的最顶层类是AnyVal。
  下边界：表达了泛型的类型必须是某种类型或者某种类的父类，语法为>:,例如T >: S表示泛型T的类型必须是S的超类，下界的作用主要是保证类型安全。

• “<%” :view bounds可以进行某种神秘的转换，把你的类型在没有知觉的情况下转换成目标类型
  如果希望类型变量界定能跨越类继承层次结构时，可以使用视图界定来实现的，其后面的原理是通过隐式转换来实现。视图界定利用<%符号来实现，例如后面的例子[T <% Person]，T是Person继承的或者是能变成Person。

• “T:classTag”:相当于动态类型，你使用时传入什么类型就是什么类型

• 逆变和协变：-T和+T
  逆变和协变最容易理解的便是用List来理解。
  协变定义形式如：trait List[+T] {} 。当类型S是类型A的子类型时，则List[S]也可以认为是List[A}的子类型，
  即List[S]可以泛化为List[A]。
  逆变定义形式如：trait List[-T] {}
  当类型S是类型A的子类型，则Queue[A]反过来可以认为是Queue[S}的子类型。

• “T:Ordering” :表示将T变成Ordering[T],可以直接用其方法进行比大小,可完成排序等工作

1:老子《道德经》第三十六章，老子故里，中国鹿邑。

“道常无为，而无不为。
侯王若能守之，万物将自化。
化而欲作，吾将镇之以无名之朴。
无名之朴，夫亦将不欲。
不欲以静，天下将自定。”¹

对于scala的学习成本，大多会体现在对于隐式转换的理解应用上。隐式转换伴随着泛型，scala所有的神秘之处、优雅之处皆因于此。

隐式在scala中，应用场景会在如下四个方面：

• 隐式参数

  1	scala> def razor(implicit name:String) = name
  2	razor: (implicit name: String)String

  直接调用razor方法

  1	scala> razor
  2	<console>:13: error: could not find implicit value for parameter name: String
  3	razor
  4	^

  报错！编译器说无法为参数name找到一个隐式值
  定义一个隐式值后再调用razor方法

  1	scala> implicit val iname = "Philips"
  2	iname: String = Philips
  3
  4	scala> razor
  5	res12: String = Philips

  因为将iname变量标记为implicit，所以编译器会在方法省略隐式参数的情况下去搜索作用域内的隐式值作为缺少参数。
  但是如果此时你又重复定义一个隐式变量，再次调用方法时就会报错

  1	scala> implicit val iname2 = "Gillette"
  2	iname2: String = Gillette
  3
  4	scala> razor
  5	<console>:15: error: ambiguous implicit values:
  6	both value iname of type => String
  7	and value iname2 of type => String
  8	match expected type String
  9	razor
  10	^

  匹配失败，所以隐式转换必须满足无歧义规则，在声明隐式参数的类型是最好使用特别的或自定义的数据类型，不要使用Int,String这些常用类型，避免碰巧匹配。
• 隐式函数

  1	class Person(val name:String)
  2
  3	class Engineer(val name:String,val salary:Double){
  4	def mySalary(): Unit ={
  5	println(name+",your monthly salary is is:"+salary)
  6	}
  7	}
  8
  9	object Test {
  10	def main(args: Array[String]): Unit = {
  11	new Person("sutong").mySalary
  12	}
  13	}

  实例化一个person对象，然后调用mySalary方法时，此时编译是通不过的，因为person类没有mySalary方法。但是如果我们加入一个隐式函数就能时编译通过并能顺利运行，如下：

  1	object Test {
  2	implicit def person2Engineer(p:Person):Engineer = {
  3	new Engineer(p.name,100000)
  4	}
  5	def main(args: Array[String]): Unit = {
  6	new Person("sutong").mySalary
  7	}
  8	}

  输出：

  1	sutong,your salary is:100000.0

  Scala会在报错前，去找隐式函数，例如我们定义的隐式函数，根据函数签名，主要是输入参数，找到了person2Engineer方法，并利用此方法将person对象转换为了Engineer对象，然后发现Engineer对象有mySalary方法，直接调用其mySalary方法，打印输出。运行后，Person对象和Engineer类型无任何关系。

约定：

虽然在定义implicit函数时scala并未要求要写明返回类型，但我们应写明返回类型，这样有助于代码阅读。

• 隐式对象
  用implicit修饰的object就是隐式对象。

  1	abstract class Template[T]{
  2	def add(a:T,b:T):T
  3	}
  4
  5	abstract class SubTemplate[T] extends Template[T] {
  6	def unit:T
  7	}
  8
  9	object Implicit_Object_Test {
  10	def main(args: Array[String]): Unit = {
  11	implicit object StringAdd extends SubTemplate[String]{
  12	override def unit: String = ""
  13	override def add(a:String,b:String):String = a concat b
  14	}
  15	implicit object IntAdd extends SubTemplate[Int]{
  16	override def unit: Int = 0
  17	override def add(a:Int,b:Int):Int = a+b
  18	}
  19
  20	def sum[T](x:List[T])(implicit m:SubTemplate[T]):T = {
  21	if(x.isEmpty) m.unit
  22	else m.add(x.head,sum(x.tail))
  23	}
  24
  25	println(sum(List(2,4,6,8,10)))
  26	println(sum(List("a","b","c")))
  27	}
  28	}
  29	输出：
  30	30
  31	abc

  首先定义了两个含有泛型的抽象类，Template是父类，而SubTempalte是子类，而这个子类有有两个子对象StringAdd和IntAdd，下面来看下主函数中定义的sum函数，它是一个含有泛型的函数，它的第一个参数是含有泛型的List类型的xs，第二个参数是含有泛型的SubTemplate类型的隐式参数m，函数返回值是一个泛型，首先，函数里先判断传入的第一个参数是否为空，若为空则调用隐式参数m，有由于scala可以自动进行类型推到，所以运行时，泛型T是一个确定类型，要么为Int要么为String，但是为空时，我们调用隐式参数m的unit是不同的，Int为0，而String为“”，所以我们定义了两个隐式对象对其进行处理，IntAdd隐式类复写了unit，使之为0，StringAdd隐式类复写了unit，使之为””,这样程序就可以正常执行了。同理，隐式对象方法对add方法进行复写，完成了sum操作。
• 隐式类
  在scala2.10后提供了隐式类，可以使用implicit声明类，但是需要注意以下几点：

1.其所带的构造参数有且只能有一个
2.隐式类必须被定义在类，伴生对象和包对象里
3.隐式类不能是case class（case class在定义会自动生成伴生对象与2矛盾）
4.作用域内不能有与之相同名称的标示符

1

import scala.io.Source

2

import java.io.File

3

4

object Implicit_Class {

5

  import Context_Helper._

6

  def main(args: Array[String]) {

7

    println(1.add(2))  

8

    println(new File("I:\\aa.txt").read())

9

  }

10

}

11

12

object Context_Helper{

13

  implicit class ImpInt(tmp:Int){

14

    def add(tmp2: Int) = tmp + tmp2

15

  }

16

  implicit class FileEnhance(file:File){

17

    def read() = Source.fromFile(file.getPath).mkString

18

  }

19

}

其中1.add(2)这个可以这样理解：

当 1.add（2） 时，scala 编译器不会立马报错，而检查当前作用域有没有 用implicit 修饰的，同时可以将Int作为参数的构造器，并且具有方法add的类，经过查找 发现 ImpInt 符合要求，利用隐式类 ImpInt 执行add 方法。

归纳一下

• 隐式转换的时机
  a.当方法中的参数的类型与目标类型不一致时
  b.当对象调用类中不存在的方法或成员时，编译器会自动将对象进行隐式转换
• 隐式解析机制
  a.首先会在当前代码作用域下查找隐式实体（隐式方法 隐式类 隐式对象）
  b.如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找
• 隐式转换的前提
  a.不存在二义性
  b.隐式操作不能嵌套使用
  c.代码能够在不使用隐式转换的前提下能编译通过，就不会进行隐式转换

1:老子《道德经》第三十七章，老子故里，中国鹿邑。

“道冲，而用之或不盈。
渊兮，似万物之宗。
挫其锐，解其纷，和其光，同其尘。
湛兮，似或存，吾不知其谁之子，象帝之先。”^ddj

###可重入
若一个程序或子程序可以“安全的被并行执行(Parallel computing)”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，可以再次进入并执行它（并行执行时，个别的执行结果，都符合设计时的预期）。可重入概念是在单线程操作系统的时代提出的。

ReentrantLock默认情况下为不公平锁

1

private ReentrantLock lock = new ReentrantLock();//公平锁

2

private ReentrantLock lock = new ReentrantLock(true);//不公平锁

不公平锁与公平锁的区别：
公平情况下，操作会排一个队按顺序执行，来保证执行顺序。（会消耗更多的时间来排队）
不公平情况下，是无序状态允许插队，jvm会自动计算如何处理更快速来调度插队。（如果不关心顺序，这个速度会更快）

使用场景

ReentrantLock的使用场景，通常有如下几个：

• 发现该操作已经在执行中则不再执行（有状态执行）

  1	private ReentrantLock lock = new ReentrantLock();//公平锁
  2	...
  3	if(lock.tryLock()){//如果已经被锁，则会立即返回false不会等待，忽略锁住的业务操作执行
  4	try{
  5	////业务操作
  6	}finally{
  7	lock.unlock();
  8	}
  9	}
  10	...

• 如果发现该操作已经在执行，等待一个一个执行（同步执行，类似synchronized）
• 如果发现该操作已经在执行，则尝试等待一段时间，等待超时则不执行（尝试等待执行）

  1	private ReentrantLock lock = new ReentrantLock();//公平锁
  2	...
  3	if(lock.tryLock(5,TimeUnit.SECONDS)){//尝试等待5秒
  4	try{
  5	////业务操作
  6	}finally{
  7	lock.unlock();
  8	}
  9	}

• 如果发现该操作已经在执行，等待执行。这时可中断正在进行的操作立刻释放锁继续下一操作
  synchronized与Lock在默认情况下是不会响应中断(interrupt)操作，会继续执行完。lockInterruptibly()提供了可中断锁来解决此问题。（场景2的另一种改进，没有超时，只能等待中断或执行完毕）

这种情况主要用于取消某些操作对资源的占用

源码分析

1

/** 同步器：内部类Sync的一个引用 */

2

private final Sync sync;

3

4

/**

5

 * 创建一个非公平锁

6

 */

7

public ReentrantLock() {

8

    sync = new NonfairSync();

9

}

10

11

/**

12

 * 创建一个锁

13

 * @param fair true-->公平锁  false-->非公平锁

14

 */

15

public ReentrantLock(boolean fair) {

16

    sync = (fair)? new FairSync() : new NonfairSync();

17

}

三个内部类Sync/NonfairSync/FairSync

1

/**

2

     * 该锁同步控制的一个基类.下边有两个子类：非公平机制和公平机制.使用了AbstractQueuedSynchronizer类的

3

     */

4

    static abstract class Sync extends AbstractQueuedSynchronizer

5

6

    /**

7

     * 非公平锁同步器

8

     */

9

    final static class NonfairSync extends Sync

10

11

    /**

12

     * 公平锁同步器

13

     */

14

    final static class FairSync extends Sync

ReentrantLock：lock()

1

/**

2

     *获取一个锁

3

     *三种情况：

4

     *1、如果当下这个锁没有被任何线程（包括当前线程）持有，则立即获取锁，锁数量==1，之后再执行相应的业务逻辑

5

     *2、如果当前线程正在持有这个锁，那么锁数量+1，之后再执行相应的业务逻辑

6

     *3、如果当下锁被另一个线程所持有，则当前线程处于休眠状态，直到获得锁之后，当前线程被唤醒，锁数量==1，再执行相应的业务逻辑

7

     */

8

    public void lock() {

9

        sync.lock();//调用NonfairSync（非公平锁）或FairSync（公平锁）的lock()方法

10

    }

NonfairSync：lock()

1

/**

2

         * 1）首先基于CAS将state（锁数量）从0设置为1，如果设置成功，设置当前线程为独占锁的线程；-->请求成功-->第一次插队

3

         * 2）如果设置失败(即当前的锁数量可能已经为1了，即在尝试的过程中，已经被其他线程先一步占有了锁)，这个时候当前线程执行acquire(1)方法

4

         * 2.1）acquire(1)方法首先调用下边的tryAcquire(1)方法，在该方法中，首先获取锁数量状态，

5

         * 2.1.1）如果为0(证明该独占锁已被释放，当下没有线程在使用)，这个时候我们继续使用CAS将state（锁数量）从0设置为1，如果设置成功，当前线程独占锁；-->请求成功-->第二次插队；当然，如果设置不成功，直接返回false

6

         * 2.2.2）如果不为0，就去判断当前的线程是不是就是当下独占锁的线程，如果是，就将当前的锁数量状态值+1（这也就是可重入锁的名称的来源）-->请求成功

7

         *

8

         * 下边的流程一句话：请求失败后，将当前线程链入队尾并挂起，之后等待被唤醒。

9

         *

10

         * 2.2.3）如果最后在tryAcquire(1)方法中上述的执行都没成功，即请求没有成功，则返回false，继续执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法

11

         * 2.2）在上述方法中，首先会使用addWaiter(Node.EXCLUSIVE)将当前线程封装进Node节点node，然后将该节点加入等待队列（先快速入队，如果快速入队不成功，其使用正常入队方法无限循环一直到Node节点入队为止）

12

         * 2.2.1）快速入队：如果同步等待队列存在尾节点，将使用CAS尝试将尾节点设置为node，并将之前的尾节点插入到node之前

13

         * 2.2.2）正常入队：如果同步等待队列不存在尾节点或者上述CAS尝试不成功的话，就执行正常入队（该方法是一个无限循环的过程，即直到入队为止）-->第一次阻塞

14

         * 2.2.2.1）如果尾节点为空（初始化同步等待队列），创建一个dummy节点，并将该节点通过CAS尝试设置到头节点上去，设置成功的话，将尾节点也指向该dummy节点（即头节点和尾节点都指向该dummy节点）

15

         * 2.2.2.1）如果尾节点不为空，执行与快速入队相同的逻辑，即使用CAS尝试将尾节点设置为node，并将之前的尾节点插入到node之前

16

         * 最后，如果顺利入队的话，就返回入队的节点node，如果不顺利的话，无限循环去执行2.2)下边的流程，直到入队为止

17

         * 2.3）node节点入队之后，就去执行acquireQueued(final Node node, int arg)（这又是一个无限循环的过程，这里需要注意的是，无限循环等于阻塞，多个线程可以同时无限循环--每个线程都可以执行自己的循环，这样才能使在后边排队的节点不断前进）

18

         * 2.3.1）获取node的前驱节点p，如果p是头节点，就继续使用tryAcquire(1)方法去尝试请求成功，-->第三次插队（当然，这次插队不一定不会使其获得执行权，请看下边一条），

19

         * 2.3.1.1）如果第一次请求就成功，不用中断自己的线程，如果是之后的循环中将线程挂起之后又请求成功了，使用selfInterrupt()中断自己

20

         * （注意p==head&&tryAcquire(1)成功是唯一跳出循环的方法，在这之前会一直阻塞在这里，直到其他线程在执行的过程中，不断的将p的前边的节点减少，直到p成为了head且node请求成功了--即node被唤醒了，才退出循环）

21

         * 2.3.1.2）如果p不是头节点，或者tryAcquire(1)请求不成功，就去执行shouldParkAfterFailedAcquire(Node pred, Node node)来检测当前节点是不是可以安全的被挂起，

22

         * 2.3.1.2.1）如果node的前驱节点pred的等待状态是SIGNAL（即可以唤醒下一个节点的线程），则node节点的线程可以安全挂起，执行2.3.1.3）

23

         * 2.3.1.2.2）如果node的前驱节点pred的等待状态是CANCELLED，则pred的线程被取消了，我们会将pred之前的连续几个被取消的前驱节点从队列中剔除，返回false（即不能挂起），之后继续执行2.3）中上述的代码

24

         * 2.3.1.2.3）如果node的前驱节点pred的等待状态是除了上述两种的其他状态，则使用CAS尝试将前驱节点的等待状态设为SIGNAL，并返回false（因为CAS可能会失败，这里不管失败与否，都返回false，下一次执行该方法的之后，pred的等待状态就是SIGNAL了），之后继续执行2.3）中上述的代码

25

         * 2.3.1.3）如果可以安全挂起，就执行parkAndCheckInterrupt()挂起当前线程，之后，继续执行2.3）中之前的代码

26

         * 最后，直到该节点的前驱节点p之前的所有节点都执行完毕为止，我们的p成为了头节点，并且tryAcquire(1)请求成功，跳出循环，去执行。

27

         * （在p变为头节点之前的整个过程中，我们发现这个过程是不会被中断的）

28

         * 2.3.2）当然在2.3.1）中产生了异常，我们就会执行cancelAcquire(Node node)取消node的获取锁的意图。

29

         */

30

        final void lock() {

31

            if (compareAndSetState(0, 1))//如果CAS尝试成功

32

                setExclusiveOwnerThread(Thread.currentThread());//设置当前线程为独占锁的线程

33

            else

34

                acquire(1);

35

        }

FairSync：lock()

1

final void lock() {

2

          acquire(1);

3

}

AbstractQueuedSynchronizer：acquire(int arg)就是非公平锁使用的那个方法
FairSync：tryAcquire(int acquires)

1

/**

2

  * 获取公平锁的方法

3

  * 1）获取锁数量c

4

  * 1.1)如果c==0，如果当前线程是等待队列中的头节点，使用CAS将state（锁数量）从0设置为1，如果设置成功，当前线程独占锁-->请求成功

5

  * 1.2)如果c!=0，判断当前的线程是不是就是当下独占锁的线程，如果是，就将当前的锁数量状态值+1（这也就是可重入锁的名称的来源）-->请求成功

6

  * 最后，请求失败后，将当前线程链入队尾并挂起，之后等待被唤醒。

7

  */

8

 protected final boolean tryAcquire(int acquires) {

9

     final Thread current = Thread.currentThread();

10

     int c = getState();

11

     if (c == 0) {

12

         if (isFirst(current) && compareAndSetState(0, acquires)) {

13

             setExclusiveOwnerThread(current);

14

             return true;

15

         }

16

     }

17

     else if (current == getExclusiveOwnerThread()) {

18

         int nextc = c + acquires;

19

         if (nextc < 0)

20

             throw new Error("Maximum lock count exceeded");

21

         setState(nextc);

22

         return true;

23

     }

24

     return false;

25

 }

最后，如果请求失败后，将当前线程链入队尾并挂起，之后等待被唤醒，下边的代码与非公平锁一样。

“大道泛兮，其可左右。
万物恃之而生而不辞，功成不名有。
衣养万物而不为主，常无欲，可名于小；万物归焉而不为主，可名为大。
是以圣人之能成大也，以其不为大也，故能成大。”¹

本文的出发点是记录scala与传统java以及python的不同之处。

行结尾方式 抑或 换行符

跟java不同的地方在于，每一行不必以“;”结尾，除了一个行如果写多条语句时，前面的语句必须以“;”结尾。

1

val rdd = sc.parallelize([1,2,3,4]);println(rdd)

注释

完全跟java一样，/**/用于多行；//用于单行。

package

引入包，有两种方式：

• 跟java相同

  1	package com.c-goshine.sh.demo;

• 有些类似c#

  1	package com.cgoshine.sh.demo{
  2
  3	}

  使用这种方式可以在一个文件中定义多个包。

  import

  跟python有些像，import可以写在文件的任何地方。
  导入某个包下的所有成员，这个跟java的方式有些不同，用“_”来代替java的“*”，如：

  1	import com.cgoshine.sh.demo._ //引入包内所有成员

如果想引用包里的几个成员，可以使用选择器selector

import java.awt.{Color, Font}
// 重命名成员
import java.util.{HashMap => JavaHashMap}
// 隐藏成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员，但是HashMap被隐藏了

注意：默认情况下，Scala 总会引入 java.lang._ 、 scala._ 和 Predef._，这里也能解释，为什么以scala开头的包，在使用时都是省去scala.的。

数据类型

scala与java有着相同的数据类型。

变量声明

用var声明变量；用val声明常量

格式：var VariableName : DataType [= Initial Value]

1

var ss:String [="rzaor"]

2

var ss //裸奔方式

访问修饰符

public private protected

• private
  默认public，其中private比java要严格（在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员）。

  1	class Outer{
  2	class Inner{
  3	private def f(){println("f")}
  4	class InnerMost{
  5	f() // 正确
  6	}
  7	}
  8	(new Inner).f() //错误
  9	}

• protected
  同样也比java的要严格。因为它只允许保护成员在定义了该成员的的类的子类中被访问。而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。

  1	package p{
  2	class Super{
  3	protected def f() {println("f")}
  4	}
  5	class Sub extends Super{
  6	f()
  7	}
  8	class Other{
  9	(new Super).f() //错误
  10	}
  11	}

• 作用域保护

  1	private[x]
  2	protected[x]

  理解为：如果写成private[x],读作”这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是private。这种技巧在横跨了若干包的大型项目中非常有用，它允许你定义一些在你项目的若干子包中可见但对于项目外部的客户却始终不可见的东西。

  1	package bobsrocckets{
  2	package navigation{
  3	private[bobsrockets] class Navigator{
  4	protected[navigation] def useStarChart(){}
  5	class LegOfJourney{
  6	private[Navigator] val distance = 100
  7	}
  8	private[this] var speed = 200
  9	}
  10	}
  11	package launch{
  12	import navigation._
  13	object Vehicle{
  14	private[launch] val guide = new Navigator
  15	}
  16	}
  17	}

  类Navigator被标记为private[bobsrockets]就是说这个类对包含在bobsrockets包里的所有的类和对象可见。
  比如说，从Vehicle对象里对Navigator的访问是被允许的，因为对象Vehicle包含在包launch中，而launch包在bobsrockets中，相反，所有在包bobsrockets之外的代码都不能访问类Navigator。

位运算符

位运算符用来对二进制位进行操作，~,&,|,^分别为取反，按位与与，按位与或，按位与异或运算。
如果指定 A = 60; 及 B = 13; 两个变量对应的二进制为：

1

A = 0011 1100

2

3

B = 0000 1101

4

5

-------位运算----------

6

7

A&B = 0000 1100

8

9

A|B = 0011 1101

10

11

A^B = 0011 0001

12

13

~A  = 1100 0011

Scala 中的按位运算法则如下：

函数 方法

Scala 有函数和方法，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。

• 函数声明

  1	def functionName ([参数列表]) : [return type]

• 函数定义

  1	def functionName ([参数列表]) : [return type] = {
  2	function body
  3	return [expr]
  4	}

  如果函数没有返回值，可以返回为 Unit，这个类似于 Java 的 void。

  1	object add{
  2	def addInt( a:Int, b:Int ) : Int = {
  3	var sum:Int = 0
  4	sum = a + b
  5	return sum
  6	}
  7	def printMe( ) : Unit = {
  8	println("Hello, Scala!")
  9	}
  10	}

  闭包

  闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。
  如下面这段匿名的函数：

  1	val multiplier = (i:Int) => i * 10

  函数体内有一个变量 i，它作为函数的一个参数。如下面的另一段代码：

  1	val multiplier = (i:Int) => i * factor

  在 multiplier 中有两个变量：i 和 factor。其中的一个 i 是函数的形式参数，在 multiplier 函数被调用时，i 被赋予一个新的值。然而，factor不是形式参数，而是自由变量，考虑下面代码：

  1	var factor = 3
  2	val multiplier = (i:Int) => i * factor

  这样定义的函数变量 multiplier 成为一个”闭包”，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。

  1	object Test {
  2	def main(args: Array[String]) {
  3	println( "muliplier(1) value = " + multiplier(1) )
  4	println( "muliplier(2) value = " + multiplier(2) )
  5	}
  6	var factor = 3
  7	val multiplier = (i:Int) => i * factor
  8	}

函数的闭包就是当函数的参数超出其作用域时，我们还能对参数进行访问。

1

scala> def iscala(content:String) = (message:String) => println(content + " "+ message)

2

iscala: (content: String)String => Unit

3

4

scala> val func1 = iscala("spark")

5

func1: String => Unit = $$Lambda$1228/248295195@3dceec83

6

7

scala> func1("hadoop")

8

spark hadoop

9

10

scala> func1("hbase")

11

spark hbase

在调用func1时，将之前的content参数的值延续了下来。

字符串连接

1

string1.concat(string2);

同样你也可以使用加号(+)来连接

• 创建格式化字符串

  1	object Test {
  2	def main(args: Array[String]) {
  3	var floatVar = 12.456
  4	var intVar = 2000
  5	var stringVar = "scala multi-paradigm!"
  6	var fs = printf("浮点型变量为 " +
  7	"%f, 整型变量为 %d, 字符串为 " +
  8	" %s", floatVar, intVar, stringVar)
  9	println(fs)
  10	}
  11	}

  for循环

  1	for( var x <- Range ){
  2	statement(s);
  3	}

  Range 可以是一个数字区间表示 i to j ，或者 i until j。左箭头 <- 用于为变量 x 赋值。
  举个例子：

  1	object Test {
  2	def main(args: Array[String]) {
  3	var a = 0;
  4	// for 循环
  5	for( a <- 1 to 10){
  6	println( "Value of a: " + a );
  7	}
  8	}
  9	}

类和对象

Scala中的类不声明为public，一个Scala源文件中可以有多个类。

1

class Point(xc: Int, yc: Int) {

2

  ……

3

}

继承

Scala继承一个基类跟Java很相似, 但我们需要注意以下几点：

• 重写一个非抽象方法必须使用override修饰符。
• 只有主构造函数才可以往基类的构造函数里写参数。
• 在子类中重写超类的抽象方法时，你不需要使用override关键字。

继承会继承父类的所有属性和方法，Scala 只允许继承一个父类。

单例对象 & 伴生对象

Scala单例对象是十分重要的，不像Java一样，有静态类、静态成员、静态方法，但是Scala提供了object对象，这个object对象类似于Java的静态类,它的成员、它的方法都默认是静态的。
如果object的静态成员要被外界访问，则该成员不能被private修饰。
伴生对象首先是一个单例对象，单例对象用关键字object定义。在Scala中，单例对象分为两种，一种是并未自动关联到特定类上的单例对象，称为独立对象 （Standalone Object）；另一种是关联到一个类上的单例对象，该单例对象与该类共有相同名字，则这种单例对象称为伴生对象（Companion Object），对应类称为伴生类。

Trait(特性)

Scala Trait(特征) 相当于 Java 的接口，实际上它比接口还功能强大。
与接口不同的是，它还可以定义属性和方法的实现。
一般情况下Scala的类只能够继承单一父类，但是如果是 Trait(特征) 的话就可以继承多个，从结果来看就是实现了多重继承。
Trait(特征) 定义的方式与类类似，但它使用的关键字是 trait。

1

package com.cgoshine.sh.demo.scala

2

3

trait Equal {

4

  def isEqual(x:Any):Boolean

5

  def isNotEqual(x:Any):Boolean = !isEqual(x)

6

}

isEqual 方法没有定义方法的实现，isNotEqual定义了方法的实现。子类继承特征可以实现未被实现的方法。所以其实 Scala Trait(特征)更像 Java 的抽象类。

implements这个在scala中到目前为止还没见到，即使“实现”Trait中也是用的extends。

1

class Point(xc: Int, yc: Int) extends Equal {

2

……

3

}

模式匹配

Scala 提供了强大的模式匹配机制，应用也非常广泛。
match 对应 Java 里的 switch，但是写在选择器表达式之后。即： 选择器 match {备选项}。
一个模式匹配包含了一系列备选项，每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

1

object Test {

2

   def main(args: Array[String]) {

3

      println(matchTest(3))

4

5

   }

6

   def matchTest(x: Int): String = x match {

7

      case 1 => "one"

8

      case 2 => "two"

9

      case _ => "many"

10

   }

11

}

“_”，默认的全匹配备选项，即没有找到其他匹配时的匹配项，类似 switch 中的 default。

• 使用样例类
  使用了case关键字的类定义就是就是样例类(case classes)，样例类是种特殊的类，经过优化以用于模式匹配。

  1	object Test {
  2	def main(args: Array[String]) {
  3	val alice = new Person("Alice", 25)
  4	val bob = new Person("Bob", 32)
  5	val charlie = new Person("Charlie", 32)
  6
  7	for (person <- List(alice, bob, charlie)) {
  8	person match {
  9	case Person("Alice", 25) => println("Hi Alice!")
  10	case Person("Bob", 32) => println("Hi Bob!")
  11	case Person(name, age) =>
  12	println("Age: " + age + " year, name: " + name + "?")
  13	}
  14	}
  15	}
  16	// 样例类
  17	case class Person(name: String, age: Int)
  18	}

  在声明样例类时，下面的过程自动发生了：

  构造器的每个参数都成为val，除非显式被声明为var，但是并不推荐这么做；
  在伴生对象中提供了apply方法，所以可以不使用new关键字就可构建对象；
  提供unapply方法使模式匹配可以工作；
  生成toString、equals、hashCode和copy方法，除非显示给出这些方法的定义。

正则表达式

Scala 通过 scala.util.matching 包中的 Regex 类来支持正则表达式。

1

import scala.util.matching.Regex

2

3

object Test {

4

   def main(args: Array[String]) {

5

      val pattern = "Scala".r

6

      val str = "Scala is Scalable and cool"

7

8

      println(pattern findFirstIn str)

9

   }

10

}

使用 String 类的 r() 方法构造了一个Regex对象,然后使用 findFirstIn 方法找到首个匹配项。
如果需要查看所有的匹配项可以使用 findAllIn 方法。你可以使用 mkString( ) 方法来连接正则表达式匹配结果的字符串，并可以使用管道(|)来设置不同的模式：

1

import scala.util.matching.Regex

2

3

object Test {

4

   def main(args: Array[String]) {

5

      val pattern = new Regex("(S|s)cala")  // 首字母可以是大写 S 或小写 s

6

      val str = "Scala is scalable and cool"

7

8

      println((pattern findAllIn str).mkString(","))   // 使用逗号 , 连接返回结果

9

   }

10

}

输出结果为：

1

$ scalac Test.scala

2

$ scala Test

3

Scala,scala

如果你需要将匹配的文本替换为指定的关键词，可以使用 replaceFirstIn( ) 方法来替换第一个匹配项，使用 replaceAllIn( ) 方法替换所有匹配项。

1

object Test {

2

   def main(args: Array[String]) {

3

      val pattern = "(S|s)cala".r

4

      val str = "Scala is scalable and cool"

5

6

      println(pattern replaceFirstIn(str, "Java"))

7

   }

8

}

Scala 的正则表达式继承了 Java 的语法规则，Java 则大部分使用了 Perl 语言的规则。

• 规则：

• 实例：

异常处理

Scala 的异常处理和其它语言比如 Java 类似。

1

throw new FileNotFoundException

如果有异常发生，catch字句是按次序捕捉的。因此，在catch字句中，越具体的异常越要靠前，越普遍的异常越靠后。 如果抛出的异常不在catch字句中，该异常则无法处理，会被升级到调用者处。
捕捉异常的catch子句，语法与其他语言中不太一样。在Scala里，借用了模式匹配的思想来做异常的匹配，因此，在catch的代码里，是一系列case字句:

1

import java.io.FileReader

2

import java.io.FileNotFoundException

3

import java.io.IOException

4

5

object Test {

6

   def main(args: Array[String]) {

7

      try {

8

         val f = new FileReader("input.txt")

9

      } catch {

10

         case ex: FileNotFoundException =>{

11

            println("Missing file exception")

12

         }

13

         case ex: IOException => {

14

            println("IO Exception")

15

         }

16

      }

17

   }

18

}

• finally 语句
  finally 语句用于执行不管是正常处理还是有异常发生时都需要执行的步骤。

  1	import java.io.FileReader
  2	import java.io.FileNotFoundException
  3	import java.io.IOException
  4
  5	object Test {
  6	def main(args: Array[String]) {
  7	try {
  8	val f = new FileReader("input.txt")
  9	} catch {
  10	case ex: FileNotFoundException => {
  11	println("Missing file exception")
  12	}
  13	case ex: IOException => {
  14	println("IO Exception")
  15	}
  16	} finally {
  17	println("Exiting finally...")
  18	}
  19	}
  20	}

  提取器（Extractor）

  提取器是从传递给它的对象中提取出构造该对象的参数。
  Scala 提取器是一个带有unapply方法的对象。unapply方法算是apply方法的反向操作：unapply接受一个对象，然后从对象中提取值，提取的值通常是用来构造该对象的值。

  1	object Test {
  2	def main(args: Array[String]) {
  3
  4	println ("Apply 方法 : " + apply("Zara", "gmail.com"));
  5	println ("Unapply 方法 : " + unapply("Zara@gmail.com"));
  6	println ("Unapply 方法 : " + unapply("Zara Ali"));
  7
  8	}
  9	// 注入方法 (可选)
  10	def apply(user: String, domain: String) = {
  11	user +"@"+ domain
  12	}
  13
  14	// 提取方法（必选）
  15	def unapply(str: String): Option[(String, String)] = {
  16	val parts = str split "@"
  17	if (parts.length == 2){
  18	Some(parts(0), parts(1))
  19	}else{
  20	None
  21	}
  22	}
  23	}

  输出：

  1	$ scalac Test.scala
  2	$ scala Test
  3	Apply 方法 : Zara@gmail.com
  4	Unapply 方法 : Some((Zara,gmail.com))
  5	Unapply 方法 : None

Options Some None

Some和None都是Options的子类，Scala鼓励你在变量和函数返回值可能不会引用任何值的时候使用Option类型。在没有值的时候，使用None；如果有值可以引用，就使用Some来包含这个值。

1

scala> val capitals = Map("France"->"Paris", "Japan"->"Tokyo", "China"->"Beijing")

2

capitals: scala.collection.immutable.Map[String,String] = Map(France -> Paris, Japan -> Tokyo, China -> Beijing)

3

4

scala> capitals get "France"

5

res0: Option[String] = Some(Paris)

6

7

scala> capitals get "Germany"

8

res1: Option[String] = None

当程序回传Some的时候，代表函式返回一个String，你可以调用get()函数获得那个String，如果程序返回的是None，则代表没有字符串可以给你。
在返回None，也就是没有String给你的时候，如果你还硬要调用get()来取得 String 的话，Scala一样是会抛出一个NoSuchElementException异常给你的。
我们也可以选用另外一个方法，getOrElse。这个方法在这个Option是Some的实例时返回对应的值，而在是None的实例时返回传入的参数。换句话说，传入getOrElse的参数实际上是默认返回值。

1

scala> capitals get "Germany" get

2

warning: there was one feature warning; re-run with -feature for details

3

java.util.NoSuchElementException: None.get

4

  ……

5

6

scala> capitals get "France" get

7

warning: there was one feature warning; re-run with -feature for details

8

res3: String = Paris

9

10

scala> (capitals get "Germany") getOrElse "Oops"

11

res7: String = Oops

12

13

scala> capitals get "France" getOrElse "Oops"

14

res8: String = Paris

文件 I/O

Scala 进行文件写操作，直接用的都是 java中 的 I/O 类 （java.io.File)：

1

import java.io._

2

3

object Test {

4

   def main(args: Array[String]) {

5

      val writer = new PrintWriter(new File("demo.txt" ))

6

7

      writer.write("com.cgoshine.sh.demo")

8

      writer.close()

9

   }

10

}

• 从屏幕读取输入

  1	object Test {
  2	def main(args: Array[String]) {
  3	print("input your company's name : " )
  4	val line = Console.readLine
  5
  6	println("thanks,your input is: " + line)
  7	}
  8	}

• 从文件读取
  从文件读取内容非常简单。我们可以使用 Scala 的 Source 类及伴生对象来读取文件。

  1	import scala.io.Source
  2
  3	object Test {
  4	def main(args: Array[String]) {
  5	println("文件内容为:" )
  6
  7	Source.fromFile("test.txt" ).foreach{
  8	print
  9	}
  10	}
  11	}

1:老子《道德经》第三十四章，老子故里，中国鹿邑。

“为学日益，为道日损。
损之又损，以至于无为。
无为而无不为。
取天下常以无事，及其有事，不足以取天下。”¹

列表

字符串索引分片

格式：[lower:upper:step]
[lower,upper)

列表与整数相乘

1

l  = [3,5,'gradient','dropout','l2']

2

l * 2

output:

1

[3, 5, 'gradient', 'dropout', 'l2', 3, 5, 'gradient', 'dropout', 'l2']

列表可以通过索引和分片进行修改

1

l[0] = ['deep learning']

2

l

output:

1

[['deep learning'], 5, 'gradient', 'dropout', 'l2']

1

l[0:2] = ['DeepLearning','regularizatioin']

2

l

output:

1

['DeepLearning', 'regularizatioin', 'gradient', 'dropout', 'l2']

列表中某个元素出现的次数

1

l2 = ["DeepLearning",'normalization']

2

l + l2

3

l3 = l + l2

4

l3

output:

1

['DeepLearning',

2

 'regularizatioin',

3

 'gradient',

4

 'dropout',

5

 'l2',

6

 'DeepLearning',

7

 'normalization']

1

l3.count('DeepLearning')

output:

1

2

元组

跟列表类似，但不可变，且有序。

(12,) #定义单个元素的元组。

1

a = (12,)

2

print a

3

print type(a)

output:

1

(10,)

2

<type 'tuple'>

1

a = (12)

2

print type(a)

output:

1

<type 'int'>

将列表转换为元组

1

tuple(l)

output:

1

('DeepLearning', 'regularizatioin', 'gradient', 'dropout', 'l2')

不可变集合

frozenset

1

flight_distance = {}

2

city_pair = frozenset(['Los Angeles', 'New York'])

3

flight_distance[city_pair] = 2498

4

flight_distance[frozenset(['Austin', 'Los Angeles'])] = 1233

5

flight_distance[frozenset(['Austin', 'New York'])] = 1515

6

flight_distance

output:

1

{frozenset({'Austin', 'New York'}): 1515,

2

 frozenset({'Austin', 'Los Angeles'}): 1233,

3

 frozenset({'Los Angeles', 'New York'}): 2498}

切片

切片的引用机制

1

a = array([0,1,2,3,4])

2

b = a[2:4]

引用机制意味着，Python并没有为 b 分配新的空间来存储它的值，而是让 b 指向了 a 所分配的内存空间，因此，改变 b 会改变 a 的值：

1

b[0] = 10

2

a

output:

1

array([ 0,  1, 10,  3,  4])

可用用.copy()来产生一个复制来避免这种及联修改：

1

b = a[2:4].copy()

花式索引

1

a = array([[ 0, 1, 2, 3, 4, 5],

2

           [10,11,12,13,14,15],

3

           [20,21,22,23,24,25],

4

           [30,31,32,33,34,35],

5

           [40,41,42,43,44,45],

6

           [50,51,52,53,54,55]])

7

a

output:

1

array([[ 0,  1,  2,  3,  4,  5],

2

       [10, 11, 12, 13, 14, 15],

3

       [20, 21, 22, 23, 24, 25],

4

       [30, 31, 32, 33, 34, 35],

5

       [40, 41, 42, 43, 44, 45],

6

       [50, 51, 52, 53, 54, 55]])

对于二维花式索引，我们需要给定 row 和 col 的值：

1

a[(0,1,2,3,4), (1,2,3,4,5)]

2

output:

3

array([ 1, 12, 23, 34, 45]) #返回的是一条次对角线上的5个值。

1

a[3:, [0,2,5]]

2

output:

3

array([[30, 32, 35],

4

       [40, 42, 45],

5

       [50, 52, 55]]) #返回的是最后三行的第1，3，5列。

与切片不同，花式索引返回的是原对象的一个复制而不是引用。

squeeze 方法除去多余的轴

squeeze 返回一个将所有长度为1的维度去除的新数组。

1 :老子《道德经》第四十八章，老子故里，中国鹿邑。

“希言自然。
故飘风不终朝，骤雨不终日。
孰为此者？
天地，天地尚不能久，而况于人乎？
故从事于道者同于道，德者同于德，失者同于失。
故同于道者，道亦得之；同于失，道亦失之。
信不足，焉有不信。”¹

本文对如下方法进行记录：（持续更新）

• zip
• bincount
• enumerate

zip

zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。

1

import numpy as np

2

x = [2,5,3,5]

3

y = [1,3,2,5]

4

z = [8,7,9,0]

5

# i = (3,4,5,6)

6

i = list(zip(x,y,z))

7

i

output:

1

[(2, 1, 8), (5, 3, 7), (3, 2, 9), (5, 5, 0)]

bincount

1

numpy.bincount(x, weights=None, minlength=None)

数组x以及返回的数据bins，bins的数量比x中的最大值+1，bins[i]=x[i]在x中出现的次数。
比如：

1

import numpy as np

2

x = [2,5,3,5]

3

c = np.bincount(x)

4

c

output:

1

array([0, 0, 1, 1, 0, 2])

2

# 0在x中出现0次

3

# 1在x中出现0次

4

# 2在x中出现1次

5

# 3在x中出现1次

6

# 4在x中出现0次

7

# 5在x中出现1次

看一下设置了weights的情况：
bins[i]=sum(x[i]*w[i])

1

import numpy as np

2

x = [2,5,3,5]

3

w = [.4,.3,.7,.1]

4

c = np.bincount(x,w)

5

c

output:

1

array([ 0. ,  0. ,  0.4,  0.7,  0. ,  0.4])

参数minlength貌似只有在minlength>x.len的时候有效，表示bins数组的最小长度。
这篇文章可以移步去看看 - bincount详解

enumerate

• enumerate()是python的内置函数
• enumerate在字典上是枚举、列举的意思
• 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
• enumerate多用于在for循环中得到计数

  1	enum = ['我','爱','北京','天安门']
  2	for index,s in enumerate(enum):
  3	print('index=%d s=%s'% (index,s))

  output:

  1	index=0 s=我
  2	index=1 s=爱
  3	index=2 s=北京
  4	index=3 s=天安门

1 :老子《道德经》，老子故里，中国鹿邑。

“唯之与阿，相去几何？
善之与恶，相去何若？
人之所畏，不可不畏。
荒兮，其未央哉!
众人熙熙，如享太牢，如春登台。
我独泊兮，其未兆，如婴儿之未孩；傫傫兮，若无所归！
众人皆有余，而我独若遗。
我愚人之心也哉!”¹