#### 1，交换排序--冒泡法

#### 2，选择排序 

##### 简单选择排序 

两两比较大小，找出极大值或极小值，然后将其放在固定的位置。
两个数从左到右，两两比较，记录较大值的索引。
第一轮下来，将本轮最大值和索引0的交换
第二轮，将本轮最大值和索引1交换（此时需要比较的次数-1次）
第N轮完成后，排序完成。
N为数字的个数。




```
m_list=[
    [1,9,8,5,6,7,4,3,2],
    [1,2,3,4,5,6,7,8,9],
    [9,8,7,6,5,4,3,2,1]    
]
nums = m_list[0]
length = len(nums)
print(nums)

count_swap = 0
count_iter = 0

for i in range(length):  #i=0
    maxindex=i  #maxindex = 0
    
    for j in range(i+1,length): #j in range[1,9)  j =1 
        count_iter +=1
        if nums[maxindex] < nums[j]:  #muns[0] < num[1] 如果极大的值小于[j],则把j的值赋值给maxindex 
            maxindex = j  # maxindex = 1
    if i != maxindex: #如果i的值不等于maxindex的值 ，将最大的id的值给指定的 id 。 
        tmp = nums[i]  #tmp = nums[i]
        #print(nums[i])
        nums[i]=nums[maxindex] #
        #print(nums[i])
        #print(nums[maxindex])
        nums[maxindex] =tmp
        count_swap +=1
print(nums,count_swap,count_iter)
```

    [1, 9, 8, 5, 6, 7, 4, 3, 2]
    [9, 8, 7, 6, 5, 4, 3, 2, 1] 7 36


##### 二元选择排序


python排序相关

js学习笔记，仅供自己使用！


### 数值型


```javascript
// 最大安全整数
var big = Number.MAX_VALUE
console.log(big)

// 
var min = Number.MIN_VALUE
console.log(min)
```

    1.7976931348623157e+308
    5e-324





    undefined




```javascript
var infin = Number.POSITIVE_INFINITY
console.log(infin)
```

    Infinity





    undefined



1. 合理值，均为双精度浮点型，数值合理范围-(2的53次方-1) 到（2的53次方-1)
2. 正负无穷（+Infinity）（-Infinity）,处理除0异常问题
3. NaN


```javascript
1/0
```




    Infinity




```javascript
a = Number.NaN
```




    NaN



####  相关方法


```javascript
console.log(Number.parseFloat('123234.xx')) // 将字符串转换成浮点数
console.log(Number.parseFloat('123234.11'))
```

    123234
    123234.11





    undefined




```javascript
console.log(Number.parseInt('111.222')) // 将字符串转换成整型
```

    111





    undefined




```javascript
Number.isFinite(23213232.223) // 判断传入的数字是否为有限数字
```




    true




```javascript
Number.isInteger(23213232.223) // 判断传入的数字是否为整型
```




    false




```javascript
Number.isNaN(23213232.223) // 判断传入的数字是否为NaN
```




    false



#### math
数学计算相关函数
使用连接：
https://www.w3school.com.cn/js/jsref_obj_math.asp

```javascript
var pi_value=Math.PI;
var sqrt_value=Math.sqrt(15);
console.log(pi_value)
console.log(sqrt_value)
console.log(Math.abs(-1.3)) // 求绝对值
```

    3.141592653589793
    3.872983346207417
    1.3





    undefined



### 运算符

#### 逻辑运算符
与或非 && ! ||
####  比较运算符
!== |=== ：严格相对，不做隐式转换
> < >= <= != ==

```javascript
console.log(100>'200') // f
console.log(300>'200') // t
console.log(300>'2000') //f
console.log(300>'2a') //f
console.log('3000'>'2000') //t 

// 宽松
console.log(300=='300') // t
console.log('300'=='300') //t 

// 严格
console.log(300==='300') // f
console.log('300'==='300') //t
```

    false
    true
    false
    false
    true
    true
    true
    false
    true





    undefined



#### 三元运算符

表达式1?表达式2:表达式3
(true|false)?“true”，

```javascript
(1)?'a':'b'
```




    'a'



#### 其他操作符


```javascript
console.log('a' instanceof String)  //判断是否属于指定的类型
a = new String('b')
console.log(a instanceof String)  // instanceof 需要构建个onj才能使用
```

    false
    true





    undefined




```javascript
console.log(typeof('a')) // 判断对象的类型
```

    string





    undefined


