Numpy学习（2）numpy向量化、numpy操作

1、Numpy创建向量

Numpy创建的数组有时也称为向量，但要注意两者的区别，需要注意数组的秩。
Numpy使用了优化的C api，运算速度快，在深度学习需要运用numpy向量化加快运算速度，NumPy底层用C语言编写，内部解除了GIL(全局解释性锁)，其对数组的操作速度不受python解释器的限制，效率远高于纯python代码。
原因是Numpy数组由相同种类数据类型的元素组成，可以快速确定存储空间。
对整组数据进行快速运算的标准数学函数库，无需编写循环，即内置并行运算功能，当系统进行某种计算时，并且有多个核心时，NumPy会自动做并行计算。
一个大矩阵做运算，for循环是一次提取两个值，放入内存运算后返回结果，再提取2个再运算返回结果。Numpy是一次性把所有值都提入内存同时运算同时返回结果，相当于空间换时间。
标量计算 --> 串行编程 = 同时只能做一件事，一件接一件（for循环）
矢量运算 --> 并行编程 = 同时做所有事（向量化）
标量运算：省空间，费时间
矢量运算：费空间，省时间

import numpy as np
#行向量
x=np.array([[1,2,3,4]])
print(x)
#列向量
x2=np.array([[1],[2],[3],[4]])
print(x2)
#二维向量，矩阵
y=np.arange(1,9).reshape(2,4)
print(y)
#三维向量，矩阵组表，shape（a,b,c）可以理解为a个shape（b,c)的矩阵
z=np.arange(1,9).reshape(2,2,2)
print(z)

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

 [[5 6]
  [7 8]]]

注意创建一维向量时，用shape方法查看数组的秩。

x3=np.array([1,2,3,4])
x3.shape

(4,)

x.shape

(1, 4)

x3=np.array([[1,2,3,4]])#将其赋值为二维数组
x3.shape

(1, 4)

x3只是秩为1的数组，x才是一行四列的行向量，
使用x3在后续进行转置和矩阵乘法等操作时会出现错误。
在进行矩阵的为了让矩阵操作更加显性化，需要将一维向量用矩阵的形式表示。

#shape方法查看维度、矩阵行列尺寸
print(z.shape)
#size查看元素数量
print(z.size)
#ndim查看维度数量，rank秩
print(z.ndim)#shape中元素个数即为维数，乘积即为矩阵中元素数量

(2, 2, 2)
8
3

2、一些方法

1、合并vstack()、concatenate()

n1=np.array([[1,2]])
n2=np.array([[1,2]])
n3=np.array([[1,2]])
n4=np.array([[1,2]])
print(np.vstack((n1,n2)))#向下合并
print(np.hstack((n1,n2)))#向右合并
print(np.concatenate((n1,n2,n3),axis=0))#横向
print(np.concatenate((n1,n2,n3),axis=1))#纵向

[[1 2]
 [1 2]]
[[1 2 1 2]]
[[1 2]
 [1 2]
 [1 2]]
[[1 2 1 2 1 2]]

2、查找最大值和最小值max和min函数，可用axis=0，1，2…控制行列

print(z)
#求和
print(np.sum(z))
#返回最大
print(np.max(z))
#返回最小
print(np.min(z))
print(np.min(z,axis=0))#shape(z,x,y)第一个维度"z"最小值
print(np.min(z,axis=1))#x维度最小行
print(np.min(z,axis=2))#y维度最小列

