Python 数据分析与科学计算 课件 第7章 Numpy数值计算

Python数据分析与科学计算第7章NumPy数值计算7.1数组对象7.2数组的基本操作7.3数组的索引和切片7.4数组运算7.5NumPy通用函数7.6线性代数运算7.7NumPy文件的读和写7.8NumPy数据分析案例7.1数组对象

NumPy提供了高性能数组与矩阵运算处理能力。（1）快速高效的多维数组对象ndarray。（2）用于对数组执行元素级计算以及直接对数组执行数学运算的函数。（3）用于读写硬盘上给予数组的数据集的工具。（4）线性代数运算、傅里叶变化以及随机数生成。（5）整合C、C++、Fortran等高级程序设计语言，提供简单易用的C语言API，使不同程序设计语言之间可以传递实验数据。1.数组创建通过array()函数创建数组array(object[,dtype=None,copy=True,order='K',subok=False,ndmin=0])【例7.1】一维列表作为array参数importnumpyasnpa_arr=np.array([1,2,3,4,5,6])print(a_arr)程序运行结果：[123456]7.1数组对象

1.数组创建【例7.2】数组作为array参数importnumpyasnpb_arr=np.array([[1,2,3],[4,5,6.0]])print(b_arr)程序运行结果：[[1.2.3.][4.5.6.]]7.1数组对象

【例7.3】元组作为array参数importnumpyasnpc_arr=np.array((1,2,3,4,5,6))print(c_arr)程序运行结果：[123456]1.数组创建【例7.4】字符串作为array参数>>>importnumpyasnp>>>d_arr=np.array('Python')>>>d_arrarray('Python',dtype='<U6')7.1数组对象

【例7.5】字典作为array参数>>>importnumpyasnp>>>e_arr=np.array({'Alice':95,'Beth':79,'Emily':95,'Tom':65.5})>>>e_arrarray({'Alice':95,'Beth':79,'Emily':95,'Tom':65.5},dtype=object)【例7.6】设置dtype参数importnumpyasnpf_arr=np.array([1.2,2.5,3,4.6,5.7,6.8],dtype='int')print(f_arr)程序运行结果：[123456]7.1数组对象

【例7.7】设置copy参数importnumpyasnpa_arr=np.array([1.2,2.5,3,4.6,5.7,6.8])b_arr=np.array(a_arr)print("id(a_arr):",id(a_arr),"id(b_arr):",id(b_arr))c_arr=np.array(a_arr,copy=False)print("id(a_arr):",id(a_arr),"id(c_arr):",id(c_arr))程序运行结果：id(a_arr):57851936id(b_arr):146995664

id(a_arr):57851936id(c_arr):578519361.数组创建【例7.8】设置subok参数importnumpyasnpa_arr=np.mat([1,2,3,4,5,6])print("a_arr:",type(a_arr))b_arr=np.array(a_arr)print("b_arr:",type(b_arr))c_arr=np.array(a_arr,subok=True)print("c_arr:",type(c_arr))print("id(a_arr):",id(a_arr))print("id(b_arr):",id(b_arr))print("id(c_arr):",id(c_arr))程序运行结果：a_arr:<class'numpy.matrix'>b_arr:<class'numpy.ndarray'>c_arr:<class'numpy.matrix'>id(a_arr):52725616id(b_arr):147724032id(c_arr):1476722407.1数组对象

1.数组创建【例7.9】设置ndmin参数importnumpyasnpa_arr=np.array([1,2,3,4,5,6])print(a_arr)b_arr=np.array([1,2,3,4,5,6],ndmin=2)#设置数组的维数为2print(b_arr)程序运行结果：[123456][[123456]]7.1数组对象

1.数组创建通过arange()函数创建等差数组【例7.10】使用arange()函数创建数组importnumpyasnpa_arr=np.arange(5)#只有一个参数，参数值为endprint("a_arr:",a_arr)b_arr=np.arange(1,5)#有两个参数，参数值为start和endprint("b_arr:",b_arr)c_arr=np.arange(1,10,2)#有三个参数，参数值为start、end和stepprint("c_arr:",c_arr)d_arr=np.arange(1,10,1.5)#有三个参数，步长为小数print("d_arr:",d_arr)程序运行结果：a_arr:[01234]b_arr:[1234]c_arr:[13579]d_arr:[1.2.54.5.57.8.5]7.1数组对象