delete 删除对象、属性、数组元素
in 判断指定的属于在对象内，在返回true

```javascript
let trees = new Array('A','BAY','cc',1)

for (var i=0;i<trees.length;i++)
    console.log(trees[i])

console.log(trees.length)
```

    A
    BAY
    cc
    1
    4





    undefined



### 生成器 
语法
function* 函数名(参数){函数体}

```javascript
function* gogo(){
    i = 0 
    while (true) {
        yield i++    
    }
}
gen = gogo()
console.log(gen.next().value)
console.log(gen.next().value)
console.log(gen.next().value)
```

    0
    1
    2





    undefined



### 解构


```javascript
var parts = ['s','k']
var l = ['a',...parts,'b']
l
```




    [ 'a', 's', 'k', 'b' ]




```javascript
function f(x,y,z) {
    console.log(x+y+z)
}
               
var a = [2,3,4]
f(...a)
```

    9





    undefined



### js打印九九乘法表 


```javascript
for (let x=1;x<10;x++)
{
    line = '';
    //console.log('aa',x) x = 1
    for (let y=1;y<=x;y++){ // y = 1 
        //console.log(y)
        line += ` ${y}*${x}=${x*y} `
        if (x==y)
            console.log(line)
        
    }
}
```

     1*1=1 
     1*2=2  2*2=4 
     1*3=3  2*3=6  3*3=9 
     1*4=4  2*4=8  3*4=12  4*4=16 
     1*5=5  2*5=10  3*5=15  4*5=20  5*5=25 
     1*6=6  2*6=12  3*6=18  4*6=24  5*6=30  6*6=36 
     1*7=7  2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49 
     1*8=8  2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64 
     1*9=9  2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81 





    undefined



### js的函数 
function 函数名（参数）{
函数体
}

```javascript
function add(x,y){
    return x+y
}

add(1,-1)
// 简单函数
```




    0



#### 函数表达式


```javascript
var a = function add(x,y){
    return x+y
}

console.log(a(1,1))

//函数表达式内的函数名称只能内部使用，可以省略
//
```

    2





    undefined




```javascript
// 求和函数
x = 10 

var sum = function _sum(x){
    result = 0 
    while(x){
        result+=x
        x --
    }
    console.log(result)
    
}
sum(x)
```

    55





    undefined




```javascript
// 递归求和函数
x = 10000

var sum = function _sum(n){
    let result = 0 
    if (n==1) return 1;
    return result += n +_sum(--n)
    console.log(result)
    
}
sum(x)
```




    50005000


匿名函数

```javascript
var a = function (x,y){
    return x+y
}

console.log(a(1,1))

```

    2





    undefined



### 高阶函数 
输入或者输出是函数的函数被称为高阶函数

```javascript
function a(){
    console.log('a')
    return function b(){
        console.log('b')
        
    }
}
```




    undefined




```javascript
c= a()
c()
```

    a
    b





    undefined




```javascript
let counter = function(){
    let i = 0;
    function inc(){
        return ++i
    }
    return inc;   
}

c= counter()

console.log(c())
console.log(c())
console.log(c())
console.log(c())
console.log(c())

```

    1
    2
    3
    4
    5





    undefined




```javascript
let counter = function(){
    let i = 0;
    return ++i
}
c = counter()
console.log(c)
console.log(c)
console.log(c)

```

    1
    1
    1





    undefined




```javascript
function  add(x,y){
    return x+y
}
a = add
a(1,2)
```




    3




```javascript

```

JavaScript（2）：js发展史及基础语法

js学习笔记，仅供自己使用！

### 1. 相关工具
需要安装的工具：

1. nodejs
2. Visual Studio Code
3. Visual Studio Code 调用nodejs插件Node Exec 使用F8 运行代码 
#### js开发官方文档
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide
#### nodejs
http://nodejs.cn/
#### Visual Studio Code
https://code.visualstudio.com/
### 2. 简述 

js是 一款动态的弱类型的脚本解释型语言

html css js 三大前端核心技术

html(超文本标记语言)
css(层叠样式表)
js:JavaScript是一种属于网络的脚本语言,已经被广泛用于Web应用开发,常用来为网页添加各式各样的动态功能,为用户提供更流畅美观的浏览效果。

js实现网页动态化
1995年 js诞生

div css 布局
js 变化

#### es

