数据分析(1/3)——Numpy数组基础学习笔记

Numpy

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

一.numpy

1.多维性

a=np.array(5)
print(a)

5

print('a的维度是:',a.ndim)
a的维度是: 0
a=np.array([1,2,3,4,5])
print(a)
print('a的维度是:',a.ndim)

[1 2 3 4 5]

a的维度是: 1

a=np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a)
print('a的维度是:',a.ndim)

[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
a的维度是: 2

2.同质性

a=np.array([1,'array'])#不同数据类型被强制转换成相同数据类型
print(a)

['1' 'array']

同质性是指这个数组里面的元素要是一个类型，但你发现我写的是整型1和字符串型的array，为什么能打印而不报错？仔细看会发现打印结果的1并不是整型，它被添加了引号改成了字符串类型

a=np.array([1,2.5])#不同数据类型被强制转换成相同数据类型
print(a)

[1.  2.5]

1被转换成浮点型

3.ndarray的属性

（1）shape（数据的形状）：行数和列数（或更高维度的尺寸）

使用事例：a.shape

a=np.array([1,2,3])
print(a)
print('数组的形状：',a.shape)

[1 2 3]
数组的形状： (3,)

一维数组shape=(3,)：代表只有长度为 3 的轴，没有区分行 / 列，属于一维线性数组

a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
print('数组的形状：',a.shape)

[[1 2 3]
 [4 5 6]
 [7 8 9]]
数组的形状： (3, 3)

（2）ndim（数据的维度）：数组是几维的（1维是标量，2维是向量，3维及以上是张量或者叫多维数组）

使用事例：a.ndim

a1=np.array(1)
print(a1)
print('a1的维度是:',a1.ndim)
print('\n')
a2=np.array([1,2,3,4,5])
print(a2)
print('a2的维度是:',a2.ndim)
print('\n')
a3=np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a3)
print('a3的维度是:',a3.ndim)

1
a1的维度是: 0


[1 2 3 4 5]
a2的维度是: 1


[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
a3的维度是: 2

（3）size（总元素个数）：数组中所有元素的总数。

使用事例：a.size

a1=np.array(1)
print(a1)
print('a1的元素个数是:',a1.size)
print('\n')
a2=np.array([1,2,3,4,5])
print(a2)
print('a2的元素个数是:',a2.size)
print('\n')
a3=np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a3)
print('a3的元素个数是:',a3.size)

1
a1的元素个数是: 1


[1 2 3 4 5]
a2的元素个数是: 5