np.arange([start,]end,[step,]dtype=None)1.数组创建通过zeros()函数创建元素值都是0的数组7.1数组对象

【例7.11】使用zeros()函数创建数组importnumpyasnpa_arr=np.zeros(5)#创建一维全0数组print("a_arr:\n",a_arr)b_arr=np.zeros((2,4))#创建二维全0数组print("b_arr:\n",b_arr)c_arr=np.zeros((2,4,3),int)#创建三维全0数组print("c_arr:\n",c_arr)程序运行结果：a_arr:[0.0.0.0.0.]b_arr:[[0.0.0.0.][0.0.0.0.]]c_arr:[[[000][000][000][000]]

[[000][000][000][000]]]np.zeros(shape[,dtype=float,order='C'])1.数组创建通过ones()函数创建元素值都是1的数组7.1数组对象

【例7.12】使用ones()函数创建数组importnumpyasnpa_arr=np.ones(3,complex)#创建一维全1数组，指定数据类型为complexprint("a_arr:\n",a_arr)b_arr=np.ones((2,4))#创建二维全1数组print("b_arr:\n",b_arr)程序运行结果：a_arr:[1.+0.j1.+0.j1.+0.j]b_arr:[[1.1.1.1.][1.1.1.1.]]np.ones(shape[,dtype=float,order='C'])1.数组创建通过empty()函数创建数组7.1数组对象

【例7.13】使用empty()函数创建数组importnumpyasnpa_arr=np.empty(3)print("a_arr:\n",a_arr)b_arr=np.empty((2,4),int)print("b_arr:\n",b_arr)程序运行结果：a_arr:[2.11392372e-3071.60216183e-3067.56602523e-307]b_arr:[[2128575739130950003016614241761988385690][13247706951229000]]np.empty(shape[,dtype=float,order='C'])1.数组创建通过linspace()函数创建数组7.1数组对象

【例7.14】使用linspace()函数创建数组importnumpyasnpa_arr=np.linspace(1,20)print("a_arr:\n",a_arr)b_arr=np.linspace(1,20,num=5,endpoint=False,retstep=True)print("b_arr:\n",b_arr)np.linspace(start,end,num=50,endpoint=True,retstep=False,dtype=None)1.数组创建7.1数组对象

【例7.14】使用linspace()函数创建数组程序运行结果：a_arr:[1.1.38775511.77551022.163265312.551020412.938775513.326530613.714285714.102040824.489795924.877551025.265306125.653061226.040816336.428571436.816326537.204081637.591836737.979591848.367346948.755102049.142857149.530612249.9183673510.3061224510.6938775511.0816326511.4693877611.8571428612.2448979612.6326530613.0204081613.4081632713.7959183714.1836734714.5714285714.9591836715.3469387815.7346938816.1224489816.5102040816.8979591817.2857142917.6734693918.0612244918.4489795918.8367346919.224489819.612244920.]b_arr:(array([1.,4.8,8.6,12.4,16.2]),3.8)1.数组创建通过logspace()函数创建数组7.1数组对象

【例7.15】使用logspace()函数创建数组importnumpyasnpa_arr=np.logspace(10,100,10)print("a_arr:\n",a_arr)b_arr=np.logspace(2,4,3,base=2)print("b_arr:\n",b_arr)程序运行结果：a_arr:[1.e+0101.e+0201.e+0301.e+0401.e+0501.e+0601.e+0701.e+0801.e+0901.e+100]b_arr:[4.8.16.]np.linspace(start,end,num=50,endpoint=True,base=10.0,dtype=None)1.数组创建创建随机数数组7.1数组对象

函数说明rand()产生均匀分布的样本值randint()从指定的整数范围内随机抽取整数randn()从标准正态分布中随机抽取样本random()从指定的整数范围内随机抽取整数seed()随机数种子permutation()对一个序列随机排序，不改变原数组shuffle()对一个序列随机排序，改变原数组uniform(low,high,size)创建从一个均匀分布[low,high)中随机采样，采样个数为size的数组normal(loc,scale,size)创建一个以loc为均值，以scale为标准差，形状为size的数组possion(lam,size)创建一个具有泊松分布的数组，lam表示随机事件发生概率，形状为size1.数组创建random()函数7.1数组对象