ECMA262
是一款脚本程序设计语言标准
js 就是根据ECMA262标准实现的

#### v8 

v8引擎 chrome出品
将js的代码编译成字节码，大大提升了网站的性能

#### nodejs

nodejs是服务器端运行js代码的程序
npm是软件管理工具，发布分享nodejs的库和源代码
nodejs 4.0 引入es6的语言特性
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行时
采用事件驱动，非阻塞的异步io模型 高效

### 3. js的注释 
js 使用/*注释内容*/ 或者 // 注释内容
或者
/***
*
*
*/
### 4. js常量和变量
常量的申明const，常量申明不可改变
变量申明三种方式
var a = 1
a = 1
let a = 1 推荐使用 es6引入

let适用于块作用域内
var 可以突破一般的块作用域，但是不能突破函数作用域
使用var 可以提升作用域的位置，一般在程序里定义var变量，会最优先提前到最前位置（会引发程序错乱，推荐使用let）

### 5. js的数据类型 

js的常见类型：
1. 数值number
2. 布尔boolean（true | false）
3. 字符串string
4. null
5. underfined
6. object类型

js是动态弱类型测试，类型之间存在隐式类型转换

1. 其他类型+字符串
全部转换为字符串,+代表字符串拼接
2. 没有字符串，有数字
全部转换为数字，+代表做算符
3. NaN数字类型
console.log(a=null+undefined) ==>  NaN
console.log(a=null+undefined) ==>  NaN
4. null，true，false 可以默认为数字类型
null=0 true=1 false=0
5. 短路操作
console.log(a=null && true,typeof(a))
console.log(a=false && null,typeof(a))
console.log(a=false && 'aa',typeof(a))
console.log(a=true && 'aa',typeof(a))
console.log(a=false && null,typeof(a))

输出结果：
null object
false boolean
false boolean
aa string
false boolean

&&： 前者为真则为真
a && b：如果a是false，那么b不管是true还是false，都返回false，因此不用判断b了，这个时候刚好判断到a，因此返回a。
如果a是true，那么就要在判断b，和刚刚一样，不管b是true是false，都返回b。
||：
a || b：如果a是true，那么b不管是true还是false，都返回true。因此不用判断b了，这个时候刚好判断到a，因此返回a。
如果a是false，那么就要判断b，如果b是true，那么返回true，如果b是false，返回false

在js中：
以下内容会被当成false处理："" , false , 0 , null , undefined , NaN
其他都是true。注意：字符串"false"也会被当做true处理，在未转型的情况下他是字符串，属于一个对象，所以是true。

### 6. js的字符串

#### 1. 定义 
1. 单双引号定义
2. 反引号定义
可以使用字符串占位替换(字符串差值)。es6支持
let name = 'mykernel'
let age = 18 

str = `my name is ${ name },i am ${age}`
console.log(str)
结果：
my name is mykernel,i am 18

####  2. str 转义


```

```

####  3. str 支持的方法
let a_str = 'my name is mykernel,i am 18'
let b = 'good'
console.log(a_str.charAt(3)) // 打印索引为3的字符
console.log(a_str[3])  // 打印索引为3的字符
console.log(a_str.toLocaleUpperCase()) // 转换为大写
console.log(a_str.concat(b)) // 拼接字符串b
console.log(a_str.slice(3)) // 切片
console.log(a_str.slice(3,10))
console.log(a_str.slice(-5,-3))
console.log('分割:',a_str.split('.'))
console.log('截取1:',a_str.substr(7,2)) // 字符串截取，从索引为7开始，截取2个字符
console.log('截取2:',a_str.substring(7,15)) //  字符串截取，从索引为7开始到15
/*定位字符串的索引*/
console.log(a_str.indexOf('m'))

/*字符串替换*/
console.log(a_str.replace('mykernel','zaizai'))

/*去除空格*/
s = '    aaa  '
console.log(s.trim())

JavaScript（1）：js发展史及基础语法

js学习笔记，仅供自己使用！

### 1. 相关工具
需要安装的工具：
1. nodejs
2. Visual Studio Code
3. Visual Studio Code 调用nodejs插件Node Exec 使用F8 运行代码 
#### js开发官方文档
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide
#### nodejs
http://nodejs.cn/
#### Visual Studio Code
https://code.visualstudio.com/
### 2. 简述 

js是一款动态的弱类型的脚本解释型语言

html css js 三大前端核心技术

