1、np.argmax()、np.max()、np.argmin()、np.min()用法：

2、np.where(condition[, x, y])

3、np.random中shuffle与permutation的区别

4、np.ascontiguousarray():返回和传入的数组类似的内存中连续的数组

5、np.empty():返回没有初始化的数组，它的值是随机的  

6、np.newaxis：为数组增加一个轴

7、np.tile():将矩阵横向、纵向地复制

8、np.sort()和np.argsort():第一个返回从小到大的排序值，第二个返回从小到大的索引

9、np.cumsum()：返回当前列之前的和加到当前列上的数组

1、np.argmax()、np.max()、np.argmin()、np.min()用法：

  argmax返回的是最大数的索引.argmax有一个参数axis,默认是0。看二维的情况如下：

a = np.array([[1, 5, 5, 2],
              [9, 6, 2, 8],
              [3, 7, 9, 1]])
print(np.argmax(a, axis=0))
[1,2,2,1]  # 返回列表的长度为最里层元素的长度

a = np.array([[1, 5, 5, 2],
              [9, 6, 2, 8],
              [3, 7, 9, 1]])
print(np.argmax(a, axis=1))
[1,0,2]   # 返回列表的长度为次里层元素的长度

    argmax()返回的是元素的索引，而max()返回的则是元素值，max的用法和argmax相似，也有一个axis的参数。同理，argmin()和min()也是相同的用法。

2、np.where(condition[, x, y])

  1)这里x,y是可选参数，condition是条件，这三个输入参数都是array_like的形式；而且三者的维度相同
  2)当conditon的某个位置的为true时，输出x的对应位置的元素，否则选择y对应位置的元素；
  3)如果只有参数condition，则函数返回为true的元素的坐标位置信息；

x = np.arange(9.).reshape(3, 3)
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
print (np.where( x > 5 ))
(array([2, 2, 2]), array([0, 1, 2]))

返回值其实是:
x[2, 0], x[2, 1], x[2, 2]

3、np.random中shuffle与permutation的区别

    函数np.shuffle()与np.permutation()都是对原来的数组进行重新洗牌（即随机打乱原来的元素顺序）,区别在于:

    shuffle直接在原来的数组上进行操作，改变原来数组的顺序，无返回值。而permutation不直接在原来的数组上进行操作，而是返回一个新的打乱顺序的数组，并不改变原来的数组。

4、np.ascontiguousarray():返回和传入的数组类似的内存中连续的数组

 x = np.arange(6).reshape(2,3)
 print (np.ascontiguousarray(x, dtype=np.float32))
 print (x.flags['C_CONTIGUOUS'])

输出：
[[0. 1. 2.]
 [3. 4. 5.]]
True

5、np.empty():返回没有初始化的数组，它的值是随机的  

print (np.empty([2, 2]))

输出：
[[ 0.00000000e+000 -8.77796459e-313]
 [ 1.40447433e-311  6.17582057e-322]]

6、np.newaxis：为数组增加一个轴

x = np.arange(3) 
print (x)
y=x[:, np.newaxis]
print (y)

输出：
array([0, 1, 2])
array([[0], [1], [2]])

7、np.tile():将矩阵横向、纵向地复制

a=np.array([[1,2], [3, 4]])
print (a)
[[1 2]
 [3 4]]
print (np.tile(a, (1, 4)))  # 从最深的维度扩展到原来的4倍
[[1 2 1 2 1 2 1 2]
 [3 4 3 4 3 4 3 4]]
print (np.tile(a, (3, 1)))  # 从次深的维度扩展到原来的3倍
[[1 2]
 [3 4]
 [1 2]
 [3 4]
 [1 2]
 [3 4]]
print (np.tile(a, (3, 4)))  # 首先最深的维度扩展4倍，然后次深的维度扩展3倍
[[1 2 1 2 1 2 1 2]
 [3 4 3 4 3 4 3 4]
 [1 2 1 2 1 2 1 2]
 [3 4 3 4 3 4 3 4]
 [1 2 1 2 1 2 1 2]
 [3 4 3 4 3 4 3 4]]

8、np.sort()和np.argsort():第一个返回从小到大的排序值，第二个返回从小到大的索引

a=np.array([1,3,2,4])    
print (np.sort(a))     # 返回从小到大的排序
[1 2 3 4]
print (np.argsort(a))  # 返回从小到大的排序索引
[0 2 1 3]
print (np.argsort(-a)) # 返回从大到小的排序索引
[3 1 2 0]

9、np.cumsum()：返回当前列之前的和加到当前列上的数组

a=[1,2,3,4,5,6,7]
print (np.cumsum(a))
[ 1  3  6 10 15 21 28]
c=[[1,2,3],[4,5,6],[7,8,9]]
print (np.cumsum(c,axis=0))  # 0(第一行不动，其他行累加)
[[ 1  2  3]
 [ 5  7  9]
 [12 15 18]]
print (np.cumsum(c,axis=1))  # 1(第一列列不动，其他列累加)
[[ 1  3  6]
 [ 4  9 15]
 [ 7 15 24]]