【例7.16】使用random()函数创建数组或产生随机数importnumpyasnpa_arr=np.random.random()print("a_arr:\n",a_arr)b_arr=np.random.random((2,3))print("b_arr:\n",b_arr)程序运行结果：a_arr:0.9416316333371949b_arr:[[0.338775940.954012940.77139567][0.031949310.101989050.37465295]]np.random.random((d0,d1,...,dn))1.数组创建rand()函数7.1数组对象

【例7.17】使用rand()函数创建数组或产生随机数importnumpyasnpa_arr=np.random.rand()print("a_arr:\n",a_arr)b_arr=np.random.rand(2,3)print("b_arr:\n",b_arr)程序运行结果：a_arr:0.7594280446678919b_arr:[[0.684736120.525523120.22994573][0.018081280.995600310.71410923]]np.random.rand(d0,d1,...,dn)1.数组创建randn()函数7.1数组对象

【例7.18】使用randn()函数创建数组或产生随机数importnumpyasnpa_arr=np.random.randn()print("a_arr:\n",a_arr)b_arr=np.random.randn(2,3print("b_arr:\n",b_arr)程序运行结果：a_arr:-0.23138551702438248b_arr:[[-0.03878431-0.026674050.14489851][1.81674187-1.1985719-1.67512633]]np.random.randn(d0,d1,...,dn)1.数组创建randint()函数7.1数组对象

【例7.19】使用randint()函数创建数组importnumpyasnpa_arr=np.random.randint(100)print("a_arr:\n",a_arr)b_arr=np.random.randint(1,10,size=(2,5))print("b_arr:\n",b_arr)程序运行结果：a_arr:29b_arr:[[87734][31258]]np.random.randint(low,high=None,size=None,dtype='l')1.数组创建uniform()函数7.1数组对象

【例7.20】使用uniform()函数创建数组importnumpyasnpa_arr=np.random.uniform(size=5)print("a_arr:\n",a_arr)b_arr=np.random.uniform(1,10,size=(2,5))print("b_arr:\n",b_arr)程序运行结果：a_arr:[0.924967820.666079120.663832240.675553980.40459855]b_arr:[[9.061491623.198780861.787838514.875511929.2173324][2.292023164.367488373.896152684.770648892.99041214]]np.random.uniform(low,high,size)1.数组创建normal()函数7.1数组对象

【例7.21】使用normal()函数创建数组importnumpyasnpa_arr=np.random.normal()print("a_arr:\n",a_arr)b_arr=np.random.normal(size=(2,5))print("b_arr:\n",b_arr)程序运行结果：0.9279352525549017b_arr:[[0.975250771.60686154-0.29005658-2.178073010.71971385][-0.330177921.89823936-0.72117832-0.260490940.76149852]]np.random.normal(loc,scale,size)7.1数组对象

属性说明ndim数组轴的个数shape数组的维度size数组元素个数dtype数组中元素的数据类型itemsize数组中每个元素的字节大小ndarray对象常用属性2.数组属性7.1数组对象

【例7.22】查看数组的属性importnumpyasnpa_arr=np.array([[1,2,3],[4,5,6.0]])print("a_arr:\n",a_arr)print("数组轴的个数：",a_arr.ndim)print("数组的维度：",a_arr.shape)print("数组元素个数：",a_arr.size)print("数组元素类型：",a_arr.dtype)print("数组元素字节大小：",a_arr.itemsize)a_arr:

[[1.2.3.][4.5.6.]]数组轴的个数：2数组的维度：(2,3)数组元素个数：6数组元素类型：float64数组元素字节大小：8程序运行结果：2.数组属性7.1数组对象

Numpy提供了可用于多维数组的丰富的数据类型数据类型描述int8、uint8有符号和无符号的8位整数int16、uint16有符号和无符号的16位整数int32、uint32有符号和无符号的32位整数int64、uint64有符号和无符号的64位整数float16半精度浮点数，float32单精度浮点数float64双精度浮点数float128扩展精度浮点数complex64复数，分别用两个32位浮点数表示实部和虚部complex128复数，分别用两个64位浮点数表示实部和虚部complex256复数，分别用两个128位浮点数表示实部和虚部bool布尔型，取值为True和FalseobjectPython对象string固定长度的字符串类型unicode固定长度的unicode类型3.数组元素的类型7.1数组对象

>>>importnumpyasnp>>>a_arr=np.array([1,2,3,4,5,6])>>>a_arr.dtypedtype('int32')数组元素的类型可以通过dtype查看。数组元素的类型也可以通过astype()方法进行转换。例如，将以上示例中a_arr数组的类型转换成float64，并赋给b_arr数组，代码如下：>>>b_arr=a_arr.astype(np.float64)>>>b_arrarray([1.,2.,3.,4.,5.,6.])>>>b_arr.dtypedtype('float64')3.数组元素的类型7.2数组的基本操作

数组重塑常用函数函数说明reshape()不改变原数组的数据重塑数组形状flatten()将多维数组转换为一维数组reval()将多维数组转换为一维数组transpos()反转或排列数组的轴resize()调整数组的大小1.数组重塑7.2数组的基本操作

reshape()函数np.reshape(array,newshape,order=’C’)【例7.23】使用reshape()函数重塑数组形状importnumpyasnp

a_arr=np.arange(12)print('a_arr数组为：',a_arr)b_arr=a_arr.reshape(3,4)print('b_arr数组为：\n',b_arr)print('a_arr数组维度为：',a_arr.ndim)print('b_arr数组维度为：',b_arr.ndim)a_arr数组为：[01234567891011]b_arr数组为：[[0123][4567][891011]]a_arr数组维度为：1b_arr数组维度为：2程序运行结果：1.数组重塑7.2数组的基本操作

flatten()函数ndarray.flatten(order)【例7.24】使用flatten()函数重塑数组形状importnumpyasnp

a_arr=np.array([[1,2,3],[4,5,6]])print('a_arr数组为：\n',a_arr)#重塑a_arr数组的形状,order为默认值'C',即横向展平b_arr=a_arr.flatten()print('b_arr数组为：\n',b_arr)#重塑a_arr数组的形状,order为'F',即纵向展平c_arr=a_arr.flatten('F')print('c_arr数组为：\n',c_arr)c_arr[0]=100print('a_arr数组为：\n',a_arr)a_arr数组为：[[123][456]]b_arr数组为：[123456]c_arr数组为：[142536]a_arr数组为：[[123][456]]程序运行结果：1.数组重塑7.2数组的基本操作

reval()函数np.reval(array,order)【例7.25】使用reval()函数重塑数组形状importnumpyasnp

a_arr=np.array([[1,2,3],[4,5,6]])print('a_arr数组为：\n',a_arr)b_arr=np.ravel(a_arr)print('b_arr数组为：\n',b_arr)b_arr[0]=100print('a_arr数组为：\n',a_arr)a_arr数组为：

[[123][456]]b_arr数组为：[123456]a_arr数组为：[[10023][456]]程序运行结果：1.数组重塑7.2数组的基本操作

concatenate()函数np.concatenate((array1,array2,…),axis)【例7.26】使用concatenate()函数合并数组importnumpyasnp

a_arr=np.array([[1,2,3],[4,5,6]])#创建二维数组print('a_arr数组为：\n',a_arr)b_arr=np.array([[7,8,9],[10,11,12]])#创建二维数组

print('b_arr数组为：\n',b_arr)c_arr=np.concatenate((a_arr,b_arr))#沿轴0连接数组d_arr=np.concatenate((a_arr,b_arr),1)#沿轴1连接数组print("沿轴0连接两个数组：\n",c_arr)print("沿轴1连接两个数组：\n",d_arr)a_arr数组为：[[123][456]]b_arr数组为：[[789][101112]]沿轴0连接两个数组：[[123][456][789][101112]]沿轴1连接两个数组：[[123789][456101112]]程序运行结果：2.数组合并7.2数组的基本操作

stack()函数np.stack((array1,array2,…),axis)【例7.27】使用stack()函数合并数组importnumpyasnp

a_arr=np.array([[1,2,3],[4,5,6]])#创建二维数组print('a_arr数组为：\n',a_arr)b_arr=np.array([[7,8,9],[10,11,12]])#创建二维数组

print('b_arr数组为：\n',b_arr)c_arr=np.stack((a_arr,b_arr))#沿轴0连接数组d_arr=np.stack((a_arr,b_arr),1)#沿轴1连接数组print("沿轴0连接两个数组：\n",c_arr)print("沿轴1连接两个数组：\n",d_arr)a_arr数组为：[[123][456]]b_arr数组为：[[789][101112]]沿轴0连接两个数组：[[[123][456]][[789][101112]]]沿轴1连接两个数组：[[[123][789]][[456][101112]]]程序运行结果：2.数组合并7.2数组的基本操作

hstack()、vstack()函数是stack()函数的变体，通过垂直堆叠来生成数组【例7.28】使用hstack()和vstack函数合并数组importnumpyasnp

a_arr=np.array([[1,2,3],[4,5,6]])#创建二维数组print('a_arr数组为：\n',a_arr)b_arr=np.array([[7,8,9],[10,11,12]])#创建二维数组

print('b_arr数组为：\n',b_arr)c_arr=np.hstack((a_arr,b_arr))#水平合并d_arr=np.vstack((a_arr,b_arr))#垂直合并print("水平合并：\n",c_arr)print("垂直合并：\n",d_arr)a_arr数组为：[[123][456]]b_arr数组为：[[789][101112]]水平合并：[[123789][456101112]]垂直合并：[[123][456][789][101112]]程序运行结果hstack()、vstack()函数2.数组合并7.2数组的基本操作

np.split(ary,indices_or_sections,axis)split()函数hsplit()函数np.hsplit(ary,indices_or_sections)3.数组分割7.2数组的基本操作

【例7.29】使用hsplit()和vsplit()函数分割数组importnumpyasnp

a_arr=np.array([[1,2,3,4,5,6],[7,8,9,10,11,12]])print('a_arr数组为：\n',a_arr)#分割数组，参数axis为默认值0，表示横向切分b_arr=np.split(a_arr,2)c_arr=np.hsplit(a_arr,3)#水平分割数组d_arr=np.vsplit(a_arr,2)#垂直分割数组print("使用split函数分割：\n",b_arr)print("水平分割：\n",c_arr)print("垂直分割：\n",d_arr)a_arr数组为：[[123456][789101112]]使用split函数分割：[array([[1,2,3,4,5,6]]),array([[7,8,9,10,11,12]])]水平分割：[array([[1,2],[7,8]]),array([[3,4],[9,10]]),array([[5,6],[11,12]])]垂直分割：[array([[1,2,3,4,5,6]]),array([[7,8,9,10,11,12]])]程序运行结果：vsplit()函数np.hsplit(ary,indices_or_sections)3.数组分割7.2数组的基本操作

【例7.30】使用T属性对数组进行转置importnumpyasnp

a_arr=np.arange(12).reshape(3,4)print('a_arr数组为：\n',a_arr)b_arr=a_arr.T#使用T属性对a_arr数组进行转置print('转置后的数组为：\n',format(b_arr))a_arr数组为：[[0123]

[4567][891011]]转置后的数组为：[[048][159][2610][3711]]程序运行结果：T属性4.数组转置7.2数组的基本操作