html(超文本标记语言)
css(层叠样式表)
js:JavaScript是一种属于网络的脚本语言,已经被广泛用于Web应用开发,常用来为网页添加各式各样的动态功能,为用户提供更流畅美观的浏览效果。

js实现网页动态化
1995年 js诞生

div css 布局
js 变化

#### es

ECMA262
是一款脚本程序设计语言标准
js 就是根据ECMA262标准实现的

#### v8 

v8引擎 chrome出品
将js的代码编译成字节码，大大提升了网站的性能

#### nodejs

nodejs是服务器端运行js代码的程序
npm是软件管理工具，发布分享nodejs的库和源代码
nodejs 4.0 引入es6的语言特性
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行时
采用事件驱动，非阻塞的异步io模型 高效

### 3. js的注释 
js 使用/*注释内容*/ 或者 // 注释内容
或者
/***
*
*
*/
### 4. js常量和变量
常量的申明const，常量申明不可改变
变量申明三种方式
var a = 1
a = 1
let a = 1 推荐使用 es6引入

let适用于块作用域内
var 可以突破一般的块作用域，但是不能突破函数作用域
使用var 可以提升作用域的位置，一般在程序里定义var变量，会最优先提前到最前位置（会引发程序错乱，推荐使用let）

### 5. js的数据类型 

js的常见类型：
1. 数值number
2. 布尔boolean（true | false）
3. 字符串string
4. null
5. underfined
6. object类型

js是动态弱类型测试，类型之间存在隐式类型转换

1. 其他类型+字符串
全部转换为字符串,+代表字符串拼接
2. 没有字符串，有数字
全部转换为数字，+代表做算符
3. NaN数字类型
console.log(a=null+undefined) ==>  NaN
console.log(a=null+undefined) ==>  NaN
4. null，true，false 可以默认为数字类型
null=0 true=1 false=0
5. 短路操作
console.log(a=null && true,typeof(a))
console.log(a=false && null,typeof(a))
console.log(a=false && 'aa',typeof(a))
console.log(a=true && 'aa',typeof(a))
console.log(a=false && null,typeof(a))

输出结果：
null object
false boolean
false boolean
aa string
false boolean

&&： 前者为真则为真
a && b：如果a是false，那么b不管是true还是false，都返回false，因此不用判断b了，这个时候刚好判断到a，因此返回a。
如果a是true，那么就要在判断b，和刚刚一样，不管b是true是false，都返回b。
||：
a || b：如果a是true，那么b不管是true还是false，都返回true。因此不用判断b了，这个时候刚好判断到a，因此返回a。
如果a是false，那么就要判断b，如果b是true，那么返回true，如果b是false，返回false

在js中：
以下内容会被当成false处理："" , false , 0 , null , undefined , NaN
其他都是true。注意：字符串"false"也会被当做true处理，在未转型的情况下他是字符串，属于一个对象，所以是true。

### 6. js的字符串

#### 1. 定义 
1. 单双引号定义
2. 反引号定义
可以使用字符串占位替换(字符串差值)。es6支持
let name = 'mykernel'
let age = 18 

str = `my name is ${ name },i am ${age}`
console.log(str)
结果：
my name is mykernel,i am 18

####  2. str 转义


```python

```

####  3. str 支持的方法
let a_str = 'my name is mykernel,i am 18'
let b = 'good'
console.log(a_str.charAt(3)) // 打印索引为3的字符
console.log(a_str[3])  // 打印索引为3的字符
console.log(a_str.toLocaleUpperCase()) // 转换为大写
console.log(a_str.concat(b)) // 拼接字符串b
console.log(a_str.slice(3)) // 切片
console.log(a_str.slice(3,10))
console.log(a_str.slice(-5,-3))
console.log('分割:',a_str.split('.'))
console.log('截取1:',a_str.substr(7,2)) // 字符串截取，从索引为7开始，截取2个字符
console.log('截取2:',a_str.substring(7,15)) //  字符串截取，从索引为7开始到15
/*定位字符串的索引*/
console.log(a_str.indexOf('m'))

/*字符串替换*/
console.log(a_str.replace('mykernel','zaizai'))

/*去除空格*/
s = '    aaa  '
console.log(s.trim())

#### 1. 对象的创建


```
import numpy as np

# 创建一维数组
a= np.arange(5)
print(a)
print(a.dtype)
print(len(a))
print(a.shape)
```

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



