Numpy的小总结

1.Numpy是什么？

numpy是Python的一个科学计算库，提供矩阵运算的功能。

1.1Numpy的导入

import numpy as np #一般都是用numpy的别名来进行操作

1.2Numpy的常用函数

np.array((1.2,2,3,4), dtype=np.int32)

这里是强制定义了np里面的矩阵数据类型，是让其为int32位，如果其中有小数的，都会转换成整数。

numpy向量转为矩阵：

arr1 = np.array([1,2,3,4,5,6,6,6])

print(arr1.reshape(2,4))

reshape完之后，就变成矩阵了

arr1.shape()则显示矩阵的情况，就是是几维矩阵，矩阵的长度如何。

arr1.dtype显示arr1矩阵的数据的类型，这里上边定义的是int类型的

import numpy as np

print(np.array((1.2,2,3,4.1), dtype=np.int32))

arr1 = np.array([1,2,3,4,5,6,6,6])
print(arr1.reshape(2,4))
print(arr1.dtype)

np.linspace(1,10,10)

#起始值为第一个参数，终点值为第二个参数，然后第三个参数是把这个区间的数，分为多少，这里的输出结果是从1到10
矩阵之间是可以运算的，但是要注意的是什么？就是矩阵的长度得是对应的。比如二维对二维，并且相对应运算行的长度得相同

import numpy as np
a = np.array([[1,2,3],[2,3,4]])
b = np.array([[2,3,4],[2,3,4]])
print(a -b)
"""结果输出:[[-1 -1 -1]
 [ 0  0  0]]"""

矩阵点乘

行乘列得出结果，看输出结果中的9可以看出，是a的第一行乘以b的第一列。

import numpy as np
a = np.array([[1,2,3],[2,3,4],[1,1,1]])
b = np.array([[2,3,4],[2,3,4],[1,1,1]])
print(np.dot(a,b))
"""输出结果[[ 9 12 15]
 [14 19 24]
 [ 5  7  9]]
"""

np.floor(矩阵)向下取整，就是传进来的矩阵，如果是3.5，就会变成3这样子

矩阵.ravel()会变成向量

import numpy as np
a = np.array([[1,2,3],[2,3,4],[1,1,1]])
print(a.ravel())
"""输出结果：[1 2 3 2 3 4 1 1 1]"""

 矩阵拼接

vstack和hstack，我发现只能凭借相同大小的，就是如果矩阵不等长的话则按照断的来拼接。像矩阵a的第二行，有五个数，但是最终只拼接了三个

import numpy as np
a = np.array([[1,2,3],[2,3,4,5,6],[1,1,1]])
a = np.array([[1,2,3],[2,3,4],[1,1,1]])
print(np.hstack((a,b)))
print(np.vstack((a,b)))
"""输出结果:[[1 2 3 2 3 4]
 [2 3 4 2 3 4]
 [1 1 1 1 1 1]]
[[1 2 3]
 [2 3 4]
 [1 1 1]
 [2 3 4]
 [2 3 4]
 [1 1 1]]"""

矩阵切分

按照行来切,这里在第三行和第四行切了，因此，产生了三个矩阵

a = np.floor(10*np.random.random((2,12))) #按行切
print(a)
print(np.hsplit(a,(3,4)))
"""结果：[[ 0.  2.  0.  3.  3.  1.  5.  9.  1.  5.  5.  9.]
 [ 5.  5.  1.  7.  3.  0.  8.  3.  4.  7.  0.  7.]]
[array([[ 0.,  2.,  0.],
       [ 5.,  5.,  1.]]), array([[ 3.],
       [ 7.]]), array([[ 3.,  1.,  5.,  9.,  1.,  5.,  5.,  9.],
       [ 3.,  0.,  8.,  3.,  4.,  7.,  0.,  7.]])]"""

 按列来分,想切几刀就切几刀，切多少下，只要没超过它的列数，就可以切。

import numpy as np
a = np.floor(10*np.random.random((12,2)))
print(a)
print(np.vsplit(a,3))
"""运行结果[[ 7.  5.]
 [ 4.  9.]
 [ 9.  9.]
 [ 9.  7.]
 [ 8.  6.]
 [ 4.  4.]
 [ 6.  7.]
 [ 3.  2.]
 [ 8.  1.]
 [ 4.  2.]
 [ 2.  5.]
 [ 0.  0.]]
[array([[ 7.,  5.],
       [ 4.,  9.],
       [ 9.,  9.],
       [ 9.,  7.]]), array([[ 8.,  6.],
       [ 4.,  4.],
       [ 6.,  7.],
       [ 3.,  2.]]), array([[ 8.,  1.],
       [ 4.,  2.],
       [ 2.,  5.],
       [ 0.,  0.]])]"""

 

至于访问切出来的矩阵，很简单，就是参考数组，既然切成了多个矩阵，那就是按照不同的下标来访问咯，比如上边的结果想拿到第一个数组的第一个数字，则只要赋值了之后，用

赋值的变量[0][0][0]就可以访问到了，注意数组嵌套的情况。