[Python与数学建模-数据处理与可视化]-1数值计算工具Nu
虽然列表list可以完成数组操作，但不是真正意义上的数组，当数据量很大时，其速度很慢，故提供了NumPy扩展库完成数组操作。很多高级扩展库也依赖于它，比如Scipy、Pandas和Matplotlib等。
NumPy提供了两种基本的对象：ndarray（N-dimensional Array Object）和ufunc（Universal Function Object）。ndarray（称为array数组，下文统一称为数组）是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的通用函数。
1数组的创建、属性和操作
1.1数组的创建
通过NumPy库的array函数实现数组的创建，如果向array函数中传入了一个列表或元组，将构造简单的一维数组；如果传入多个嵌套的列表或元组，则可以构造一个二维数组。构成数组的元素都具有相同的数据类型。下面分别构造一维数组和二维数组。
例2.1 利用array函数创建数组示例。
程序文件Pex2_1.py
import numpy as np #导入模块并命名为np
a = np.array([2,4,8,20,16,30]) #单个列表创建一维数组
#嵌套元组创建二维数组
b = np.array(((1,2,3,4,5),(6,7,8,9,10),
(10,9,1,2,3),(4,5,6,8,9.0)))
print("一维数组：",a)
print("二维数组：\n",b)
执行结果：
一维数组：
[ 2 4 8 20 16 30]
二维数组：
[[ 1. 2. 3. 4. 5.]
[ 6. 7. 8. 9. 10.]
[10. 9. 1. 2. 3.]
[ 4. 5. 6. 8. 9.]]
如上结果所示，可以将列表或元组转换为一个数组。在第二个数组b中，输入的元素含有整型和浮点型两种数据类型，但输出的数组元素都转化为相同的浮点型。
例2.2 利用arange、linspace、empty等函数生成数组示例。
程序文件Pex2_2.py
import numpy as np
a=np.arange(4,dtype=float) #创建浮点型数组：[0., 1.,2., 3.]
b=np.arange(0,10,2,dtype=int) #创建整型数组：[0, 2, 4, 6, 8]
c=np.empty((2,3),int) #创建2×3的整型空矩阵
d=np.linspace(-1,2,5) #创建数组：[-1., -0.25, 0.5, 1.25, 2.]
e=np.random.randint(0,3,(2,3)) #生成[0,3)上的2行3列的随机整数数组
注2.1
（1）上面程序运行后，没有输出，如果想看输出结果，读者可以自己加上print语句；我们以后的程序设计中，对于一些不重要的中间结果，也不输出了。或者使用Anaconda运行，在Spyder的控制台下可以直接看到输出结果。
（2）empty函数只分配数组所使用的内存，不对数组元素值进行初始化操作，因此它的运行速度是最快的，上述程序中c=np.empty((2,3),int)的返回值是随机的，每次运行都是不一样的。
例2.3 使用虚数单位“j”生成数组。
程序文件Pex2_3.py
import numpy as np
a=np.linspace(0,2,5) #生成数组：[0., 0.5, 1., 1.5, 2.]
b=np.mgrid[0:2:5j] #等价于np.linspace(0,2,5)
x,y=np.mgrid[0:2:4j,10:20:5j] #生成[0,2]×[10,20]上的4×5的二维数组
print("x={}\ny={}".format(x,y))
1.2数组的属性
为了更好地理解和使用数组，了解数组的基本属性是十分必要的。数组的属性及其说明如表2.1所列。
图片.png
图片.png
程序文件Pex2_4.py
import numpy as np
a=np.random.randint(1,11,(3,5)) #生成[1,10]区间上3行5列的随机整数数组
print("维数：",a.ndim); #维数：2
print("维度：",a.shape) #维度：（3,5）
print("元素总数：",a.size); #元素总数：15
print("类型：",a.dtype) #类型：int32
print("每个元素字节数：",a.itemsize) #字节数：4
例2.5 生成数学上一维向量的三种模式。
程序文件Pex2_5.py
import numpy as np
a=np.array([1,2,3])
print("维度为：",a.shape) #维度为：（3,)
b=np.array([[1,2,3]])
print("维度为：",b.shape) #维度为：（1,3）
c=np.array([[1],[2],[3]])
print("维度为：",c.shape) #维度为：（3,1）
1.3数组元素的索引
NumPy中的array数组与Python基础数据结构列表（list）的区别是：列表中的元素可以是不同的数据类型，而array数组只允许存储相同的数据类型。
①对于一维数组来说，Python原生的列表和NumPy的数组的切片操作都是相同的，无非是记住一个规则：列表名（或数组名）[start: end: step]，但不包括索引end对应的值。
②二维数据列表元素的引用方式为a[i][j]；array数组元素的引用方式为a[i,j]。
NumPy比一般的Python 序列提供更多的索引方式。除了用整数和切片的一般索引外，数组还可以布尔索引及花式索引。
（1）一般索引
例2.6 数组索
引示例。
程序文件Pex2_6.py
import numpy as np
a = np.array([2,4,8,20,16,30])
b = np.array(((1,2,3,4,5),(6,7,8,9,10),
(10,9,1,2,3),(4,5,6,8,9.0)))
print(a[[2,3,5]]) #一维数组索引，输出：[ 8 20 30]
print(a[[-1,-2,-3]]) #一维数组索引，输出：[30 16 20]
print(b[1,2]) #输出第2行第3列元素：8.0
print(b[2]) #输出第3行元素：[10. 9. 1. 2. 3.]
print(b[2,:]) #输出第3行元素：[10. 9. 1. 2. 3.]
print(b[:,1]) #输出第2列所有元素：[2. 7. 9. 5.]
print(b[[2,3],1:4]) #输出第3、4行，第2、3、4列的元素
print(b[1:3,1:3]) #输出第2、3行，第2、3列的元素
如上结果所示，在一维数组的索引中，可以将任意位置的索引组装为列表，用作对应元素的获取；在二维数组中，位置索引必须写成[rows,cols]的形式，方括号的前半部分用于控制二维数组的行索引，后半部分用于控制数组的列索引。如果需要获取所有的行或列元素，那么，对应的行索引或列索引需要用英文状态的冒号表示。
（2）布尔索引
例2.7 布尔索引示例。
程序文件Pex2_7.py
from numpy import array, nan, isnan
a=array([[1, nan, 2], [4, nan, 3]])
b=a[~isnan(a)] #提取a中非nan的数
print("b=",b)
print("b中大于2的元素有：", b[b>2])
运行结果：
b= [1. 2. 4. 3.]
b中大于2的元素有： [4. 3.]
（3）花式索引
花式索引的索引值是一个数组。对于使用一维整型数组作为索引，如果被索引数据是一维数组，那么索引的结果就是对应位置的元素；如果被索引数据是二维数组，那么就是对应下标的行。
对于二维被索引数据来说，索引值可以是二维数据，当索引值为两个维度相同的一维数组组成的二维数组时，以两个维度作为横纵坐标索引出单值后组合成新的一维数组。
例2.8 花式索引示例。
程序文件Pex2_8.py
from numpy import array
x = array([[1,2],[3,4],[5,6]])
print("前两行元素为：\n", x[[0,1]]) #输出：[[1,2],[3,4]]
print("x[0][0]和x[1][1]为：", x[[0,1],[0,1]]) #输出：[1 4]
print("以下两种格式是一样的：")
print(x[[0,1]][:,[0,1]]) # 输出：[[1,2],[3,4]]，
print(x[0:2,0:2]) #同上，输出第1、2行，第1、2列的元素
1.4数组的修改
这里数组的修改是指数组元素的修改，和数组维数的扩大或缩小。
例2.9 数组修改示例。
程序文件Pex2_9.py
import numpy as np
x = np.array([[1,2],[3,4],[5,6]])
x[2,0] = -1 #修改第3行、第1列元素为-1
y=np.delete(x,2,axis=0) #删除数组的第3行
z=np.delete(y,0, axis=1) #删除数组的第1列
t1=np.append(x,[[7,8]],axis=0) #增加一行
t2=np.append(x,[[9],[10],[11]],axis=1) #增加一列
1.5数组的变形
在对数组进行操作时，经常要改变数组的维度。在NumPy中，常用reshape函数改变数据的形状，也就是改变数组的维度。其参数为一个正整数元组，分别指定数组在每个维度上的大小。reshape函数在改变原始数据的形状的同时不改变原始数据的值。如果指定的维度和数组的元素数目不吻合，则函数将抛出异常。
数组变形和转换的一些函数（方法也统称函数）如表2.2所列。
图片.png
例2.10 reshape和resize变形示例。
程序文件Pex2_10.py
import numpy as np
a=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]]
b=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]]
print(a.reshape(4,),'\n',a) #输出：[0 1 2 3]和[[0,1],[2,3]]
print(b.resize(4,),'\n',b) #输出：None和[0 1 2 3]
如上结果所示，虽然reshape和resize都是用来改变数组形状的，但是reshape只是返回改变形状后的视图，数组本身是不变的；而resize没有返回，直接改变数组本身的形状。
如果需要将多维数组降为一维数组，利用ravel、flatten和reshape三种方法均可以实现。
例2.11 数组降维示例。
程序文件Pex2_11.py
import numpy as np
a=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]]
b=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]]
c=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]]
print(a.reshape(-1),'\n',a) #输出：[0 1 2 3]和[[0,1],[2,3]]
print(b.ravel(),'\n',b) #输出：[0 1 2 3]和[[0,1],[2,3]]
print(c.flatten(),'\n',c) #输出：[0 1 2 3]和[[0,1],[2,3]]
从显示效果看，三种方法是一样的，原数组都没有修改。但我们在平时使用时，flatten()比较合适，在使用过程中flatten()分配了新的内存；ravel()返回的是一个数组的视图，e=b.ravel()是允许的。
例2.12 数组组合效果示例。
程序文件Pex2_12.py
import numpy as np
a=np.arange(4).reshape(2,2) #生成数组[[0,1],[2,3]]
b=np.arange(4,8).reshape(2,2) #生成数组[[4,5],[6,7]]
c1=np.vstack([a,b]) #垂直方向组合
c2=np.r_[a,b] #垂直方向组合
d1=np.hstack([a,b]) #水平方向组合
d2=np.c_[a,b] #水平方向组合
例2.13 数组分割示例。
程序文件Pex2_13.py
import numpy as np
a=np.arange(4).reshape(2,2) #构造2行2列的数组
b=np.hsplit(a,2) #把a平均分成2个列数组
c=np.vsplit(a,2) #把a平均分成2个行数组
print(b[0],'\n',b[1],'\n',c[0],'\n',c[1])
2数组的运算、通用函数和广播运算
2.1四则运算
在NumPy库中，实现四则运算既可以使用运算符号+、-、、/，也可以使用函数add、substract、multiply、divide。需要注意的是，函数只能接受两个对象的运算，如果需要多个对象的运算，就得使用嵌套方法。
另外还有三个数学运算符，分别是余数、整除和幂次，可以使用符号%、//、*，也可以使用函数fmod、modf和power。但是整除的函数应用会稍微复杂一点，需要写成np.modf(a/b)[1]的格式，因为modf可以返回数值的小数部分和整数部分，而整数部分就是要取的整数值。
例2.14 数组简单运算示例。
程序文件Pex2_14.py
import numpy as np
a=np.arange(10,15); b=np.arange(5,10)
c=a+b; d=a*b #对应元素相加和相乘
e1=np.modf(a/b)[0] #对应元素相除的小数部分
e2=np.modf(a/b)[1] #对应元素相除的整数部分
2.2比较运算
数组间的比较运算有表2.3所示的六种。
图片.png
运用比较运算符返回的是bool类型的值，即True和False。
例2.15 比较运算示例。
程序文件Pex2_15.py
import numpy as np
a=np.array([[3,4,9],[12,15,1]])
b=np.array([[2,6,3],[7,8,12]])
print(a[a>b]) #取出a大于b的所有元素，输出：[ 3 9 12 15]
print(a[a>10]) #取出a大于10的所有元素，输出：[12 15]
print(np.where(a>10,-1,a)) #a中大于10的元素改为-1
print(np.where(a>10,-1,0)) #a中大于10的元素改为-1，否则为0
最后一个print语句输出为：
[[ 0 0 0]
[-1 -1 0]]
通过上述运行结果可以看出，多维数组通过bool索引返回的都是一维数组；np.where返回的数组保持原来的形状。
2.3ufunc函数
3.ufunc函数
ufunc函数全称为通用函数，是一种能够对数组中的逐个元素进行操作的函数。ufunc函数是针对数组进行操作的，并且都以NumPy数组作为输出。使用ufunc函数比使用math库中的函数效率要高很多。目前NumPy支持超过60多种的通用函数。这些函数包括广泛的操作，如四则运算、求模、取绝对值、幂函数、指数函数、三角函数、位运算、比较运算和逻辑运算等。
例2.16 ufunc函数效率示例。
程序文件Pex2_16.py
import numpy as np, time, math
x=[i*0.01 for i in range(1000000)]
start=time.time() # 1970纪元后经过的浮点秒数
for (i,t) in enumerate(x): x[i]=math.sin(t)
print("math.sin:", time.time()-start)
y=np.array([i*0.01 for i in range(1000000)])
start=time.time()
y=np.sin(y)
print("numpy.sin:", time.time()-start)
运行结果：
math.sin: 0.3449997901916504
numpy.sin: 0.010999917984008789
可以发现对数组的操作，numpy函数整体花费时间比math模块函数要少得多。
2.4ufunc函数的广播机制
广播（Broadcasting）是指不同形状的数组之间执行算术运算的方式。当使用ufunc函数进行数组计算时，ufunc函数会对两个数组的对应元素进行计算。进行这种计算的前提是两个数组的维度相容。若两个数组的维度不相容时，则NumPy会实行广播机制。但是数组的广播功能是有规则的，如果不满足这些规则，运算时就会出错。数组的主要广播规则为：
（1）各输入数组的维度可以不相等，但必须确保从右到左的对应维度值相等。
（2）如果对应维度值不相等，就必须保证其中一个为1。
例2.17 广播机制示例。
程序文件Pex2_17.py
import numpy as np
a=np.arange(0, 20, 10).reshape(-1, 1) #变形为1列的数组，行数自动计算
b=np.arange(0, 3)
print(a+b)
运行结果：
[[ 0 1 2]
[10 11 12]]
3NumPy.random模块的随机数生成
虽然在Python内置的random模块中可以生成随机数，但是每次只能随机生成一个随机数，而且随机数的种类也不够丰富。建议使用NumPy.random模块的随机数生成函数，一方面可以生成随机向量，另一方面函数丰富。关于各种常见的随机数生成函数，如表2.4所列。
图片.png
图片.png
4文本文件和二进制文件存取
NumPy提供了多种文件操作函数以方便用户存取数组内容。文件存取的格式分为两类：二进制和文本。而二进制格式的文件又分为NumPy专用的格式化二进制类型和无格式类型。
4.1文本文件的存取
4.1.1savetxt()和loadtxt()存取文本文件
savetxt()可以把1维和2维数组保存到文本文件。loadtxt()可以把文本文件中的数据加载到1维和2维数组中。
例2.18 文本文件存取示例。
程序文件Pex2_18.py
import numpy as np
a=np.arange(0,3,0.5).reshape(2,3) #生成2×3的数组
np.savetxt("Pdata2_18_1.txt", a) #缺省按照'%.18e'格式保存数值，以空格分隔
b=np.loadtxt("Pdata2_18_1.txt") #返回浮点型数组
print("b=",b)
np.savetxt("Pdata2_18_2.txt", a, fmt="%d", delimiter=",") #保存为整型数据，以逗号分隔
c=np.loadtxt("Pdata2_18_2.txt",delimiter=",") #读入的时候也需要指定逗号分隔
print("c=",c)
运行结果：
b= [[0. 0.5 1. ]
[1.5 2. 2.5]]
c= [[0. 0. 1.]
[1. 2. 2.]]
例2.19 文本文件Pdata2_19.txt中存放如下格式的数据：
6 2 6 7 4 2 5 9
4 9 5 3 8 5 8 2
5 2 1 9 7 4 3 3
7 6 7 3 9 2 7 1
2 3 9 5 7 2 6 5
5 5 2 2 8 1 4 3
把其中的数据读入到数组a，并提取数组a的前2行、第2列到第4列的元素，构造一个2行3列的数组b。
程序文件Pex2_19.py
import numpy as np
a=np.loadtxt("Pdata2_19.txt") #返回值a为浮点型数据
b=a[0:2,1:4] #获取a的第1,2行，第2,3,4列
print("b=",b)
程序运行结果如下：
b= [[2. 6. 7.]
[9. 5. 3.]]
例2.20 文本文件Pdata2_20.txt中存放如下格式的数据：
姓名，年龄，体重，身高
张三，30，75，165
李四，45，60，179
王五，15，39，120
提取其中的数值数据。
程序文件Pex2_20.py
import numpy as np
a=np.loadtxt("Pdata2_20.txt",dtype=str,delimiter="，")
b=a[1:,1:].astype(float) #提取a矩阵的数值行和数值列，并转换类型
print("b=",b)
运行结果：
b= [[ 30. 75. 165.]
[ 45. 60. 179.]
[ 15. 39. 120.]]
如果需要处理复杂的数据结构，比如处理缺失数据等情况，可以使用genfromtxt。
4.1.2genfromtxt读入文本文件数据
它的调用格式为：
genfromtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=None, replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding='bytes')
我们介绍其中的一些常用参数：
（1）fname：指定需要读入数据的文件名。
（2）dtype：指定读入数据的数据类型，默认为浮点型，如果原数据集中含有字符型数据，必须指定数据类型为“str”。
（3）comments：指定注释符，默认为“#”，如果原数据的行首有“#”，将忽略这些行的读入。
（4）delimiter：指定数据集的列分隔符。
（5）skip_header：是否跳过数据集的首行，默认不跳过。
（6）skip_footer：是否跳过数据集的脚注，默认不跳过。
（7）converters：将指定列的数据转换成其他数值。
（8）miss_values：指定缺失值的标记，如果原数据集含指定的标记，读入后这样的数据就为缺失值。
（9）filling_values：指定缺失值的填充值。
（10）usecols：指定需要读入的列。
（11）names：为读入数据的列设置列名称
（12）encoding：如果文件中含有中文，有时需要指定字符编码。
例2.21 纯文本文件Pdata2_21.txt中存放如下数据。分别读取其中的前6行前8列数据、第9列的数值数据、最后一行数据。
6 2 6 7 4 2 5 9 60kg
4 9 5 3 8 5 8 2 55kg
5 2 1 9 7 4 3 3 51kg
7 6 7 3 9 2 7 1 43kg
2 3 9 5 7 2 6 5 41kg
5 5 2 2 8 1 4 -999 52kg
35 37 22 32 41 32 43 38
程序文件Pex2_21.py
import numpy as np
#读前6行前8列数据
a=np.genfromtxt("Pdata2_21.txt",max_rows=6, usecols=range(8))
b=np.genfromtxt("Pdata2_21.txt",dtype=str,max_rows=6,usecols=[8]) #读第9列数据
b=[float(v.rstrip('kg')) for (i,v) in enumerate(b)] #删除kg,并转换为浮点型数据
c=np.genfromtxt("Pdata2_21.txt",skip_header=6) #读最后一行数据
print(a,'\n',b,'\n',c)
4.2二进制格式文件存取
4.2.1tofile()和fromfile()存取二进制格式文件
使用数组对象的tofile()方法可以方便地将数组中的数据以二进制格式写进文件，tofile()输出的数据不保存数组形状和元素类型等信息。因此用fromfile()函数读回数据时需要用户指定元素类型，并对数组的形状进行适当的修改。
例2.22 tofile和fromfile存取二进制格式文件示例。
程序文件Pex2_22.py
import numpy as np
a=np.arange(6).reshape(2,3)
a.tofile('Pdata2_22.bin')
b=np.fromfile('Pdata2_22.bin',dtype=int).reshape(2,3)
print(b)
4.2.2load()、save()和savez()存取NumPy专用的二进制格式文件
load()和save()用NumPy专用的二进制格式存取数据，它们会自动处理元素类型和形状等信息。
如果想将多个数组保存到一个文件中，可以使用savez()。savez()的第一个参数是文件名，其后的参数都是需要保存的数组，输出的是一个扩展名为npz的压缩文件。
例2.23 存取NumPy专用的二进制格式文件示例。
程序文件Pex2_23.py
import numpy as np
a=np.arange(6).reshape(2,3)
np.save("Pdata2_23_1.npy",a)
b=np.load("Pdata2_23_1.npy")
c=np.arange(6,12).reshape(2,3)
d=np.sin(c)
np.savez("Pdata2_23_2.npz",c,d)
e=np.load("Pdata2_23_2.npz")
f1=e["arr_0"] #提取第一个数组的数据
f2=e["arr_1"] #提取第二个数组的数据
用解压软件打开“Pdata2_23_2.npz”文件，会发现其中有两个文件：“arr_0.npy”、“arr_1.npy”，其中分别保存着数组c、d的内容。load()自动识别npz文件，并且返回一个类似于字典的对象，可以通过数组名作为键获取数组的内容。