```
# 创建二维数组
b = np.array([np.arange(3),np.arange(3)])
print(b)

# 按照列表的长度计算
print(len(b))

#打印对应的行和列
print(b.shape)
```

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

创建数组时候指定类型

```
print(np.arange(7,dtype=float))
print(np.arange(7,dtype=int))
```

    [0. 1. 2. 3. 4. 5. 6.]
    [0 1 2 3 4 5 6]


#### 2. 查询

一维数组的切片和索引(可以参考标准列表)


```
d = np.arange(10)
print(d[4:])
print(d[:-1])

# 逆序打印
print(d[::-1])
print(d[3])
```

    [4 5 6 7 8 9]
    [0 1 2 3 4 5 6 7 8]
    [9 8 7 6 5 4 3 2 1 0]
    3


多维数据的切片和索引


```
c = np.array([np.arange(3),np.arange(3,6)])
print(c)
```

    [[0 1 2]
     [3 4 5]]


获取元素


```
# 第一个元素为行 第二个元素为列
c[0][1]  
# c[3][4]
```




    1




```
c[0]
```




    array([0, 1, 2])



#### 3. 多维数组的形态变换

##### 1. 构建多维数组


```
b = np.arange(24).reshape(3,8)  # 3列 8排
print('In:b \n',b)

# 拉平
print(b.ravel())
print(b.flatten())
```

    In:b 
     [[ 0  1  2  3  4  5  6  7]
     [ 8  9 10 11 12 13 14 15]
     [16 17 18 19 20 21 22 23]]
    [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
    [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]



```
b = np.arange(120).reshape(3,2,5,4) 
print(b)
```

    [[[[  0   1   2   3]
       [  4   5   6   7]
       [  8   9  10  11]
       [ 12  13  14  15]
       [ 16  17  18  19]]
    
      [[ 20  21  22  23]
       [ 24  25  26  27]
       [ 28  29  30  31]
       [ 32  33  34  35]
       [ 36  37  38  39]]]
    
    
     [[[ 40  41  42  43]
       [ 44  45  46  47]
       [ 48  49  50  51]
       [ 52  53  54  55]
       [ 56  57  58  59]]
    
      [[ 60  61  62  63]
       [ 64  65  66  67]
       [ 68  69  70  71]
       [ 72  73  74  75]
       [ 76  77  78  79]]]
    
    
     [[[ 80  81  82  83]
       [ 84  85  86  87]
       [ 88  89  90  91]
       [ 92  93  94  95]
       [ 96  97  98  99]]
    
      [[100 101 102 103]
       [104 105 106 107]
       [108 109 110 111]
       [112 113 114 115]
       [116 117 118 119]]]]


##### 2. 转换为一维数组，拉平


```
b.ravel()
```




    array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
            13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
            26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
            39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
            52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
            65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
            78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
            91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102, 103,
           104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
           117, 118, 119])




```
b.flatten()
```




    array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
            13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
            26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
            39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
            52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
            65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
            78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
            91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102, 103,
           104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
           117, 118, 119])



##### 3. 转换为二维数组（12x10）


```
b.shape = (12,10)
b
```




    array([[  0,   1,   2,   3,   4,   5,   6,   7,   8,   9],
           [ 10,  11,  12,  13,  14,  15,  16,  17,  18,  19],
           [ 20,  21,  22,  23,  24,  25,  26,  27,  28,  29],
           [ 30,  31,  32,  33,  34,  35,  36,  37,  38,  39],
           [ 40,  41,  42,  43,  44,  45,  46,  47,  48,  49],
           [ 50,  51,  52,  53,  54,  55,  56,  57,  58,  59],
           [ 60,  61,  62,  63,  64,  65,  66,  67,  68,  69],
           [ 70,  71,  72,  73,  74,  75,  76,  77,  78,  79],
           [ 80,  81,  82,  83,  84,  85,  86,  87,  88,  89],
           [ 90,  91,  92,  93,  94,  95,  96,  97,  98,  99],
           [100, 101, 102, 103, 104, 105, 106, 107, 108, 109],
           [110, 111, 112, 113, 114, 115, 116, 117, 118, 119]])



##### 4. 转置