[[[1 2]
  [3 4]]

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

3、排序、sort(),可用axis=0，1，2…控制行列

# 排序、sort(),可用axis=0，1，2......控制行列 ```


```python
n5=np.array([[5,3,4,1,2]])
print(n5)
print(np.sort(n5))
n6=np.array([[5,3,4],[1,2,0]])
print(n6)
print(np.sort(n6,axis=0))#按行排序（shape中的0行比1行大）
print(np.sort(n6,axis=1))#按列排序

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

4、分割，split()

A=np.arange(12).reshape(3,4)
print(A)
print(np.split(A,3,axis=0))#横向分割成三块，其中split（）中分割的块数只能是行和列的倍数
print(np.split(A,2,axis=1))#纵向分割成两块
print(np.vsplit(A,3))#横向分割成三块，其中split（）中分割的块数只能是行和列的倍数
print(np.hsplit(A,2))#纵向分割成两块

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

5、切片和索引

#一维数组切片
a=np.array([1,2,3,4,5,6,7,8])
#冒号分隔切片
b=a[0:7:4]#从第初始位置0（1）开始到第7个位置（8）结束
print(b)

[1 5]

#向量化后一维度数组相当于二维行、列向量，属于高维数组
a1=np.array([[1,2,3,4]])
print(a1[0])#0相当于第一个维度开始
print(a1[0,0])#或print(a1[0][0])第一个维度中的第一个元素

[1 2 3 4]
1

a2=np.array([[1,2,3,4]]).reshape(2,2)
print(a2)
print(a2[0])
print(a2[0,:2])#默认从0开始

[[1 2]
 [3 4]]
[1 2]
[1 2]

a3=np.arange(9).reshape(3,3)
print(a3)
print('切片',a3[:2,2:])#逗号前切行向量，默认从0第一行开始到2第二行结束（不包括第三行）
#逗号后切列向量，从第三列开始默认从倒数一列结束
print('切片',a3[1,...])#省略号…切片，省略号表示列
print('切片',a3[...,1])#省略号表示行
print(a3[1:2,...])#第二行开始到最后一行元素
print(a3[...,:1])#第一列到第二列元素

[[0 1 2]
 [3 4 5]
 [6 7 8]]
切片 [[2]
 [5]]
切片 [3 4 5]
切片 [1 4 7]
[[3 4 5]]
[[0]
 [3]
 [6]]

#三维数组
a4=np.arange(8).reshape(2,2,2)
print(a4)
print('切片',a4[1,1])
print('索引',a4[0,0,1])

[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
切片 [6 7]
索引 1

6、平均值mean（），方差var()，标准偏差std()

方差var(){[∑(xn-x帽)^2/n]}（x帽为平均值）,
标准偏差std(),Sqr{[∑(xn-x帽)^{2/n]},（**公式中∑代表总和，x拨代表x的算术平均值**,}2代表二次方,代表平方根。

a5=np.array([[4,8,8,4]])
print(np.mean(a5))
print(np.var(a5))
print(np.std(a5))

6.0
4.0
2.0

7、矩阵的形状和转置

#reshape()设置行列
a6=np.array([[0,1,2,3,4,5,6,7]])
print(a6)
print(a6.reshape(2,4))
#转置
print(a6.reshape(2,4).T)

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

transpose()三维以上高维数组的transpose（）转置方法
一维、二维中transpose（）和.T并无区别
使用transpose进行多维数组转置时，将shape数组中的数从0开始排序，并称为索引轴，例如三维数组z为（0，1，2），含三个索引轴0，1，2
然后三个维度/索引轴交换位置，如（1，0，2）是0轴和1轴交换位置

z=np.arange(8).reshape(2,2,2)
print(z)
print(z.transpose(1,0,2))
#相当于将其降维成的二维矩阵[a,b,c,d],其中a,b,c,d为[0,1],[2,3],[4,5],[6,7]
#将[0,1],[2,3],[4,5],[6,7]视为一个元素，然后再转置
print(z.transpose(2,1,0))#z.transpose(2,1,0)=z.T转置
print(z.transpose(2,0,1))

[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
[[[0 1]
  [4 5]]

 [[2 3]
  [6 7]]]
[[[0 4]
  [2 6]]

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

 [[1 3]
  [5 7]]]

当1（或2）角标与0角标交换时，新建一个矩阵，将0角标作为行，1（或2）角标作为列。构成一个新矩阵（2,2）：
z.transpose(1,0,2)转置对下列矩阵：
1 2 1 2
1 [0,1] [2,3]→1 [0,1] [4,5]
2 [4,5] [6,7]→2 [2,3] [6,7]

z.transpose(2,1,0)转置对下列矩阵：
1 2 1 2
1 [0,1] [2,3]→1 [0,4] [2,6]
2 [4,5] [6,7]→2 [1,5] [3,7]

z.transpose(2,0,1)转置对下列矩阵：
1 2 1 2
1 [0,1] [2,3]→1 [0,2] [4,6]
2 [4,5] [6,7]→2 [1,3] [5,7]

可以写出每个数在轴的具体位置，（0，1，2）对应z、x、y轴如三维数组
三轴(0,1,2)z中各元素位置：转置成（2，0，1），相当于z轴换成原来的y轴,x轴换成原来的z轴,y轴换成原来的x轴，
轴 z,x,y z, x, y z.transpose(2,0,1)
0 (0,0,0) （0，0，0） 找 0
1 (0,0,1) （1，0，0） 到 2
2 (0,1,0) （0，0，1） 重 4 →【【【0 2】
3 (0,1,1) （1，0，1） 置 6 → 【4 6】
4 (1,0,0) （0，1，0） 后 1 → 【1 3】
5 (1,0,1) （1，1，0） 新 3 → 【5，7】】】
6 (1,1,0) （0，1，1） 位 5
7 (1,1,1) （1，1，1） 值 7

例如1原本在001位置，转置后到了100位置，那么它的新位置
参照原先的轴z,x,y就是原先的4的位置

#swapaxes()方法
#接收轴编号，对应轴进行交换,只能接受两个轴的对换
z.swapaxes(1,0)#相当于z.transpose(1,0,2)

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

       [[2, 3],
        [6, 7]]])

8、矩阵的特征值(eigenvalues)和特征向量(eigenvectors)

Av =K(λ)v,A为方阵（行列都相等），K为特征值，v为特征向量

a7=np.arange(8).reshape(2,2,2)
print(a7)
eigenvalues ,eigenvectors=np.linalg.eig(a7)
print(eigenvalues)
print(eigenvectors)

[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
[[-0.56155281  3.56155281]
 [-0.17890835 11.17890835]]
[[[-0.87192821 -0.27032301]
  [ 0.48963374 -0.96276969]]

 [[-0.76729658 -0.57152478]
  [ 0.64129241 -0.82058481]]]

9、矩阵的运算

b2 =np.arange(9).reshape(3,3)
b3=b2.T
print(b2)
print(b3)

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

#add()矩阵加法
print(np.add(b2,b3))
#subtract()减法
print(np.subtract(b2,b3))
#数量积*(行*行)
print(b2*b3)#np.multiply(b2,b3)乘法
#dot()向量积/点积(行*列)
print(np.dot(b2,b3))

[[ 0  4  8]
 [ 4  8 12]
 [ 8 12 16]]
[[ 0 -2 -4]
 [ 2  0 -2]
 [ 4  2  0]]
[[ 0  3 12]
 [ 3 16 35]
 [12 35 64]]
[[  5  14  23]
 [ 14  50  86]
 [ 23  86 149]]

10、矩阵的逆运算AB=BA=E

E为单位矩阵，A、B两矩阵互为逆矩阵，也称A是B的逆矩阵

z1= np.array([[1,2,3],[4,5,6],[7,8,9]])
print(z1)
#np.linalg.inv()求逆函数
print(np.linalg.inv(z1))

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[ 3.15251974e+15 -6.30503948e+15  3.15251974e+15]
 [-6.30503948e+15  1.26100790e+16 -6.30503948e+15]
 [ 3.15251974e+15 -6.30503948e+15  3.15251974e+15]]