4. Python数值计算工具 Numpy

Numpy模块

• 数组的创建与操作
• 数组的基本数学运算
• 常用数学和统计函数
• 线性代数的求解
• 伪随机数的创建

4.1 数组的创建和操作

数组的创建

#导入模块，并重命名为np
import numpy as np
#单个列表 创建一位数组
arr1 = np.array([1,34,6,87,3,56,8,23,4])
#嵌套元素创建二维数组
arr2 = np.array(((2,4,2,45.7,6),(7,4,6,8,3),(1,2,34,4,5),(7,8,98,5,23)))
print('一维数组：',arr1)
print('二维数组: ',arr2)

OUT：
一维数组： [ 1 34  6 87  3 56  8 23  4]
二维数组:  [[ 2.   4.   2.  45.7  6. ]
 [ 7.   4.   6.   8.   3. ]
 [ 1.   2.  34.   4.   5. ]
 [ 7.   8.  98.   5.  23. ]]

数组元素的获取

#一维数组元素的获取
print(arr1[[2,3,5,7]])
#二维数组元素的获取
#第二行第三列
print(arr2[1,2])
#第三行所有元素
print(arr2[2,:])
#第二列的元素
print(arr2[:,1])
#第二行至第四行，第二列至第五列
print(arr2[1:3,1:4])

OUT：
[ 6 87 56 23]
6.0
[ 1.  2. 34.  4.  5.]
[4. 4. 2. 8.]
[[ 4.  6.  8.]
 [ 2. 34.  4.]]

取出数组中的某些行某些列组成一个数组。

#第一行、最后一行和第二列、第四列构成的数组
print(arr2[np.ix_([0,-1],[1,3])])
#第一行、最后一行和第二列、第三列、第四列构成的数组
print(arr2[np.ix_([0,-1],[1,2,3])])

OUT：
[[ 4.  45.7]
 [ 8.   5. ]]
[[ 4.   2.  45.7]
 [ 8.  98.   5. ]]

数组的常用属性。
如果是从外部读取的数据，那么我们对数据是一无所知的，可以通过一些属性来对数据有一个初步的了解。在Numpy模块中，可以通过genfromtxt函数读取外部文本文件的数据，这里的文本文件主要是csv和txt文件。genfromtxt函数有一些参数，如下：

• fname：指定需要读入数据的文件路径。
• dtype：指定读入数据的数据类型，默认为浮点型，如果原数据集中含有字符型数据，比如指定数据类型为”str“。
• comments：指定注释符，默认为“#”，如果原数据的行首有“#”，将忽略这些行的输入。
• delimiter：指定数据集的列分割符。
• skip_header：是否跳过数据集的行首，默认不跳过。
• skip_footer：是否跳过数据集的脚注，默认不跳过。
• converters：将指定列的数据转换成其他数值。
• miss_values：指定缺失值的标记，如果原数据集含有指定的标记，读入后这样的数据就为缺失值。
• usecols：指定需要读入哪些列。
• names：为读入数据的列设置列名称。

#读入数据
import numpy as np
stu_message = np.genfromtxt(fname=r'C:\Users\SyGod\Desktop\stu_message.txt',delimiter='\t',skip_header=1)
#查看数据结构
print(type(stu_message))
#查看数据维数
print(stu_message.ndim)
#查看数据行列数
print(stu_message.shape)
#查看数组元素的数据类型
print(stu_message.dtype)
#查看数组元素的个数
print(stu_message.size)


OUT：
<class 'numpy.ndarray'>
1
(83,)
float64
83

数组的形状处理
数组形状处理的手段 主要有reshape、resize、ravel、flatten、vsack、hstack、row_stack和column_stack。

import numpy as np
arr3 = np.array([[1,5,7],[3,6,1],[4,6,8],[7,9,4],[1,4,6],[3,7,4]])
#数组的行列数
print(arr3.shape)
#使用reshape方法更改数组的形状
print(arr3.reshape(2,9))
#打印数组的行列数
print(arr3.shape)

#使用resize方法改变数组的形状
print(arr3.resize(2,9))
#打印数组的行列数
print(arr3.shape)