```
print(b.transpose())  
```

    [[  0  10  20  30  40  50  60  70  80  90 100 110]
     [  1  11  21  31  41  51  61  71  81  91 101 111]
     [  2  12  22  32  42  52  62  72  82  92 102 112]
     [  3  13  23  33  43  53  63  73  83  93 103 113]
     [  4  14  24  34  44  54  64  74  84  94 104 114]
     [  5  15  25  35  45  55  65  75  85  95 105 115]
     [  6  16  26  36  46  56  66  76  86  96 106 116]
     [  7  17  27  37  47  57  67  77  87  97 107 117]
     [  8  18  28  38  48  58  68  78  88  98 108 118]
     [  9  19  29  39  49  59  69  79  89  99 109 119]]



```
print(b)
```

    [[  0   1   2   3   4   5   6   7   8   9  10  11]
     [ 12  13  14  15  16  17  18  19  20  21  22  23]
     [ 24  25  26  27  28  29  30  31  32  33  34  35]
     [ 36  37  38  39  40  41  42  43  44  45  46  47]
     [ 48  49  50  51  52  53  54  55  56  57  58  59]
     [ 60  61  62  63  64  65  66  67  68  69  70  71]
     [ 72  73  74  75  76  77  78  79  80  81  82  83]
     [ 84  85  86  87  88  89  90  91  92  93  94  95]
     [ 96  97  98  99 100 101 102 103 104 105 106 107]
     [108 109 110 111 112 113 114 115 116 117 118 119]]



```
# 数组变形，修改自身吗，同reshape
b.resize(12,10)  
print(b)
```

    [[  0   1   2   3   4   5   6   7   8   9]
     [ 10  11  12  13  14  15  16  17  18  19]
     [ 20  21  22  23  24  25  26  27  28  29]
     [ 30  31  32  33  34  35  36  37  38  39]
     [ 40  41  42  43  44  45  46  47  48  49]
     [ 50  51  52  53  54  55  56  57  58  59]
     [ 60  61  62  63  64  65  66  67  68  69]
     [ 70  71  72  73  74  75  76  77  78  79]
     [ 80  81  82  83  84  85  86  87  88  89]
     [ 90  91  92  93  94  95  96  97  98  99]
     [100 101 102 103 104 105 106 107 108 109]
     [110 111 112 113 114 115 116 117 118 119]]


####  4. 多维数组的堆叠

##### 1. 横向叠放


```
a = np.arange(20).reshape(4,5)
print(a)
b = np.arange(20,40).reshape(4,5)
print(b)
```

    [[ 0  1  2  3  4]
     [ 5  6  7  8  9]
     [10 11 12 13 14]
     [15 16 17 18 19]]
    [[20 21 22 23 24]
     [25 26 27 28 29]
     [30 31 32 33 34]
     [35 36 37 38 39]]



```
np.hstack((a,b))
#print((a,b))
```




    array([[ 0,  1,  2,  3,  4, 20, 21, 22, 23, 24],
           [ 5,  6,  7,  8,  9, 25, 26, 27, 28, 29],
           [10, 11, 12, 13, 14, 30, 31, 32, 33, 34],
           [15, 16, 17, 18, 19, 35, 36, 37, 38, 39]])




```
np.concatenate((a,b),axis = 1)
```




    array([[ 0,  1,  2,  3,  4, 20, 21, 22, 23, 24],
           [ 5,  6,  7,  8,  9, 25, 26, 27, 28, 29],
           [10, 11, 12, 13, 14, 30, 31, 32, 33, 34],
           [15, 16, 17, 18, 19, 35, 36, 37, 38, 39]])



##### 2. 竖向叠放


```
np.vstack((a,b))
```




    array([[ 0,  1,  2,  3,  4],
           [ 5,  6,  7,  8,  9],
           [10, 11, 12, 13, 14],
           [15, 16, 17, 18, 19],
           [20, 21, 22, 23, 24],
           [25, 26, 27, 28, 29],
           [30, 31, 32, 33, 34],
           [35, 36, 37, 38, 39]])




```
np.concatenate((a,b),axis = 0)
```




    array([[ 0,  1,  2,  3,  4],
           [ 5,  6,  7,  8,  9],
           [10, 11, 12, 13, 14],
           [15, 16, 17, 18, 19],
           [20, 21, 22, 23, 24],
           [25, 26, 27, 28, 29],
           [30, 31, 32, 33, 34],
           [35, 36, 37, 38, 39]])



##### 3. 深度叠加
深度叠加：除此之外，还有一种深度叠加方法，这要用到dstack（）函数和一个元组。这种方法是沿着第三个坐标轴（纵向）的方向来叠加一摞数组。举例来说，可以在一个图像数据的二维数组上叠加另一幅图像的数据。