引言：
没有绝对优秀的构造函数的方法，每一种方法都有他们的优缺点，我们需要考虑的是知道他们的应用场景，合理的使用他们，从而达到自己的要求。

1.Object构造函数模式
使用方式：先创建空对象，再添加属性/方法
适用场景：起始时不确定对象内部的数据
缺点：语句太多

var person = new Object()
person.age = 15
person.name = 'Bob'
person.run = function () {
  console.log('run');
}

2.对象字面量
使用方式：使用{}创建对象，同时指定属性/方法
适用场景：起始时对象内部数据确定
缺点：如果创建多个对象，有重复代码

var person = {
  name: 'Bob',
  age: 15,
  run() {
    console.log('run');
  }
}
var person2 = {
  name: 'Jack',
  age: 13,
  run() {
    console.log('run');
  }
}

3.工厂模式
使用方式：通过工厂函数动态创建对象并返回
适用场景：需要创建多个对象
缺点：对象没有具体的类型，都是Object类型

function createPerson(age, name) { //返回一个对象的函数==》工厂函数
  var obj= {
    name: name,
    age: age,
    run() {
      console.log('run');
    }
  }
  return obj
}

var p1 = createPerson(14,'Bob')
var p2 = createPerson(15,'Jack')
console.log(p1 instanceof createPerson) //false

4.自定义构造函数模式
使用方式：自定义构造函数，通过new创建实例对象
适用场景：需要创建多个类型确定的对象
缺点：每个对象都有相同的数据，浪费内存

function Person(age, name) {
  this.name = name
  this.age = age
  this.run = function () {
    console.log('run');
  }
}

var p1 = new Person(15, 'Bob')
console.log(p1 instanceof Person)//true

function Dog(age, name) {
  this.name = name
  this.age = age
  this.eat = function () {
    console.log('eat');
  }
}
var d1 = new Dog(3, 'JoJo')
console.log(d1 instanceof Dog)//true

每一个实例上都有相同的方法，但是每一次创建却需要再创建一次。

var p1 = new Person(15, 'Bob')
var p2 = new Person(13, 'Jack')
console.log(p1, p2)

5.构造函数+原型的组合
使用方式：自定义构造函数，属性在函数中初始化，方法添加到原型上
适用场景：需要创建多个类型确定的对象

function Person(age, name) {
  this.name = name
  this.age = age
}

Person.prototype.setName = function (name) {
  //这里的this是指向每一个实例化后的对象
  this.name = name
}

现在他的原型上都有一个共有的方法

var p1 = new Person(15, 'Bob')
var p2 = new Person(13, 'Jack')
console.log(p1, p2)

6.动态原型模式
动态原型函数模式把所有信息都封装在了构造函数中，在构造函数中初始化原型，又保持了同时使用构造函数和原型的优点。

function Person(age, name) {
  this.name = name
  this.age = age

  if (typeof this.sayName != 'function') {
    Person.prototype.sayName = function () {
      alert(this.name)
    }
  }
}

var p = new Person(15, 'Bob')
console.log(p);

如果不用if判断的方式直接在原型上添加方法，那么每一次new一个实例对象的时候都会去重写原型，浪费内存空间，而如果加了判断那么在原型只会在第一次实例话对象的时候就生成了，以后每一次new实例均不会再重写原型对象。

7.稳妥构造函数模式
所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this的对象。稳妥对象最适合在一些安全环境中。

function Person(age, name) {
  var o = new Object()
  job = 'kuli' //私有属性
  o.sayName = function () { //共有函数
    console.log(name);
  }
  o.sayJob = function () {
    console.log(job);
  }
  return o
}

var p = new Person(15, 'Jack')
console.log(p);
console.log(p.sayName(), p.sayJob());//Jack kuli
console.log(p.name)//undefined 只能通过调用sayName方法查看name属性

8.es6 class
与组合构造函数非常相似，语法更加精炼简洁。

class Person {
  constructor(age, name) {
    this.age = age
    this.name = name
  }
  setName(name) {
    this.name = name
  }
}

var p1 = new Person(13, 'Bob')
p1.setName('Jack')
console.log(p1);

一、前言

看到这么个题目时，一脸懵逼，不知道说的啥意思，然后就多读了两边题目发现，如果有一阶楼梯，那你就一步就上去了，也就一种方案。如果有两阶楼梯，你可以一个一个的上，你也可以一次跨俩，那么就是两种了，于是就开始了数学式的计算：如下图：

n=3时，种类为1+2
n=4时，种类为3+2（上图少个（2，2）也就是五种）
n=5时，种类为5+3
n=n时，种类为：（n–1）+（n-2）
以此类推，像不像高中的那啥函数？在编程中是如何实现的呢

二、上代码

 function stairs(n){
            if(n==1){
                return 1;
            }
            else if(n==2){
                return 2
            }else{
                return stairs(n-1)+stairs(n-2)
            }
        }

如果题目条件加入一次可上3阶呢？道理是一样的，动动手，就出来了