【例7.31】使用transpose函数转置数组importnumpyasnp

a_arr=np.arange(12).reshape(3,4)print('a_arr数组为：\n',a_arr)b_arr=numpy.transpose(a_arr)print('转置后的数组为：\n',format(b_arr))a_arr数组为：[[0123]

[4567][891011]]转置后的数组为：[[048][159][2610][3711]]程序运行结果：transpose()函数numpy.transpose(arr,axes)4.数组转置7.2数组的基本操作

【例7.32】使用transpose函数转置数组importnumpyasnp

a_arr=np.arange(12).reshape(2,2,3)print('a_arr数组为：\n',a_arr)b_arr=numpy.transpose(a_arr,(1,2,0))print('转置后的数组为：\n',b_arr)a_arr数组为：[[[012][345]]

[[678][91011]]]转置后的数组为：[[[06][17][28]]

[[39][410][511]]]程序运行结果对于高维度的数组，transpose函数需要得到一个由轴编号组成的元组，才能对这些轴进行转置4.数组转置7.2数组的基本操作

【例7.33】使用swapaxes函数转置数组importnumpyasnpa_arr=np.arange(12).reshape(2,2,3)print('a_arr数组为：\n',a_arr)#使用swapaxes函数交换a_arr数组的轴0到轴1b_arr=numpy.swapaxes(a_arr,1,0)print('转置后的数组为：\n',b_arr)a_arr数组为：[[[012][345]]

