下载掌阅APP，畅读海量书库
立即打开
Num Py数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为1，二维数组的秩为2，以此类推。
在NumPy中，每一个线性的数组称为一个轴（axis），也就是维度（dimensions）。例如，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是NumPy中的轴，第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。
很多时候可以声明axis。axis=0，表示沿着第0轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。
下面直接通过两个例子来演示NumPy数组的属性。
【例2-3】 利用reshape函数来调整数组大小。
运行程序，输出如下：
[[1 2]
[3 4]
[5 6]]
【例2-4】 使用ndarray.ndim返回数组的维数。
运行程序，输出如下：
1
3
ndarray数组除了可以使用底层ndarray构造器来创建外，也可以通过以下几种方式来创建。
numpy.empty()方式用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组，初始方式为：
numpy.empty（shape，dtype=float，order='C'）：shape为数组形状；dtype为数据类型，可选；order有“C”和“F”两个选项，分别代表行优先和列优先（在计算机内存中存储元素的顺序）。
【例2-5】 创建一个空数组。
import numpy as np
x=np.empty([3,2],dtype=int)
print(x)
运行程序，输出如下：
[[1 2]
[3 4]
[5 6]]
numpy.zeros()方式创建指定大小的数组，数组元素以0来填充，初始方式为：
numpy.zeros（shape，dtype=float，order='C'）：参数shape为数组形状；dtype为数据类型，可选；order有“C”和“F”两个选项，“C”用于C的行数组，“F”用于FORTRAN的列数组。
【例2-6】 利用numpy.zeros()方式创建数组。
运行程序，输出如下：
[0.0.0.0.0.]
[0 0 0 0 0]
[[(0,0)(0,0)]
[(0,0)(0,0)]]
numpy.ones()方式用于创建指定形状的数组，数组元素以1来填充，初始方式为：
numpy.ones（shape，dtype=None，order='C'）：参数shape为数组形状；dtype为数据类型，可选；order有“C”和“F”两个选项，“C”用于C的行数组，“F”用于FORTRAN的列数组。
【例2-7】 利用numpy.ones()方式创建数组。
import numpy as np
#默认为浮点数
x=np.ones(5)
print(x)
#自定义类型
x=np.ones([2,2],dtype=int)
print(x)
运行程序，输出如下：
[1.1.1.1.1.]
[[1 1]
[1 1]]
numpy.asarray()类似numpy.array()，但numpy.asarray()的参数只有三个，比numpy.array()少两个。numpy.asarray()初始化为：
numpy.asarray（a，dtype=None，order=None）：参数a为任意形式的输入参数，可以是列表、列表的元组、元组、元组的元组、元组的列表、多维数组；dtype为数据类型，可选；order可选，有“C”和“F”两个选项，分别代表行优先和列优先（在计算机内存中存储元素的顺序）。
【例2-8】 将元组列表转换为ndarray。
import numpy as np
x= [(1,4,3),(6,9)]
a=np.asarray(x)
print(a)
运行程序，输出如下：
[(1,4,3)(6,9)]
Num Py包中使用arange()函数创建数值范围并返回ndarray对象，函数格式如下：
numpy.arange（start，stop，step，dtype）：根据start与stop指定的范围以及step设定的步长，生成一个ndarray。
【例2-9】 生成0到5的数组。
import numpy as np
x=np.arange(5)
print(x)
运行程序，输出如下：
[0 1 2 3 4]
此外，利用numpy.linspace()函数创建一个一维数组，数组是一个等差数列构成的，格式如下：
np.linspace（start，stop，num=50，endpoint=True，retstep=False，dtype=None）：start为序列的起始值；stop为序列的终止值，当endpoint=True时，数列中包含stop值，反之不包含，数列默认包含stop值；num为要生成的等步长的样本数量，默认为50；retstep如果为True，生成的数组中会显示间距，反之不显示。dtype为ndarray的数据类型。
numpy.logspace()函数用于创建一个等比数列。格式如下：
np.logspace（start，stop，num=50，endpoint=True，base=10.0，dtype=None）：star为序列的起始值；stop为序列的终止值；如果endpoint=True，数列中包含stop值，反之不包含，数列默认包含stop值；num为要生成的等步长的样本数量，默认为50；base是对数的底数；dtype为ndarray的数据类型。
【例2-10】 利用函数分别创建一个等比数列和一个等差数列。
运行程序，输出如下：
等差数列:
[1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
等比数列:
[10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
ndarray对象的内容可以通过索引或切片来访问和修改，与Python中list的切片操作一样。
ndarray数组可以基于0~n的下标进行索引，切片对象可以通过内置的slice()函数设置，并设置start、stop及step参数从原数组中切割出一个新数组。
【例2-11】 利用slice()函数分割新数组。
运行程序，输出如下：
[2 4 6]
在例2-11中，首先通过arange()函数创建ndarray对象。然后分别设置起始、终止和步长的参数为2，7和2。
也可以通过冒号分隔切片参数start：stop：step来进行切片操作，例如：
import numpy as np
a=np.arange(10)
b=a[2:8:2] #从索引2开始到索引8停止，间隔为2
print(b)
运行程序，输出如下：
[2 4 6]
其中，如果切片参数中只放置一个参数，如[2]，将返回与该索引相对应的单个元素。如果为[2：]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如[2：7]，那么则提取两个索引（不包括停止索引）之间的项。例如：
运行程序，输出如下：
6
切片还可以包括省略号（…），用于使选择元组的长度与数组的维度相同。如果在行位置使用省略号，它将返回包含行中元素的ndarray，例如：
运行程序，输出如下：
[4 5 6]
[2 5 8]
[[4 7]
[5 8]
[6 9]]
NumPy比一般的Python序列提供更多的索引方式。除了之前讲到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。
【例2-12】 获取4×3数组中四个角的元素。行索引是[0，0]和[3，3]，而列索引是[0，2]和[0，2]。
运行程序，输出如下：
数组是:
[[0 1 2]
[3 4 5]
[6 7 8]
[9 10 11]]
这个数组四个角的元素是:
[[0 2]
[9 11]]
返回的结果是包含每个角元素的ndarray对象。此外还可以借助切片“：”或“...”与索引数组组合。例如：
运行程序，输出如下：
[[5 6]
[8 9]]
[[5 6]
[8 9]]
[[3 7]
[5 6]
[8 9]]
在Python中，可以通过一个布尔数组来索引目标数组。布尔索引通过布尔运算（如比较运算符）来获取符合指定条件的元素的数组。
【例2-13】 获取大于5的元素。
import numpy as np
x=np.array([[ 0, 2, 6],[ 3, 11, 5],[ 4, 7, 8],[ 9, 10, 12]])
print('的数组是：')
print(x)
print('\n')
#打印出大于5的元素
print('大于5的元素是：')
print(x[x> 5])
运行程序，输出如下：
数组是:
[[0 2 6]
[3 11 5]
[4 7 8]
[9 10 12]]
大于5的元素是:
[6 11 7 8 9 10 12]
花式索引指的是利用整数数组进行索引。花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应下标的行，如果目标是二维数组，那么就是对应位置的元素。花式索引跟切片不一样，它总是将数据复制到新数组中。
【例2-14】 传入顺序与倒序索引数组。
运行程序，输出如下：
顺序索引数组:
[[16 17 18 19]
[8 9 10 11]
[4 5 6 7]
[28 29 30 31]]
倒序索引数组:
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[4 5 6 7]]
NumPy迭代器对象numpy.nditer提供了一种灵活访问一个或者多个数组元素的方式。迭代器最基本的任务是可以完成对数组元素的访问。
【例2-15】 使用arange()函数创建一个2×3数组，并使用nditer对它进行迭代。
运行程序，输出如下：
原始数组是:
[[0 1 2]
[3 4 5]]
迭代输出元素:
0,1,2,3,4,5,
例2-15不是使用标准C或者FORTRAN顺序，选择的顺序是和数组内存布局一致的，这样做是为了提升访问的效率，默认是行序优先（row-major order，或者说是C-order）。
这反映了默认情况下只需访问每个元素，而无须考虑其特定顺序。可以通过迭代上述数组的转置来看到这一点，并与以C顺序访问数组转置的copy方式做对比。例如：
运行程序，输出如下：
0,1,2,3,4,5,
0,3,1,4,2,5,
从上面代码可以看出，a和a.T的遍历顺序是一样的，也就是它们在内存中的存储顺序也是一样的，但是a.T.copy（order='C'）的遍历结果是不同的，那是因为它和前两种存储方式是不一样的，默认是按行访问。
在NumPy中，还可以通过for结构来控制数组的遍历顺序。
【例2-16】 利用for结构来控制数组的遍历顺序。
运行程序，输出如下：
原始数组是:
[[0 4 8 12]
[16 20 24 28]
[32 36 40 44]]
原始数组的转置是:
[[0 16 32]
[4 20 36]
[8 24 40]
[12 28 44]]
以C风格顺序排序:
[[0 16 32]
[4 20 36]
[8 24 40]
[12 28 44]]
0,16,32,4,20,36,8,24,40,12,28,44,
以F风格顺序排序:
[[0 16 32]
[4 20 36]
[8 24 40]
[12 28 44]]
0,4,8,12,16,20,24,28,32,36,40,44,
还可以通过显式设置，来强制nditer对象使用某种顺序，例如：
运行程序，输出如下：
原始数组是:
[[0 4 8 12]
[16 20 24 28]
[32 36 40 44]]
以C风格顺序排序:
0,4,8,12,16,20,24,28,32,36,40,44,
以F风格顺序排序:
0,16,32,4,20,36,8,24,40,12,28,44,
nditer对象有另一个可选参数op_flags。默认情况下，nditer将视待迭代遍历的数组设为只读对象（read-only），为了在遍历数组的同时实现对数组元素值的修改，必须指定read-write或者read-only的模式。
impor tnumpy as np
a=np.arange(0,48,4)
a=a.reshape(3,4)
print('原始数组是：')
print(a)
print('\n')
for x in np.nditer(a,op_flags=['readwrite']):
x[...]=2*x
print('修改后的数组是：')
print(a)
运行程序，输出如下：
原始数组是:
[[0 4 8 12]
[16 20 24 28]
[32 36 40 44]]
修改后的数组是:
[[0 8 16 24]
[32 40 48 56]
[64 72 80 88]]
Num Py中包含了一些函数用于处理数组，大概可分为以下几类：
· 修改数组形状；
· 翻转数组；
· 连接数组；
· 分割数组；
· 数组元素的添加与删除。
在Num Py中，提供了几个函数用于修改数组的形状，下面对这几个函数进行介绍。
1）reshape()函数
numpy.reshape()函数可以在不改变数据的条件下修改形状，格式如下：
numpy.reshape（arr，newshape，order='C'）：arr为要修改形状的数组。newshape为整数或者整数数组，新的形状应当兼容原有形状。order为排列的顺序，取值为'C'时，按行；取值为'F'时，按列；取值为'A'时，按原顺序；取值为'K'时，按元素在内存中的出现顺序。
【例2-17】 利用reshape()函数改变数组的形状。
import numpy as np
a=np.arange(8)
print('原始数组：')
print(a)
print('\n')
b=a.reshape(4,2)
print('修改后的数组：')
print(b)
运行程序，输出如下：
原始数组:
[0 1 2 3 4 5 6 7]
修改后的数组:
[[0 1]
[2 3]
[4 5]
[6 7]]
2）flat()函数
numpy.ndarray.flat()是一个数组元素迭代器，作用类似于nditer。
【例2-18】 利用flat()函数修改数组形状。
运行程序，输出如下：
原始数组:
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组:
0 1 2 3 4 5 6 7 8
3）flatten()函数
numpy.ndarray.flatten()返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：
ndarray.flatten（order='C'）：参数order取'C'时，按行；取'F'时，按列；取'A'时，按原顺序；取'K'时，按元素在内存中的出现顺序。
【例2-19】 利用flatten()函数改变数组形状。
运行程序，输出如下：
原数组:
[[0 1 2 3]
[4 5 6 7]]
展开的数组:
[0 1 2 3 4 5 6 7]
以F风格顺序展开的数组:
[0 4 1 5 2 6 3 7]
4）ravel()函数
numpy.ravel()实现将数组维度拉成一维数组，顺序通常是"C风格"，返回的是数组视图（有点类似C/C++引用的reference），修改会影响原始数组。函数的调用格式为：
numpy.ravel（a，order='C'）：order取'C'时，按行；取'F'时，按列；取'A'时，按原顺序；取'K'时，按元素在内存中的出现顺序。
【例2-20】 利用ravel()函数修改数组形状。
运行程序，输出如下：
原数组:
[[0 1 2 3]
[4 5 6 7]]
调用r ave l()函数之后：
[0 1 2 3 4 5 6 7]
以F风格顺序调用r ave l()函数之后：
[0 4 1 5 2 6 3 7]
在Num Py中，提供了4个函数用于翻转数组，下面对这几个函数进行介绍。
1）transpose()函数
numpy.transpose()函数用于对换数组的维度，函数的格式如下：
numpy.transpose（arr，axes）：参数arr为要操作的数组；axes为整数列表，对应维度，通常所有维度都会对换。
【例2-21】 利用transpose()函数对数组进行翻转。
运行程序，输出如下：
原数组:
[[0 1 2 3 4]
[5 6 7 8 9]]
对换数组:
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]]
2）ndarray.T()函数
numpy.ndarray.T()类似于numpy.transpose()。
【例2-22】 利用ndarray.T()函数翻转数组。
运行程序，输出如下：
原数组:
[[0 1 2 3 4]
[5 6 7 8 9]]
转置数组:
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]]
3）rollaxis()函数
numpy.rollaxis()函数向后滚动特定的轴到一个特定位置，格式如下：
numpy.rollaxis（arr，axis，start）：arr为数组；axis为要向后滚动的轴，其他轴的相对位置不会改变；start默认为0，表示完整的滚动，会滚动到特定位置。
【例2-23】 利用rollaxis()函数翻转数组。
运行程序，输出如下：
原数组:
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用rollaxis()函数：
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
调用rollaxis()函数：
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
4）swapaxes()函数
numpy.swapaxes()函数用于交换数组的两个轴，格式如下：
numpy.swapaxes（arr，axis1，axis2）：arr为输入的数组；axis1为对应第一个轴的整数；axis2为对应第二个轴的整数。
【例2-24】 利用swapaxes()函数实现数组翻转。
运行程序，输出如下：
原数组:
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用swapaxes()函数后的数组：
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
在NumPy中，提供了4个函数实现数组的连接，下面对这几个函数进行介绍。
1）concatenate()函数
numpy.concatenate()函数用于沿指定轴连接相同形状的两个或多个数组，函数的调用格式为：
numpy.concatenate（（a1，a2，...），axis）：a1，a2，...表示相同类型的数组；axis为沿着它连接数组的轴，默认为0。
【例2-25】 利用concatenate()函数实现数组的连接。
运行程序，输出如下：
第一个数组:
[[1 2]
[3 4]]
第二个数组:
[[5 6]
[7 8]]
沿轴0连接两个数组，竖向拼接矩阵：
[[1 2]
[3 4]
[5 6]
[7 8]]
沿轴1连接两个数组，横向拼接矩阵：
[[1 2 5 6]
[3 4 7 8]]
2）stack()函数
numpy.stack()函数用于沿新轴连接数组序列，函数格式如下：
numpy.stack（arrays，axis）：arrays为相同形状的数组序列；axis为返回数组中的轴，输入数组沿着它来堆叠。
【例2-26】 利用stack()函数实现数组的连接。
运行程序，输出如下：
第一个数组:
[[1 4]
[3 5]]
第二个数组:
[[6 8]
[7 9]]
沿轴0堆叠两个数组:
[[[1 4]
[3 5]]
[[6 8]
[7 9]]]
沿轴1堆叠两个数组:
[[[1 4]
[6 8]]
[[3 5]
[7 9]]]
3）hstack()函数
numpy.hstack()是numpy.stack()函数的变体，它通过水平堆叠来生成数组。
【例2-27】 利用hstack()函数实现数组的连接。
运行程序，输出如下：
第一个数组:
[[1 4]
[3 5]]
第二个数组:
[[6 8]
[7 9]]
水平堆叠:
[[1 4 6 8]
[3 5 7 9]]
4）vstack()函数
numpy.vstack()是numpy.stack()函数的变体，它通过垂直堆叠来生成数组。
【例2-28】 利用vstack()函数实现数组的连接。
运行程序，输出如下：
第一个数组:
[[1 4]
[3 5]]
第二个数组:
[[6 8]
[7 9]]
竖直堆叠:
[[1 4]
[3 5]
[6 8]
[7 9]]
在NumPy中，提供了相关函数实现分割数组，下面对这几个函数进行介绍。
1）split()函数
numpy.split()函数沿特定的轴将数组分割为子数组，函数格式如下：
numpy.split（ary，indices_or_sections，axis）。ary为被分割的数组。indices_or_sections如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴的位置（左开右闭）切分。axis为设置沿着哪个方向进行切分，默认为0，横向切分，即水平方向；为1时，纵向切分，即竖直方向。
【例2-29】 利用split()函数对数组进行分割。
运行程序，输出如下：
第一个数组:
[0 1 2 3 4 5 6 7 8]
将数组分为三个大小相等的子数组:
[array([0,1,2]),array([3,4,5]),array([6,7,8])]
将数组在一维数组中表明的位置分割:
[array([0,1,2,3]),array([4,5,6]),array([7,8])]
2）hsplit()函数
numpy.hsplit()函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
【例2-30】 利用hsplit()函数对数组进行水平分割。
运行程序，输出如下：
同时，在Num Py中，numpy.vsplit()沿着垂直轴分割，其分割方式与hsplit()相同。
与其他语言一样，在NumPy中，也提供了相关函数用于实现数组元素的添加和删除。下面对相关函数进行介绍。
1）resize()函数
numpy.resize()函数返回指定大小的新数组。如果新数组大小大于原始大小，则包含原始数组中的元素的副本。函数的格式为：
numpy.resize（arr，shape）：arr为要修改大小的数组；shape为返回数组的新形状。
【例2-31】 利用resize()函数返回指定大小的新数组。
运行程序，输出如下：
第一个数组:
[[1 4 7]
[3 6 9]]
第一个数组的形状:
(2,3)
改变第一个数组的形状:
[[1 4]
[7 3]
[6 9]]
改变后的形状:
(3,2)
修改新数组的大小:
[[1 4 7]
[3 6 9]
[1 4 7]]
2）append()函数
numpy.append()函数在数组的末尾添加值，添加操作会分配整个数组，并把原来的数组复制到新数组中。此外，输入数组的维度必须匹配否则将生成ValueError。append()函数返回的始终是一个一维数组。函数的格式为：
numpy.append（arr，values，axis=None）：arr为输入数组。values为要向arr添加的值，需要和arr形状相同（除了要添加的轴）。axis默认为None，当axis无定义时，是横向操作，返回总是为一维数组；当axis有定义的时候，取值为0和1，当axis为0时，数组按列进行操作（列数要相同）。当axis为1时，数组按行进行操作（行数要相同）。
【例2-32】 利用append()函数在数组末尾添加值。
运行程序，输出如下：
第一个数组:
[[1 4 7]
[3 6 9]]
向数组添加元素:
[1 4 7 3 6 9 2 5 8]
沿轴0添加元素:
[[1 4 7]
[3 6 9]
[2 5 8]]
沿轴1添加元素:
[[1 4 7 3 3 3]
[3 6 9 2 5 8]]
3）insert()函数
numpy.insert()函数实现沿给定轴在给定索引之前插入值。函数的格式为：
numpy.insert（arr，obj，values，axis）：arr为输入数组；obj为在其之前插入值的索引；values为要插入的值；axis为沿着它插入的轴，如果未提供，则输入数组会被展开。
【例2-33】 利用insert()函数在给定轴的数组中插入值。
运行程序，输出如下：
第一个数组:
[[1 4]
[2 5]
[3 6]]
未传递ax is参数。在插入之前输入数组会被展开。
[1 4 2 11 12 5 3 6]
传递了ax is参数。会广播值数组来使其与输入数组形状吻合。沿轴0广播:
[[1 4]
[11 11]
[2 5]
[3 6]]
沿轴1广播:
[[1 11 4]
[2 11 5]
[3 11 6]]
4）delete()函数
numpy.delete()函数返回从输入数组中删除指定子数组的新数组。与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开。函数的格式为：
numpy.delete（arr，obj，axis）：arr为输入数组；obj可以被切片，整数或者整数数组，表明要从输入数组删除的子数组；axis表示沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开。
【例2-34】 利用delete()函数从输入数组中删除指定数组。
运行程序，输出如下：
第一个数组:
[[0 1 2 3]
[4 5 6 7]
[8 9 10 11]]
未传递ax is参数。在删除之前输入数组会被展开。
[0 1 2 3 4 6 7 8 9 10 11]
删除第二列:
[[0 2 3]
[4 6 7]
[8 10 11]]
删除第三行:
[[0 1 2 3]
[4 5 6 7]]
5）unique()函数
numpy.unique()函数用于去除数组中的重复元素。函数的格式为：
numpy.unique（arr，return_index，return_inverse，return_counts）：arr为输入数组，如果不是一维数组则会展开；return_index如果为True，返回新列表元素在旧列表中的位置（下标），并以列表形式存储；return_inverse如果为True，返回旧列表元素在新列表中的位置（下标），并以列表形式存储；return_counts如果为True，返回去重数组中的元素在原数组中的出现次数。
【例2-35】 利用unique()函数去除数组中的重复元素。
运行程序，输出如下：
第一个数组:
[5 2 6 2 7 2 6 8 2 9]
第一个数组去重后:
[2 5 6 7 8 9]
去重数组的索引数组（新列表元素在旧列表中的位置）:
[1 0 2 4 7 9]
可以看到每个和原数组下标对应的数值:
[5 2 6 2 7 2 6 8 2 9]
去重后的数组:
[2 5 6 7 8 9]
下标（旧列表元素在新列表中的位置）为：
[1 0 2 0 3 0 2 4 0 5]
使用下标重构原数组:
[5 2 6 2 7 2 6 8 2 9]
返回去重元素的重复数量:
2:重复数量4
5:重复数量1
6:重复数量2
7:重复数量1
8:重复数量1
9:重复数量1
Num Py算术函数包含简单的加、减、乘、除，对应的函数分别为add()、subtract()、multiply()和divide()。
需要注意的是数组必须具有相同的形状或符合数组广播规则。
【例2-36】 数组的加减乘除运算。
运行程序，输出如下：
第一个数组:
[[0.1.2.]
[3.4.5.]
[6.7.8.]]
第二个数组:
[9 9 9]
两个数组相加:
[[9.10.11.]
[12.13.14.]
[15.16.17.]]
两个数组相减:
[[-9.-8.-7.]
[-6.-5.-4.]
[-3.-2.-1.]]
两个数组相乘:
[[0. 9.18.]
[27.36.45.]
[54.63.72.]]
两个数组相除:
[[0. 0.11111111 0.22222222]
[0.33333333 0.44444444 0.55555556]
[0.66666667 0.77777778 0.88888889]]
此外NumPy也包含了其他重要的算术函数，下面对一些常用的算术函数进行介绍。
1）reciprocal()函数
numpy.reciprocal()函数返回参数逐元素的倒数。如1/4倒数为4/1。
【例2-37】 利用reciprocal()函数返回逐元素的倒数。
运行程序，输出如下：
数组是:
[ 1.25 1.33 1. 100. ]
调用reciprocal()函数：
[0.8 0.7518797 1. 0.01 ]
2）power()函数
numpy.power()函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
【例2-38】 利用power()函数将第一个输入数作为底数，计算相应元素的幂。
运行程序，输出如下：
数组是;
[ 10 500 1000]
调用power()函数：
[ 100 250000 1000000]
第二个数组:
[1 2 3]
再次调用power()函数：
[ 10 250000 1000000000]
3）mod()函数
numpy.mod()函数计算输入数组中相应元素相除后的余数。函数numpy.remainder()也产生相同的结果。
【例2-39】 利用mod()函数求相应元素相除后的余数。
运行程序，输出如下：
第一个数组:
[10 30 60]
第二个数组:
[3 5 7]
调用mod()函数：
[1 0 4]
调用remainder()函数：
[1 0 4]