[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
a3的元素个数是: 10

（4）dtype（元素类型）：数组中元素的类型（整型，浮点型等）。

使用事例：a.dtype

a1=np.array(1)
print(a1)
print('a1的元素类型是:',a1.dtype)
print('\n')
a2=np.array([1.2,2.3,6.7])
print(a2)
print('a2的元素类型是:',a2.dtype)
print('\n')
a3=np.array([1,2.8])
print(a3)
print('a3的元素类型是:',a3.dtype)

1
a1的元素类型是: int64


[1.2 2.3 6.7]
a2的元素类型是: float64


[1.  2.8]
a3的元素类型是: float64

（5）T（转置）：行变列，列变行。

使用事例：a.T

a1=np.array(1)
print(a1)
print('a1的倒置结果是:',a1.T)
print('\n')
a2=np.array([1,2,3,4,5])
print(a2)
print('a2的倒置结果是:',a2.T)
print('\n')
a3=np.array([[1,2,3,4,5],[6,7,8,9,10]])
print(a3)
print('a3的倒置结果是:',a3.T)

1
a1的倒置结果是: 1


[1 2 3 4 5]
a2的倒置结果是: [1 2 3 4 5]


[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
a3的倒置结果是: [[ 1  6]
 [ 2  7]
 [ 3  8]
 [ 4  9]
 [ 5 10]]

最少2维才能发生倒置，但这个也不常用

4.ndarray的创建

（1）基础构造

#基础的创建方法
#直接创建
a1=np.array([1,2,3,4,5])
print(a1)
print('\n')
#利用list
list1=[6,7,8,9,10]
#还可以利用dtype指定数据类型
a2=np.array(list1,dtype=np.float64)
print(a2)

[1 2 3 4 5]


[ 6.  7.  8.  9. 10.]

#利用copy
a3=np.copy(a1)
print(a3)
a3[0]=8#改了值也不会影响原本的a1，只是拷贝数据过来了一份
print(a3)
print(a1)

[1 2 3 4 5]
[8 2 3 4 5]
[1 2 3 4 5]

（2）预定义形状（直接给定数据形状）

可以让数组全是一个值,但全0，全1，未初始化三种方式会默认数据是浮点型，想要整型可以指定。只有自己设定固定值，会默认是整型，想要浮点型可以指定

#全0
a1=np.zeros((2,))
print(a1)
print('\n')
a2=np.zeros((2,3))
print(a2)
print(a2.dtype)#会默认是浮点型，如果想要整型可以指定
print('\n')
a3=np.zeros((2,3),dtype=int)#指定整型
print(a3)
print(a3.dtype)

[0. 0.]


[[0. 0. 0.]
 [0. 0. 0.]]
float64


[[0 0 0]
 [0 0 0]]
int64

#全1
a1=np.ones((2,))
print(a1)
print('\n')
a2=np.ones((2,3))
print(a2)
print(a2.dtype)#会默认是浮点型，如果想要整型可以指定
print('\n')
a3=np.ones((2,3),dtype=int)#指定整型
print(a3)
print(a3.dtype)

[1. 1.]


[[1. 1. 1.]
 [1. 1. 1.]]
float64


[[1 1 1]
 [1 1 1]]
int64

#未初始化，给随机值
a1=np.empty((2,))
print(a1)
print('\n')
a2=np.empty((2,3))
print(a2)
print(a2.dtype)#会默认是浮点型，如果想要整型可以指定
print('\n')
a3=np.empty((2,3),dtype=int)#指定整型
print(a3)
print(a3.dtype)

[1. 1.]


[[0. 0. 0.]
 [0. 0. 0.]]
float64


[[0 0 0]
 [0 0 0]]
int64

#可自己设立固定值
a1=np.full((2,),2026)
print(a1)
print('\n')
a2=np.full((2,3),7)
print(a2)
print(a2.dtype)#会默认是整型，如果想要浮点型可以指定
print('\n')
a3=np.full((2,3),20,dtype=np.float64)#指定浮点型
print(a3)
print(a3.dtype)

[2026 2026]


[[7 7 7]
 [7 7 7]]
int64


[[20. 20. 20.]
 [20. 20. 20.]]
float64

#小特色用法
a1=np.full((2,),2026)
print(a1)
print('\n')
a2=np.zeros_like(a1)#意思是a2的形状要跟a1一样，但是值全设为0
print(a2)
print('\n')
a3=np.ones_like(a1)
print(a3)
print('\n')
a4=np.empty_like(a1)
print(a4)
print('\n')
a5=np.full_like(a1,2025)
print(a5)
print('\n')

[2026 2026]


[0 0]


[1 1]


[1 1]


[2025 2025]

（3）等差数列

a1=np.arange(2,10,2)#start,end,step,是前闭后开
print(a1)

[2 4 6 8]

（4）等间隔数列

a1=np.linspace(1,10,5)#要求1到10有5个数字，包括1和10，也就是分成4个间隔，每个间隔都是2.25
print(a1)
print('\n')
a2=a1=np.linspace(1,10,2,dtype=int)
print(a2)

[ 1.    3.25  5.5   7.75 10.  ]


[ 1 10]

（5）对数间隔数列

a1=np.logspace(0,4,2,base=2)#要求0到4有2个数字，包括0和4，但是不是打印出0和4，0和4这里是当对数的，也就是对数函数等式右边，我们会打印出它的真数，这个base是以哪个数为底数的意思，这里应该是log以2为底
print(a1)
print('\n')
a2=np.logspace(0,4,3,base=2)
print(a2)

[ 1. 16.]


[ 1.  4. 16.]

其实是分了两步，先用等间隔把数分好，然后再进行运算，得到真数（对数形式的一部分，忘了就搜一下）

（6）特殊矩阵构造

#单位矩阵：主对角线上的数字为1，其他数字为0
a1=np.eye(3,dtype=int)
print(a1)

[[1 0 0]
 [0 1 0]
 [0 0 1]]

#对角矩阵：主对角线上的元素不为0，其他数字为0
a1=np.diag([1,2,3,4,5])#这里是给主对角线赋值
print(a1)

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

（7）随机数组的生成

#生成0到1之间的随机浮点数（均匀分布）
a1=np.random.rand(2,3)#括号里面是写你要的数组形状
print(a1)#每次生成的数都是随机的

[[0.51127308 0.31334984 0.63495631]
 [0.31835499 0.46780483 0.39191956]]

#生成指定范围区间的随机浮点数（均匀分布）
a1=np.random.uniform(3,6,(2,3))#生成3到6的随机浮点数
print(a1)

[[5.17774035 3.74240964 3.59487708]
 [3.77020806 4.0636745  3.45617473]]

#生成指定范围区间的随机整数（均匀分布）
a1=np.random.randint(3,30,(2,3))#生成3到6的随机整数
print(a1)

[[ 5 13 10]
 [19 23 20]]

#生成随机数列（正态分布）
#两边小，中间大
a1=np.random.randn(2,3)
print(a1)

[[ 1.50156707 -0.39777235 -0.98780874]
 [-0.86460356 -0.62973287 -0.57048801]]

#设置随机种子
#这个种子值，每个种子值都对应了一个随机数组，是固定的，上面的随机你会发现每次运行结果都会不一样，但设定了种子值，这个随机只会运行出与种子值配套的结果，你换个电脑，只要输入相同的下面代码，结果也是一样
np.random.seed(20)
a1=np.random.randint(1,10,(2,5))
print(a1)
print('\n')
np.random.seed(200)
a2=np.random.randint(1,10,(2,5))
print(a2)

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


[[1 5 8 7 9]
 [2 8 4 2 8]]

5.ndarray的数据类型

布尔类型bool

整数类型int unit（无符号）

浮点数float

复数complex

（1）布尔类型

a1=np.array([1,0,3,9,0],dtype='bool')#0输出False，非0输出True
print(a1)
print('\n')

[ True False  True  True False]

（2）整型

a1=np.array([1,0,3,9,0])
print(a1)
print('\n')

[1 0 3 9 0]

（3）浮点型

a1=np.array([1.6,3.9,9.8])
print(a1)

[1.6 3.9 9.8]

（4）复数型

6.索引与切片

（1）一维数组

a1=np.random.randint(1,100,20)
print(a1)

[86 25  8 23 55 78 17 71 36 32 33 46 60 46 62 21 86  1  4 56]

print(a1[10])
print('\n')
print(a1[:])#全打印
print('\n')
print(a1[2:5])#打印下标2，3，4
print('\n')
print(a1[slice(2,15,3)])#打印下标2，5，8，11，14
print('\n')
print(a1[(a1>10)&(a1<70)])#打印大于10小于70的数

33


[86 25  8 23 55 78 17 71 36 32 33 46 60 46 62 21 86  1  4 56]


[ 8 23 55]


[ 8 78 36 46 62]


[25 23 55 17 36 32 33 46 60 46 62 21 56]

（2）二维数组

a1=np.random.randint(1,100,(4,8))
print(a1)

[[96 57  4 34 73  1 53 91]
 [62 71 79 77 59 69 63 53]
 [ 7 83 97 28 69 65 90 69]
 [51 95 98 30 89 23  8 34]]

print(a1[1,3])
print('\n')
print(a1[1,2:5])#取第一行，第二列到第四列的数据
print('\n')
print(a1[2][   a1[2] >   50])#取第二行大于50的数
print('\n')
print(a1[:][a1>50])#取所有大于50的数
print('\n')
print(a1[:,3])#取第三列的数据

77


[79 77 59]


[83 97 69 65 90 69]


[96 57 73 53 91 62 71 79 77 59 69 63 53 83 97 69 65 90 69 51 95 98 89]


[34 77 28 30]

7.ndarray的运算

（1）同维度同形状运算

#一维与一维
a=np.array([1,2,3,4,5])
b=np.array([6,7,8,9,10])
print(a+b)#两两对应加上,只有在numpy可以这样写，你要是在python原生语法里面写，这个+代表的是拼接
print('\n')
print(a-b)
print('\n')
print(a*b)
print('\n')
print(a/b)
print('\n')
print(a**2)

[ 7  9 11 13 15]


[-5 -5 -5 -5 -5]


[ 6 14 24 36 50]


[0.16666667 0.28571429 0.375      0.44444444 0.5       ]


[ 1  4  9 16 25]

#二维与二维
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
b=np.array([[4,5,6],[7,8,9],[1,2,3]])
print(a+b)#两两对应加上
print('\n')
print(a-b)
print('\n')
print(a*b)
print('\n')
print(a/b)
print('\n')
print(a**2)

[[ 5  7  9]
 [11 13 15]
 [ 8 10 12]]


[[-3 -3 -3]
 [-3 -3 -3]
 [ 6  6  6]]


[[ 4 10 18]
 [28 40 54]
 [ 7 16 27]]


[[0.25       0.4        0.5       ]
 [0.57142857 0.625      0.66666667]
 [7.         4.         3.        ]]


[[ 1  4  9]
 [16 25 36]
 [49 64 81]]

（2）不同维度不同形状

#不同维度和标量
a=np.array([1,2,3,4,5])
print(a+3)
print('\n')
print(a-3)
print('\n')
print(a*3)
print('\n')
print(a/3)

[4 5 6 7 8]


[-2 -1  0  1  2]


[ 3  6  9 12 15]


[0.33333333 0.66666667 1.         1.33333333 1.66666667]

#不同维度和不同形状会用到广播机制，但广播机制的前提是前面的数据列数要等于后面数据的行数，不然无法实现。广播机制是将它们重复补全，补成同一形状
a=np.array([1,2,3])#1行3列
b=np.array([[4],[5],[6]])#3行1列
'''
a原来是
1 2 3
a被补成
1 2 3
1 2 3
1 2 3
***********
b原来是
4
5
6
b被补成
4 5 6
4 5 6
4 5 6
'''
print(a+b)
print('\n')
print(a-b)
print('\n')
print(a*b)
print('\n')
print(a/b)

(3,)
[[5 6 7]
 [6 7 8]
 [7 8 9]]


[[-3 -2 -1]
 [-4 -3 -2]
 [-5 -4 -3]]


[[ 4  8 12]
 [ 5 10 15]
 [ 6 12 18]]


[[0.25       0.5        0.75      ]
 [0.2        0.4        0.6       ]
 [0.16666667 0.33333333 0.5       ]]

（3）矩阵的运算

a=np.array([[1,2,3],[4,5,6],[7,8,9]])
b=np.array([[4,5,6],[7,8,9],[1,2,3]])
'''
a数据
1 2 3
4 5 6
7 8 9
*******
b数据
4 5 6
7 8 9
1 2 3
*******
第一行第一列这个数的计算结果怎么得来的
1*4+2*7+3*1=21，拿a的第一行乘b的第一列，挨个相加
'''
print(a @ b)#运算符是@，跟线性代数有关知识

[[ 21  27  33]
 [ 57  72  87]
 [ 93 117 141]]

8.基本函数

（1）计算平方根

print(np.sqrt(9))#返回浮点数类型数据
print('\n')
print(np.sqrt([1,4,9]))
print('\n')
a=np.array([1,4,9])
print(np.sqrt(a))

3.0


[1. 2. 3.]


[1. 2. 3.]

（2）计算指数

print(np.exp(0))  #是以e为底，e^x
print('\n')
print(np.exp(1))

1.0


2.718281828459045

（3）计算自然对数

print(np.log(2.71))  #是以e为底，lnx
print('\n')
print(np.log(1))

0.9969486348916096


0.0

（4）计算正余弦

print(np.sin(np.pi/2))#np.pi是Π，180°的意思
print('\n')
print(np.cos(np.pi))

1.0


-1.0

（5）计算a的b次幂

print(np.power(2,3))
print('\n')
a=np.array([1,2,3,4,5])
print(np.power(a,3))

8


[  1   8  27  64 125]

（6）四舍五入

print(np.round([3.2,4.6,8.5,8.51]))#跟纯数学有点区别8.5被舍去，但8.51不会

[3. 5. 8. 9.]

（7）向上向下取整

a=np.array([1.6,25.1,81.7])
print(np.ceil(a))#向上
print('\n')
print(np.floor(a))#向下

[ 2. 26. 82.]


[ 1. 25. 81.]

（8）检测缺失值

np.isnan([1,2,np.nan,3])#第三个数缺失

array([False, False,  True, False])

9.统计函数

求和，计算平均值，计算中位数，标准差，方差

查找最大值和最小值

计算分位数，累计和，累积差

a=np.random.randint(1,20,8)
print(a)

[14 19  7  6 12 11 15  2]

#求和
print(np.sum(a))
print('\n')
print(np.sum([1,2,3]))

86


6

#计算平均值
print(np.mean(a))
print('\n')
print(np.mean([1,2,3]))

10.75


2.0

#计算中位数，会先把元素按升序排好，偶数个元素取中间元素两个相加除以2
print(a)
print('\n')
print(np.median(a))
print('\n')
print(np.median([1,2,3]))

[14 19  7  6 12 11 15  2]


11.5


2.0

#计算方差和标准差
#1 2 3平均值为2，方差等于((1-2)^2+(2-2)^2+(3-2)^2)/3，标准差是将方差开平方根
print(a)
print('\n')
print(np.var([1,2,3]))
print('\n')
print(np.std([1,2,3]))
print('\n')
print(np.var(a))
print('\n')
print(np.std(a))

[14 19  7  6 12 11 15  2]


0.6666666666666666


0.816496580927726


26.4375


5.141740950300783

#计算最大值和最小值
print(a)
print('\n')
print(np.max(a))
print('\n')
print(np.min(a))
print('\n')
print(np.max(a),np.argmax(a))#把最大值的下标也能打出来

[14 19  7  6 12 11 15  2]


19


2


19 1

#查找分位数，一样会先排好序再找，0代表0%的数也就是第一个，100代表100%的数也就是最后一个
print(a)
print('\n')
print(np.percentile(a,0))
print('\n')
print(np.percentile(a,25))#有25%的数会比6.75小
'''
怎么算出6.75的，首先排好序的数据为2 6 7 11 12 14 15 19
八个数中间有七段，7*0.25=1.75，只取小数部分0.75
会落在第二个段，也就是（7-6）*0.75+6=6.75
'''
print('\n')
print(np.percentile(a,50))
print('\n')
print(np.percentile(a,75))
print('\n')
print(np.percentile(a,100))

[14 19  7  6 12 11 15  2]


2.0


6.75


11.5


14.25


19.0

#累积和，累积积
arr=np.array([1,2,3])
print(np.sum(arr))
print('\n')
print(np.cumsum(arr))#输出的数组第二个数等于输入的第一个数和第二个相加，输出的第三个数等于输入的三个数相加
print('\n')
print(np.cumprod(arr))

6


[1 3 6]


[1 2 6]

10.比较函数

比较是否大于，小于，等于

逻辑与，或，非

检查数组中是否有一个True，是否所有的都为True，自定义条件

#是否大于
print(np.greater([3,4,5,6,7],4))#是否大于4
print('\n')
#是否小于
print(np.less([3, 4, 5, 6, 7], 4))
print('\n')
#是否等于
print(np.equal([3, 4, 5, 6, 7], 4))
print('\n')
print(np.equal([3, 4, 5],[4,4,4]))#不同维度不同形状也能用广播机制

[False False  True  True  True]


[ True False False False False]


[False  True False False False]


[False  True False]

#逻辑运算
print(np.logical_and([1,0],[1,1]))#只有两个数都非0就会返回True
print('\n')
print(np.logical_or([1,0],[0,1]))
print('\n')
print(np.logical_not([1,0]))#变成[0,1]
[ True False]


[ True  True]


[False  True]

#检查元素是否至少有一个元素为True，也就是看有没有一个元素是非0的，有返回True，都是0返回False
print(np.any([0,0]))
print('\n')
print(np.any([0,1]))
print('\n')
#检查是否全部元素都为True
print(np.all([1,1]))
print('\n')
print(np.all([0,1]))
print('\n')

False


True


True


False

#自定义条件,where(条件，符合条件才能进来选，不符合条件才能进来选)，可以很好进行分类
a=np.array([1,2,3,4,5])
b=np.array([6,7,8,9,10])
print(np.where(a>3,a,0))
print('\n')
print(np.where(a<3,a,0))
print('\n')
print(np.where(a>3,a,b))

[0 0 0 4 5]


[1 2 0 0 0]


[6 7 8 4 5]

#例子说明：学生分数分类
score=np.random.randint(50,101,20)
print(score)
print('\n')
print(np.where(score>=60,'及格','不及格'))
``
[95 65 67 79 99 58 50 77 57 86 79 88 96 82 93 73 75 51 81 70]


['及格' '及格' '及格' '及格' '及格' '不及格' '不及格' '及格' '不及格' '及格' '及格' '及格' '及格' '及格'
 '及格' '及格' '及格' '不及格' '及格' '及格']

#还可以嵌套
print(np.where(
   score<60,'不及格',np.where(score<80,'良好','优秀')
)
)

['优秀' '良好' '良好' '良好' '优秀' '不及格' '不及格' '良好' '不及格' '优秀' '良好' '优秀' '优秀' '优秀'
 '优秀' '良好' '良好' '不及格' '优秀' '良好']

#或者你用不惯嵌套也可以用select，default是必须要加的
print(np.select([score>80,(score>=60) & (score<=80),score<60],['优秀','良好','不及格'],default='未知'))

['优秀' '良好' '良好' '良好' '优秀' '不及格' '不及格' '良好' '不及格' '优秀' '良好' '优秀' '优秀' '优秀'
 '优秀' '良好' '良好' '不及格' '优秀' '良好']

11.排序函数

np.random.seed(0)
a=np.random.randint(1,100,20)
print(a)
print('\n')
print(np.sort(a))#不会改变原数组
print(np.argsort(a))#打印下标
print('\n')
print(a)
print('\n')
a.sort()#会改变原数组
print(a)

[45 48 65 68 68 10 84 22 37 88 71 89 89 13 59 66 40 88 47 89]


[10 13 22 37 40 45 47 48 59 65 66 68 68 71 84 88 88 89 89 89]
[ 5 13  7  8 16  0 18  1 14  2 15  3  4 10  6  9 17 11 12 19]


[45 48 65 68 68 10 84 22 37 88 71 89 89 13 59 66 40 88 47 89]


[10 13 22 37 40 45 47 48 59 65 66 68 68 71 84 88 88 89 89 89]

12.去重函数

np.random.seed(0)
a=np.random.randint(1,100,20)
print(a)
print('\n')
print(np.unique(a))#去掉重复元素，并且还排好序

[45 48 65 68 68 10 84 22 37 88 71 89 89 13 59 66 40 88 47 89]


[10 13 22 37 40 45 47 48 59 65 66 68 71 84 88 89]

13.数组拼接

a1=np.array([1,2,3,4,5])
a2=np.array([6,7,8,9,10])
print(a1+a2)#只是相加
print('\n')
print(np.concatenate((a1,a2)))

[ 7  9 11 13 15]


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

14.数组的分割

a1=np.array([1,2,3,4,5,6])
print(np.split(a1,2))#要保证是等分的
print('\n')
print(np.split(a1,[1,3]))#不均匀分割法，传下标作为分割点，在下标前面切一刀

[array([1, 2, 3]), array([4, 5, 6])]


[array([1]), array([2, 3]), array([4, 5, 6])]

15.调整数组形状

np.random.seed(0)
a=np.random.randint(1,100,20)
print(a)
print('\n')
print(np.reshape(a,[5,4]))#一定要符合元素个数

[45 48 65 68 68 10 84 22 37 88 71 89 89 13 59 66 40 88 47 89]


[[45 48 65 68]
 [68 10 84 22]
 [37 88 71 89]
 [89 13 59 66]
 [40 88 47 89]]

** 注：用Jupyter写的原文本，调试会更方便，我用块区分了代码和输出结果，便于更好理解**