[[678][91011]]]转置后的数组为：

[[[012][678]]

[[345][91011]]]swapaxes()np.swapaxes(arr,axis1,axis2)4.数组转置程序运行结果：7.3数组的索引和切片

【例7.34】一维数组的索引和切片importnumpyasnp

a_arr=np.arange(0,10)print('a_arr数组为：\n',a_arr)print("a_arr[0]:",a_arr[0])print("a_arr[-1]:",a_arr[-1])print("a_arr[::]:",a_arr[::])print("a_arr[1::]:",a_arr[1::])print("a_arr[0:9:3]:",a_arr[0:9:3print("a_arr[9:1:-2]:",a_arr[9:1:-2])a_arr数组为：[0123456789]a_arr[0]:0a_arr[-1]:9a_arr[::]:[0123456789]a_arr[1::]:[123456789]a_arr[0:9:3]:[036]a_arr[9:1:-2]:[9753]程序运行结果：1.一维数组的索引和切片7.3数组的索引和切片

【例7.35】二维数组的索引importnumpyasnp

a_arr=np.array([[1,2,3],[4,5,6],[7,8,9]])print('a_arr数组为：\n',a_arr)print("a_arr[0]:",a_arr[0])a_arr数组为：[[123][456][789]]a_arr[0]:[123]在二维数组中，每个索引位置上的元素不再是一个标量，而是一个一维数组程序运行结果：2.多维数组的索引和切片7.3数组的索引和切片

【例7.36】二维数组的切片importnumpyasnp

a_arr=np.array([[1,2,3],[4,5,6],[7,8,9]])print('a_arr数组为：\n',a_arr)print("a_arr[:2]切片\n",a_arr[:2])print("a_arr[:2,:2]切片\n",a_arr[:2,:2])print("a_arr[1,1:2]切片\n",a_arr[1,1:2])a_arr数组为：[[123][456][789]]a_arr[:2]切片[[123][456]]a_arr[:2,:2切片

[[12][45]]a_arr[1,1:2]切片[5]程序运行结果：2.多维数组的索引和切片7.3数组的索引和切片

花式索引是指将整数数组或列表作为索引，根据数组或列表的每个元素作为目标数组的下标进行取值。当使用一维数组或列表作为索引时，如果使用索引要操作的对象是一维数组，则获取的结果是对应下标的元素，如果使用索引要操作的目标对象是二维数组，则索引结果是对应下标的一行数据。如果用两个花式索引操作数组，则会将第1个作为行索引，第2个作为列索引，以二维数组索引的方式选取其对应位置的元素3.花式索引7.3数组的索引和切片

【例7.37】花式索引importnumpyasnp

a_arr=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])print('a_arr数组为：\n',a_arr)print("a_arr[1,2]花式索引：\n",a_arr[[1,2]])print("a_arr[[1,2],[1,2]]花式索引：\n",a_arr[[1,2],[1,2]])a_arr数组为：[[1234][5678][9101112]]a_arr[1,2]花式索引：[[5678][9101112]]a_arr[[1,2],[1,2]]花式索引：[611]程序运行结果：3.花式索引7.3数组的索引和切片

importnumpy

name=numpy.array(['小张','小王','小李','小赵','小李'])print('name数组为：\n',name)score=numpy.random.randint(0,100,size=(5,3))print('score数组为：\n',score)#使用布尔数组应用到score数组中print('name为小李对应的分数为：\n’,score[name=='小李'])name数组为：

['小张''小王''小李''小赵''小李']score数组为：[[82647][133515][836287][864099][656469]]姓名为小李对应的分数为：[[836287][656469]]程序运行结果：【例7.38】布尔型索引4.布尔型索引7.4数组运算

importnumpy

a_arr=numpy.array([[1,2,3],[4,5,6]])b_arr=numpy.array([[7,8,9],[10,11,12]])print('a_arr数组为：\n',a_arr)print('b_arr数组为：\n',b_arr)c_arr=a_arr+b_arrprint('a_arr+b_arr得到的c_arr数组为：\n',c_arr)

a_arr数组为：[[123][456]]b_arr数组为：[[789][101112]]a_arr+b_arr得到的c_arr数组为：[[81012][141618]]程序运行结果：【例7.39】矢量化运算1.矢量化运算7.4数组运算

importnumpy

a_arr=numpy.array([[1],[2]])b_arr=numpy.array([1,2,3])print('a_arr数组为：\n',a_arr)print('b_arr数组为：\n',b_arr)print('a_arr*b_arr：\n',a_arr*b_arr)

a_arr数组为：[[1][2]]b_arr数组为：[123]a_arr*b_arr：[[123][246]]程序运行结果：【例7.40】数组广播2.数组广播7.4数组运算

importnumpy

a_arr=numpy.array([[1,2,3],[4,5,6]])x=10print('a_arr数组为：\n',a_arr)print('x=%d'%x)b_arr=a_arr+xprint('a_arr+x得到的b_arr数组为：\n',b_arr)

a_arr数组为：[[123][456]]x=10a_arr+x得到的b_arr数组为：[[111213][141516]]【例7.41】数组与标量间的运算程序运行结果：3.数组和标量间的运算函数描述abs、fabs计算整数、浮点数或复数的绝对值sqrt计算各元素的平方根square计算各元素的平方exp计算各元素的指数exlog计算自然对数（底数为e）log10计算底数为10的对数log2计算底数为2的对数log1p计算log(1+x)的对数sign计算各元素的正负号：1为正数、0为0、-1为负数ceil计算各元素的ceiling值，即大于等于该值的最小整数floor计算各元素的floor值，即小于等于该值的最大整数7.5Numpy通用函数——常见的一元通用函数

7.5Numpy通用函数——常见的一元通用函数

函数描述around将各元素浮点数取整到最近的整数，但不改变浮点数类型rint将各元素浮点数取整到最近的整数，但不改变浮点数类型modf将数组的小数和整数部分以两个独立数组的形式返回isnan返回一个表示“哪些值是NaN（不是一个数）”的布尔型数组isfinite返回表示“哪些元素是有穷的”的布尔型数组，即判断元素是否是有限的数isinf返回表示“哪些元素是无穷的”的布尔型数组，即判断元素是否无限大sin、sinh、coscosh、tan、tanh三角函数arcos、arccosh、arcsinarcsinh、arctan、arctanh反三角函数7.5Numpy通用函数——常见的二元通用函数

函数描述add数组中对应的元素相加subtract数组中对应的元素相减dot叉积，数组和矩阵对应位置相乘multiply点积，矩阵对应元素相乘，要求矩阵维度相同*点积，数组对应元素相乘，必要时使用广播规则divide数组中对应的元素相除flooor_divide数组中对应的元素向下整除（舍去余数）maximum数组对应元素比较取其大者，返回一个数组minimum数组对应元素比较取其小者，返回一个数组mod元素级的求模计算copysign将第二个数组中的值的符号赋值给第一个数组的对应元素函数描述greater数组对应元素进行比较运算，返回布尔型数组，相当于运算符>greater_equal数组对应元素进行比较运算，返回布尔型数组，相当于运算符≥less数组对应元素进行比较运算，返回布尔型数组，相当于运算符<less_equal数组对应元素进行比较运算，返回布尔型数组，相当于运算符≤equal数组对应元素进行比较运算，返回布尔型数组，相当于运算符==not_equal数组对应元素进行比较运算，返回布尔型数组，相当于运算符!=logical_and数组对应元素进行逻辑与运算，得到布尔型数组logical_or数组对应元素进行逻辑或运算，得到布尔型数组logical_xor数组对应元素进行逻辑异或运算，得到布尔型数组7.5Numpy通用函数——常见的二元通用函数

7.5Numpy通用函数

importnumpyasnp

a_arr=np.array([1,4,9,16])b_arr=np.sqrt(a_arr)c_arr=np.square(a_arr)print('原数组：',a_arr)print('求平方根：',b_arr)print('求平方：',c_arr)原数组：[14916]求平方根：[1.2.3.4.]求平方：[11681256]【例7.42】求平方根、平方函数的应用程序运行结果：7.5Numpy通用函数

importnumpyasnpa_arr=np.array([-0.3,-1.6,1,1.8,2.1])b_arr=np.ceil(a_arr)c_arr=np.floor(a_arr)print('原数组：',a_arr)print('ceil后的数组：',b_arr)print('floor后的数组：',c_arr)原数组：[-0.3-1.61.1.82.1]ceil后的数组：[-0.-1.1.2.3.]floor后的数组：[-1.-2.1.1.2.]程序运行结果：【例7.43】ceil、floor函数的应用7.5Numpy通用函数

importnumpyasnp

a_arr=np.array([0,30,45,60,90])b_arr=a_arr*np.pi/180#将数组元素中的角度转换为弧度print('正弦值：',np.sin(b_arr))print('余弦值：',np.cos(b_arr))print('正切值：',np.tan(b_arr))c_arr=np.arcsin(np.sin(b_arr))#先求正弦后再求反正弦print('先正弦再反正弦',c_arr*180/np.pi)#将弧度转换为角度正弦值：[0.0.50.707106780.86602541.]余弦值：[1.00000000e+008.66025404e-017.07106781e-015.00000000e-016.12323400e-17]正切值：[0.00000000e+005.77350269e-011.00000000e+001.73205081e+001.63312394e+16]先正弦再反正弦[0.30.45.60.90.]程序运行结果：【例7.44】三角函数、反三角函数的应用7.5Numpy通用函数

importnumpyasnp

a_arr=np.array([1,2,3,4,5])b_arr=np.array([6,7,8,9,10])print('相加：',np.add(a_arr,b_arr))print('相减：',np.subtract(a_arr,b_arr))print('相乘：',np.multiply(a_arr,b_arr))print('相除：',np.divide(a_arr,b_arr))相加：[79111315]相减：[-5-5-5-5-5]相乘：[614243650]相除：[0.166666670.285714290.3750.444444440.5]程序运行结果：【例7.45】add、subtract、multiply和divide函数的应用7.6线性代数运算

linalg模块中的常用函数函数描述dot计算两个数组的点积，即对应元素相乘vdot计算两个向量的点积det计算矩阵行列式solve求解线性矩阵方程inv计算矩阵的乘法逆矩阵eig计算方阵的特征值和特征向量7.6线性代数运算

1.数组相乘>>>a_arr=np.array([[1,2,3],[4,5,6]])>>>b_arr=np.array([[1,2],[3,4],[5,6]])>>>c_arr=np.dot(a_arr,b_arr)>>>print(c_arr)[[2228][4964]]dot()函数numpy.dot(a,b,out=None)7.6线性代数运算

1.数组相乘>>>a_arr=np.array([[1,2,3],[4,5,6]])>>>b_arr=np.array([[1,2],[3,4],[5,6]])>>>c_arr=np.vdot(a_arr,b_arr)>>>print(c_arr)91vdot()函数vdot()函数计算两个数组的点积7.6线性代数运算

2.矩阵行列式a_arr=np.array([[1,2],[3,4]])

print('a_arr数组：\n',a_arr)print('a_arr数组的行列式：',np.linalg.det(a_arr))b_arr=np.array([[1,2,3],[4,-5,6],[7,8,9]])print('b_arr数组：\n',b_arr)print('b_arr数组的行列式：',np.linalg.det(b_arr))a_arr=np.array([[1,2],[3,4]])det()【例7.46】求矩阵行列式程序运行结果：a_arr数组：[[12][34]]a_arr数组的行列式：-2.0000000000000004b_arr数组：

[[123][4-56][789]]b_arr数组的行列式：119.999999999999977.6线性代数运算

3.线性方程组importnumpyasnp

A=np.array([[1,1,1],[5,0,-1],[2,-3,-1]])b=np.array([9,6,-9])x=np.linalg.solve(A,b)print('线性方程组的解为：',x)solve()函数【例7.47】求解线性方程组程序运行结果：线性方程组的解为：[2.3.4.]

7.6线性代数运算

4.逆矩阵importnumpyasnp

A=np.array([[1,2,3],[1,0,-1],[0,1,1]])print('A矩阵：\n',A)B=np.linalg.inv(A)print('A矩阵的逆矩阵：\n',B)print('A、B矩阵相乘结果为：\n',np.dot(A,B))inv()函数【例7.48】求矩阵的逆矩阵程序运行结果：A矩阵：[[123][10-1][011]]A矩阵的逆矩阵：[[0.50.5-1.][-0.50.52.][0.5-0.5-1.]]A、B矩阵相乘结果为：[[1.0.0.][0.1.0.][0.0.1.]]7.6线性代数运算

5.特征值和特征向量importnumpyasnp

A=np.array([[-1,1,0],[-4,3,0],[1,0,2]])prin