```
print("a:",a)
print("b:",b)
print("v:",np.dstack((a,b)))
```

    a: [[ 0  1  2  3  4]
     [ 5  6  7  8  9]
     [10 11 12 13 14]
     [15 16 17 18 19]]
    b: [[20 21 22 23 24]
     [25 26 27 28 29]
     [30 31 32 33 34]
     [35 36 37 38 39]]
    v: [[[ 0 20]
      [ 1 21]
      [ 2 22]
      [ 3 23]
      [ 4 24]]
    
     [[ 5 25]
      [ 6 26]
      [ 7 27]
      [ 8 28]
      [ 9 29]]
    
     [[10 30]
      [11 31]
      [12 32]
      [13 33]
      [14 34]]
    
     [[15 35]
      [16 36]
      [17 37]
      [18 38]
      [19 39]]]


#### 5. 多维数组的拆分


```
a = np.arange(20).reshape(4,5)
a
```




    array([[ 0,  1,  2,  3,  4],
           [ 5,  6,  7,  8,  9],
           [10, 11, 12, 13, 14],
           [15, 16, 17, 18, 19]])



##### 1. 横向拆分



```
np.hsplit(a,5)
```




    [array([[ 0],
            [ 5],
            [10],
            [15]]), array([[ 1],
            [ 6],
            [11],
            [16]]), array([[ 2],
            [ 7],
            [12],
            [17]]), array([[ 3],
            [ 8],
            [13],
            [18]]), array([[ 4],
            [ 9],
            [14],
            [19]])]



![横向拆分](http://qiniu.mykernel.cn/%E6%A8%AA%E5%90%91%E6%8B%86%E5%88%86.png)


```
np.split(a,5,axis = 1)
```




    [array([[ 0],
            [ 5],
            [10],
            [15]]), array([[ 1],
            [ 6],
            [11],
            [16]]), array([[ 2],
            [ 7],
            [12],
            [17]]), array([[ 3],
            [ 8],
            [13],
            [18]]), array([[ 4],
            [ 9],
            [14],
            [19]])]



##### 2. 纵向拆分


```
a = np.arange(20).reshape(4,5)
```


```
np.vsplit(a,4)
```




    [array([[0, 1, 2, 3, 4]]),
     array([[5, 6, 7, 8, 9]]),
     array([[10, 11, 12, 13, 14]]),
     array([[15, 16, 17, 18, 19]])]




```
np.split(a,4,axis = 0)
```




    [array([[0, 1, 2, 3, 4]]),
     array([[5, 6, 7, 8, 9]]),
     array([[10, 11, 12, 13, 14]]),
     array([[15, 16, 17, 18, 19]])]



![纵向拆分](http://qiniu.mykernel.cn/%E7%BA%B5%E5%90%91%E6%8B%86%E5%88%86.png)

##### 3. 深向拆分


```
c = np.arange(27).reshape(3,3,3)
c
```




    array([[[ 0,  1,  2],
            [ 3,  4,  5],
            [ 6,  7,  8]],
    
           [[ 9, 10, 11],
            [12, 13, 14],
            [15, 16, 17]],
    
           [[18, 19, 20],
            [21, 22, 23],
            [24, 25, 26]]])




```
np.dsplit(c,3)
```




    [array([[[ 0],
             [ 3],
             [ 6]],
     
            [[ 9],
             [12],
             [15]],
     
            [[18],
             [21],
             [24]]]), array([[[ 1],
             [ 4],
             [ 7]],
     
            [[10],
             [13],
             [16]],
     
            [[19],
             [22],
             [25]]]), array([[[ 2],
             [ 5],
             [ 8]],
     
            [[11],
             [14],
             [17]],
     
            [[20],
             [23],
             [26]]])]



#### 6. 其他属性 


```
b = np.arange(24).reshape(2,12)
b
```




    array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
           [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])


秩，即轴的数量或维度的数量

```
print(b.ndim)
```

    2

返回元素个数

```
print(b.size)
```

    24

返回数组的维度，对于矩阵，n 行 m 列，数组的形状

```
print(b.shape)
```

    (2, 12)

返回对象中每个元素的大小，以字节为单位
一个元素类型为 float64 的数组 itemsiz 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。

```
print(b.itemsize)
```

    8