OUT:
(6, 3)
[[1 5 7 3 6 1 4 6 8]
 [7 9 4 1 4 6 3 7 4]]
(6, 3)
None
(2, 9)

虽然reshape和resize方法都是用来改变数组形状的方法，但是reshape方法只是返回改变形状后的预览，并未真正改变数组arr3的形状；而resize方法则不会返回预览，但是会直接改变数组arr3的形状，从前后次两次打印的arr3形状就可以发现两者的区别。如果需要将多维数组降为一维数组，利用ravel、faltten和reshape三种方法可以接解决。

import numpy as np
arr4 = np.array([[1,10,100],[2,20,200],[3,30,300]])
print('原数组：\n',arr4)
#默认排序降维
print('数组降维：\n',arr4.ravel())
print(arr4.flatten())
print(arr4.reshape(-1))
#改变排序模式的降维
print(arr4.ravel(order = 'F'))
print(arr4.flatten(order = 'F'))
print(arr4.reshape(-1 , order = 'F'))

OUT：
原数组：
 [[  1  10 100]
 [  2  20 200]
 [  3  30 300]]
数组降维：
 [  1  10 100   2  20 200   3  30 300]
[  1  10 100   2  20 200   3  30 300]
[  1  10 100   2  20 200   3  30 300]
[  1   2   3  10  20  30 100 200 300]
[  1   2   3  10  20  30 100 200 300]
[  1   2   3  10  20  30 100 200 300]

以上的结果显示，在默认情况下，优先按照数组的行顺序，逐个将元素降至一维；如果按原始数据的列顺序，降为一维的话，需要设置order参数为“F”。尽管这三个方法的功能一致，但是还是有一些差异。

import numpy as np
arr4 = np.array([[1,10,100],[2,20,200],[3,30,300]])
#更改预览之
arr4.flatten()[0] = 2000
print('flatten方法：\n',arr4)
arr4.ravel()[1] = 1000
print('ravel方法：\n',arr4)
arr4.reshape(-1)[2] = 3000
print('reshape方法：\n',arr4)

OUT：
flatten方法：
 [[  1  10 100]
 [  2  20 200]
 [  3  30 300]]
ravel方法：
 [[   1 1000  100]
 [   2   20  200]
 [   3   30  300]]
reshape方法：
 [[   1 1000 3000]
 [   2   20  200]
 [   3   30  300]]

上述结果显示，通过flatten方法实现的降度返回的是复制，因为对降维后的元素做修改，并没有影响到原数组arr4的结果；相反，ravel方法与reshape方法返回的则是视图，通过对视图的改变，是会影响到原数组的arr4的。
vstack用于垂直方向的数组堆叠，其功能与row_stack函数一致，而hstack则用于水平方向的数组合并，其功能与column_stack一致，下面通过例子对这四种函数进行说明。

import numpy as np
arr5 = np.array([1,2,3])
arr4 = np.array([[1,10,100],[2,20,200],[3,30,300]])
print('vstack纵向堆叠数组：\n',np.vstack([arr4,arr5]))
print('row_stack纵向堆叠数组：\n',np.row_stack([arr4,arr5]))
arr6 = np.array([[5],[15],[25]])
print('hstack横向合并数组：\n',np.hstack([arr4,arr6]))
print('column_stack横向合并数组：\n',np.column_stack([arr4,arr6]))


OUT：
vstack纵向堆叠数组：
 [[  1  10 100]
 [  2  20 200]
 [  3  30 300]
 [  1   2   3]]
row_stack纵向堆叠数组：
 [[  1  10 100]
 [  2  20 200]
 [  3  30 300]
 [  1   2   3]]
hstack横向合并数组：
 [[  1  10 100   5]
 [  2  20 200  15]
 [  3  30 300  25]]
column_stack横向合并数组：
 [[  1  10 100   5]
 [  2  20 200  15]
 [  3  30 300  25]]

如上结果所示，前两个输出是纵向堆叠的效果，后两个则是横向合并的效果。如果是多个数组的纵向堆叠，必须保证每个数组的列数相同；如果是将多个数组按横向合并的话，则必须保证每个数组的行数必须相同。