测试是否安装成功，程序代码如下：

01 from numpy import * #导入numpy库
02 print(eye(4)) #生成对角矩阵
运行程序，输出结果如下：

​ 图8.7　一维数组一个轴

8.2　创建数组

8.2.1　创建简单的数组

NumPy创建简单的数组主要使用array()函数，语法如下：

numpy.array(object,dtype=None,copy=True,order=’K’,subok=False,ndmin=0)
参数说明：　

object：任何具有数组接口方法的对象。　

dtype：数据类型。　

copy：布尔型，可选参数，默认值为True，则object对象被复制；否则，只有当__array__返回副本，object参数为嵌套序列，或者需要副本满足数据类型和顺序要求时，才会生成副本。　

order：元素在内存中的出现顺序，值为K、A、C、F。如果object参数不是数组，则新创建的数组将按行排列（C），如果值为F，则按列排列；如果object参数是一个数组，则C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）成立。　

subok：布尔型。如果值为True，则将传递子类；否则返回的数组将强制为基类数组（默认值）。　

ndmin：指定生成数组的最小维数。

【示例03】　复制数组。（示例位置：资源包\MR\Code\08\03）
当运算和处理数组时，为了不影响到原数组，就需要对原数组进行复制，而对复制后的数组进行修改删除等操作都不会影响到原数组。数组的复制可以通过copy参数实现，程序代码如下：

copy=True 新数组改变 旧数组不改变 否则反之
ndmin=3，虽然给出的数组是一维的，但是同样会创建一个三维数组，程序代码如下：
运行程序，输出结果如下：

[[[1 2 3]]]

1．创建指定维度和数据类型未初始化的数组

【示例05】　创建指定维度和未初始化的数组。（示例位置：资源包\MR\Code\08\05）
创建指定维度和数据类型未初始化的数组主要使用empty()函数，程序代码如下：

01 import numpy as np
02 n = np.empty([2,3])
03 print(n)
运行程序，输出结果如下：

[[2.22519099e-307 2.33647355e-307 1.23077925e-312]
[2.33645827e-307 2.67023123e-307 1.69117157e-306]]
这里，数组元素为随机值，因为它们未被初始化。如果要改变数组类型，可以使用dtype参数，如整型，dtype=int。

2．创建指定维度（以0填充）的数组

【示例06】　创建指定维度（以0填充）的数组。（示例位置：资源包\MR\Code\08\06）
创建指定维度并以0填充的数组，主要使用zeros()函数，程序代码如下：

01 import numpy as np
02 n = np.zeros(3)
03 print(n)
运行程序，输出结果如下：

[0. 0. 0.]
输出结果默认是浮点型（float）。

3．创建指定维度（以1填充）的数组

【示例07】　创建指定维度并以1填充的数组。（示例位置：资源包\MR\Code\08\07）
创建指定维度并以1填充的数组，主要使用ones()函数，程序代码如下：

01 import numpy as np
02 n = np.ones(3)
03 print(n)

运行程序，输出结果如下：

[1. 1. 1.]
4．创建指定维度和类型的数组并以指定值填充【示例08】　创建以指定值填充的数组。（示例位置：资源包\MR\Code\08\08）
创建指定维度和类型的数组并以指定值填充，主要使用full()函数，程序代码如下：

01 import numpy as np
02 n = np.full((3,3), 8)
03 print(n)
运行程序，输出结果如下：

[[8 8 8]
[8 8 8]
[8 8 8]]

8.2.3　从数值范围创建数组

1．通过arange()函数创建数组

arange()函数同Python内置range()函数相似，区别在于返回值，arange()函数返回值是数组，而range()函数返回值是列表。arange()函数的语法如下：

arange([start,] stop[, step,], dtype=None)
参数说明：　

start：起始值，默认值为0。　

stop：终止值（不包含）。　

step：步长，默认值为1。　

dtype：创建数组的数据类型，如果不设置数据类型，则使用输入数据的数据类型。

01 import numpy as np
02 n=np.arange(1,12,2)
03 print(n)
运行程序，输出结果如下：

[ 1 3 5 7 9 11]

2．使用linspace()函数创建等差数列

首先简单了解一下等差数列，等差数列是指如果一个数列从第二项起，每一项与它的前一项的差等于同一个常数，那么这个数列就叫作等差数列。
例如，一般成年男鞋的各种尺码，如图8.9所示。

​ 图8.10　训练计划
在Python中创建等差数列可以使用NumPy的linspace()函数，该函数用于创建一个一维的等差数列的数组，它与arange()函数不同，arange()函数是从开始值到结束值的左闭右开区间（即包括开始值不包括结束值），第三个参数（如果存在）是步长；而linspace()函数是从开始值到结束值的闭区间（可以通过参数endpoint=False，使结束值不是闭区间），并且第三个参数是值的个数。

linspace()函数语法如下：

linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None)
参数说明：　

start：序列的起始值。　

stop：序列的终止值，如果endpoint参数的值为True，则该值包含于数列中。　

num：要生成的等步长的样本数量，默认值为50。　

endpoint：如果值为True，数列中包含stop参数的值；反之则不包含。默认值为True。　

retstep：如果值为True，则生成的数组中会显示间距；反之则不显示。　

dtype：数组的数据类型。

01 import numpy as np
02 n1 = np.linspace(7500,10000,6)
03 print(n1)
运行程序，输出结果如下：

[ 7500. 8000. 8500. 9000. 9500. 10000.]

3．使用logspace()函数创建等比数列

在Python中创建等比数列可以使用NumPy的logspace()函数，语法如下：

numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
参数说明：　

start：序列的起始值。　

stop：序列的终止值。如果endpoint参数值为True，则该值包含于数列中。　

num：要生成的等步长的数据样本数量，默认值为50。　

endpoint：如果值为True，则数列中包含stop参数值；反之则不包含。默认值为True。　

base：对数log的底数。　

dtype：数组的数据类型。

01 import numpy as np
02 n = np.logspace(0,63,64,base=2,dtype=’int’)
03 print(n)

​ 图8.12　每个格子里放的小麦数

上述举例出现一个问题：后面大数出现负数，而且都是一样的，这是由于程序中指定的数据类型是int，是32位的，数据范围为-2147483648～2147483647，而我们计算后的数据远远超出了这个范围，因此便出现了溢出现象。解决这一问题，需要指定数据类型为uint64（无符号整数，数据范围为0～18446744073709551615），关键代码如下：

n = np.logspace(0,63,64,base=2,dtype=’uint64’)

随机数组的生成主要使用NumPy的random模块，下面介绍几种常用的随机生成数组的函数。

1．rand()

rand()函数用于生成(0,1)之间的随机数组，传入一个值随机生成一维数组，传入一对值则随机生成二维数组，语法如下：

numpy.random.rand(d0,d1,d2,d3,…,dn)
参数d0，d1，…，dn为整数，表示维度，可以为空。

【示例12】　随机生成0～1的数组。（示例位置：资源包\MR\Code\08\12）
随机生成一维数组和二维数组，代码如下：
运行程序，输出结果如下：

2．randn()

randn()函数用于从正态分布中返回随机生成的数组，语法如下：

numpy.random.randn(d0,d1,d2,d3,…,dn)
参数d0，d1，…，dn为整数，表示维度，可以为空。

【示例13】　随机生成满足正态分布的数组。（示例位置：资源包\MR\Code\08\13）
随机生成满足正态分布的数组，程序代码如下：
运行程序，输出结果如下：

3．randint()

randint()函数与NumPy的arange()函数类似。randint()函数用于生成一定范围内的随机数组，左闭右开区间，语法如下：

numpy.random.randint(low,high=None,size=None)

参数说明：　

low：低值（起始值），整数，且当参数high不为空时，参数low应小于参数high；否则程序会出现错误。　

high：高值（终止值），整数。

size：数组维数，整数或者元组，整数表示一维数组，元组表示多维数组。默认值为空，如果为空，则仅返回一个整数。

4．normal()

normal()函数用于生成正态分布的随机数，语法如下：

numpy.random.normal(loc,scale,size)
参数说明：　

loc：正态分布的均值，对应正态分布的中心。loc=0说明是一个以y轴为对称轴的正态分布。　

scale：正态分布的标准差，对应正态分布的宽度，scale值越大，正态分布的曲线越“矮胖”；scale值越小，曲线越“高瘦”。　size：表示数组维数。

【示例15】　生成正态分布的随机数组。（示例位置：资源包\MR\Code\08\15）
生成正态分布的随机数组，程序代码如下：

01 import numpy as np
02 n = np.random.normal(0, 0.1, 10)
03 print(n)
运行程序，输出结果如下：

[ 0.08530096 0.0404147 -0.00358281 0.05405901 -0.01677737 -0.02448481
0.13410224 -0.09780364 0.06095256 -0.0431846 ]

1．asarray()函数

asarray()函数用于创建数组，其与array()函数类似，语法如下：

numpy.asarray(a,dtype=None,order=None)
参数说明：　

a：可以是列表、列表的元组、元组、元组的元组、元组的列表或多维数组。　

dtype：数组的数据类型。　

order：值为C和F，分别代表按行排列和按列排列，即数组元素在内存中的出现顺序。

4．empty_like()函数

empty_like()函数用于创建一个与给定数组具有相同维度和数据类型且未初始化的数组，语法如下：

numpy.empty_like(prototype,dtype=None,order=’K’,subok=True)
参数说明：　

prototype：给定的数组。　

dtype：覆盖结果的数据类型。　

order：指定数组的内存布局。其中C（按行）、F（按列）、A（原顺序）、K（数据元素在内存中的出现顺序）。　

subok：默认情况下，返回的数组被强制为基类数组。如果值为True，则返回子类。

【示例19】　创建未初始化的数组。（示例位置：资源包\MR\Code\08\19）
下面使用empty_like()函数创建一个与给定数组具有相同维数、数据类型以及未初始化的数组，程序代码如下：

01 import numpy as np

02 n = np.empty_like([[1, 2], [3, 4]])
03 print(n)
运行程序，输出结果如下：

[[0 0]
[0 0]]

5．zeros_like()函数

【示例20】　创建以0填充的数组。（示例位置：资源包\MR\Code\08\20）
zeros_like()函数用于创建一个与给定数组维度和数据类型相同，并以0填充的数组，程序代码如下：

01 import numpy as np
02 n = np.zeros_like([[0.1,0.2,0.3], [0.4,0.5,0.6]])
03 print(n)
运行程序，输出结果如下：

[[0. 0. 0.]
[0. 0. 0.]]说明
参数说明请参见empty_like()函数。

6．ones_like()函数

【示例21】　创建以1填充的数组。（示例位置：资源包\MR\Code\08\21）
ones_like()函数用于创建一个与给定数组维度和数据类型相同，并以1填充的数组，程序代码如下：

01 import numpy as np
02 n = np.ones_like([[0.1,0.2,0.3], [0.4,0.5,0.6]])

03 print(n)
运行程序，输出结果如下：

[[1. 1. 1.]
[1. 1. 1.]]说明
参数说明请参见empty_like()函数。

7．full_like()函数

full_like()函数用于创建一个与给定数组维度和数据类型相同，并以指定值填充的数组，语法如下：

numpy.full_like(a, fill_value, dtype=None, order=’K’, subok=True)
参数说明：　

a：给定的数组。　

fill_value：填充值。　

dtype：数组的数据类型，默认值为None，则使用给定数组的数据类型。　

order：指定数组的内存布局。其中C（按行）、F（按列）、A（原顺序）、K（数组元素在内存中的出现顺序）。　

subok：默认情况下，返回的数组被强制为基类数组。如果值为True，则返回子类。

8.3.1　数据类型

在对数组进行基本操作前，首先了解一下NumPy的数据类型。NumPy的数据类型比Python数据类型增加了更多种类的数值类型，如表8.1所示。为了区别Python数据类型，像bool、int、float、complex、str等数据类型的名称末尾都加了短下画线“_”。

每一种数据类型都有相应的数据转换函数。举例如下：

np.int8(3.141)

结果为3。

np.float64(8)
结果为8.0。

np.float(True)
结果为1.0。

bool(1)
结果为True。
在创建ndarray数组时，可以直接指定数值类型，关键代码如下：

a = np.arange(8, dtype=float)
结果为[0. 1. 2. 3. 4. 5. 6. 7.]。

注意
复数不能转换成为整数类型或者浮点数，例如以下的代码会出现错误提示：

float(8+ 1j)

数组索引和切片

NumPy数组元素是通过数组的索引和切片来访问和修改的，因此索引和切片是NumPy中最重要、最常用的操作。

1．索引

所谓数组的索引，即用于标记数组中对应元素的唯一数字，从0开始，即数组中的第一个元素的索引是0，以此类推。NumPy数组可以使用标准Python语法x[obj]的语法对数组进行索引，其中x是数组，obj是索引。

【示例28】　获取一维数组中的元素。（示例位置：资源包\MR\Code\08\28）
获取一维数组n1中索引为0的元素，程序代码如下：

01 import numpy as np
02 n1=np.array([1,2,3]) #创建一维数组
03 print(n1[0]) #输出一维数组的第一个元素
运行程序，输出结果如下：

1

【示例29】　获取二维数组中的元素。（示例位置：资源包\MR\Code\08\29）
再举一个例子，通过索引获取二维数组中的元素，程序代码如下：

01 import numpy as np
02 n1=np.array([[1,2,3],[4,5,6]]) #创建二维数组
03 print(n1[1] [2]) #输出二维数组中第2行第3列的元素
运行程序，输出结果如下：

6

2．切片式索引

数组的切片可以理解为对数组的分割，按照等分或者不等分，将一个数组切割为多个片段，它与Python中列表的切片操作一样。NumPy中的切片用冒号分隔切片参数来进行切片操作，语法如下：

[start:stop:step]
参数说明：　

start：起始索引。

stop：终止索引。　

step：步长。

【示例30】　实现简单的数组切片操作。（示例位置：资源包\MR\Code\08\30）
实现简单的切片操作，对数组n1进行切片式索引操作，如图8.19所示。

切片式索引操作需要注意以下几点。
（1）索引是左闭右开区间，如上述代码中的n1[0:2]，只能取到索引从0～1的元素，而取不到索引为2的元素。
（2）当没有start参数时，代表从索引0开始取数，如上述代码中的n1[:2]。
（3）start、stop和step这3个参数都可以是负数，代表反向索引。以step参数为例，如图8.20所示。

【示例31】　常用的切片式索引操作。（示例位置：资源包\MR\Code\08\31）
常用的切片式索引操作，程序代码如下：

运行程序，输出结果如下：

3．二维数组索引

二维数组索引可以使用array[n,m]的方式，以逗号分隔，表示第n个数组的，第m个元素。

【示例32】　二维数组的简单索引操作。（示例位置：资源包\MR\Code\08\32）
创建一个3行4列的二维数组，实现简单的索引操作，效果如图8.21所示。

​ 图8.21　二维数组索引示意图
程序代码如下：

上述代码中，n[1]表示第2个数组，n[1,2]表示第2个数组第3个元素，它等同于n[1][2]，表示数组n中第2行第3列的值，实际上n[1] [2]是先索引第一个维度得到一个数组，然后在此基础上再索引。

4．二维数组切片式索引

import numpy as np

创建3行3列的二维数组

n=np.array([[1,2,3],[4,5,6],[7,8,9]])

print(n[:2,1:]) #输出第1行至第3行（不包括第三行）的第二列至最后一列的元素

print(n[1,:2]) # 输出第2行的第1列至第3列（不包括第3列）的以元素

pirnt(n[:2,2]) # 输出第1行至第3行（不包括第3行）的第3列的元素

print(n[:,:1]) #输出所有行的第一列至第二列（不包括第2列）的元素

8.3.4　数组重塑

数组重塑实际是更改数组的形状，例如，将原来2行3列的数组重塑为3行4列的数组。在NumPy中主要使用reshape()方法，该方法用于改变数组的形状。

3．数组转置

数组转置是指数组的行列转换，可以通过数组的T属性和transpose()函数实现。

01 n = np.array([[‘A’,100],[‘B’,200],[‘C’,300],[‘D’,400],[‘E’,500]])
02 print(n.transpose()) #transpose()函数行列转置

1．数组的增加

数组数据的增加可以按照水平方向增加数据，也可以按照垂直方向增加数据。水平方向增加数据主要使用hstack()函数，垂直方向增加数据主要使用vstack()函数。

2．数组的删除

数组的删除主要使用delete()方法。

【示例40】　删除指定的数组。（示例位置：资源包\MR\Code\08\40）
删除指定的数组，程序代码如下：

np.delete(n1,2,axis=0) # 删除第3行

np.delete(n1,(1,2),axis=1) # 删除第二行和第三行

3．数组的修改

修改数组或数组元素时，直接为数组或数组元素赋值即可。

【示例41】　修改指定的数组。（示例位置：资源包\MR\Code\08\41）
修改指定的数组，程序代码如下：

运行程序，输出结果如下：

4．数组的查询

数组的查询同样可以使用索引和切片方法来获取指定范围的数组或数组元素，还可以通过where()函数查询符合条件的数组或数组元素。where()函数语法如下：

numpy.where(condition,x,y)
上述语法，第一个参数为一个布尔数组，第二个参数和第三个参数可以是标量也可以是数组。满足条件（参数condition），输出参数x，不满足条件输出参数y。

【示例42】　按指定条件查询数组。（示例位置：资源包\MR\Code\08\42）
数组查询，大于5输出2，不大于5输出0，程序代码如下：

运行程序，输出结果如下：

[0 1 2 3 4 5 6 7 8 9]
[0 0 0 0 0 0 2 2 2 2]
如果不指定参数x和y，则输出满足条件的数组元素的坐

标。例如，上述举例不指定参数x和y，关键代码如下：

01 n2=n1[np.where(n1>5)]
02 print(n2)
运行程序，输出结果如下：

（3）使用random模块的rand()函数创建一个3×3为0～1随机产生的二维数组，并将其转换为矩阵，程序代码如下：

01 import numpy as np

02 data1 = np.mat(np.random.rand(3,3))
03 print(data1)

（4）创建一个1～8的随机整数矩阵，程序代码如下：

01 import numpy as np
02 data1 = np.mat(np.random.randint(1,8,size=(3,5)))
03 print(data1)
运行程序，输出结果如下：

矩阵运算

​ 图8.28　矩阵相乘运算过程示意图
数组运算和矩阵运算的一个关键区别是矩阵相乘使用的是点乘。点乘，也称点积，是数组中元素对应位置一一相乘之后求和的操作，在NumPy中专门提供了点乘方法，即dot()方法，该方法返回的是两个数组的点积。

【示例49】　矩阵元素之间的相乘运算。（示例位置：资源包\MR\Code\08\49）
要实现矩阵对应元素之间的相乘可以使用multiply()函数，程序代码如下：

8.4.3　矩阵转换

1．矩阵转置

【示例50】　使用T属性实现矩阵转置。（示例位置：资源包\MR\Code\08\50）
矩阵转置与数组转置一样使用T属性，程序代码如下：

01 import numpy as np
02 n1 = np.mat(‘1 3 3;4 5 6;7 12 9’) #创建矩阵，使用分号隔开数据
03 print(‘矩阵转置结果为：\n’,n1.T) #矩阵转置
运行程序，输出结果如下：

2．矩阵求逆

【示例51】　实现矩阵逆运算。（示例位置：资源包\MR\Code\08\51）
矩阵要可逆，否则意味着该矩阵为奇异矩阵（即矩阵的行列式的值为0）。矩阵求逆主要使用I属性，程序代码如下：

01 import numpy as np
02 n1 = np.mat(‘1 3 3;4 5 6;7 12 9’) #创建矩阵，使用分号隔开数据
03 print(‘矩阵的逆矩阵结果为：\n’,n1.I) #逆矩阵
运行程序，输出结果如下：

8.5.1　数学运算函数

NumPy包含大量的数学运算的函数，包括三角函数、算术运算函数、复数处理函数等，如表8.2所示。

下面介绍几个常用的数学运算函数。

1．算术函数

（1）加、减、乘、除

NumPy算术函数包含简单的加、减、乘、除运算，如add()函数、subtract()函数、multiply()函数和divide()函数。这里要注意的是，数组必须具有相同的形状或符合数组广播规则。

【示例52】　数组加、减、乘、除运算。（示例位置：资源包\MR\Code\08\52）
数组加、减、乘、除运算，程序代码如下：

运行程序，输出结果如下：

（2）倒数

reciprocal()函数用于返回数组中各元素的倒数。如4/3的倒数是3/4。

【示例53】　计算数组元素的倒数。（示例位置：资源包\MR\Code\08\53）
计算数组元素的倒数，程序代码如下：

01 import numpy as np
02 a = np.array([0.25, 1.75, 2, 100])
03 print(np.reciprocal(a))
运行程序，输出结果如下：

[4. 0.57142857 0.5 0.01 ]

（3）求幂

power()函数将第一个数组中的元素作为底数，计算它与第二个数组中相应元素的幂。

【示例54】　数组元素的幂运算。（示例位置：资源包\MR\Code\08\54）
对数组元素幂运算，程序代码如下：

01 import numpy as np
02 n1 = np.array([10, 100, 1000])
03 print(np.power(n1, 3))
04 n2= np.array([1, 2, 3])
05 print(np.power(n1, n2))
运行程序，输出结果如下：

[ 1000 1000000 1000000000]
[ 10 10000 1000000000]

（4）取余

mod()函数用于计算数组之间相应元素相除后的余数。

【示例55】　对数组元素取余。（示例位置：资源包\MR\Code\08\55）
对数组元素取余，程序代码如下：

01 import numpy as np
02 n1 = np.array([10, 20, 30])
03 n2 = np.array([4, 5, -8])
04 print(np.mod(n1, n2))
运行程序，输出结果如下：

[ 2 0 -2]

2．舍入函数

（1）四舍五入around()函数

四舍五入在NumPy中应用比较多，主要使用around()函数，该函数返回指定小数位数的四舍五入值，语法如下：

numpy.around(a,decimals)
参数说明：　

a：数组。　

decimals：舍入的小数位数，默认值为0，如果为负，整数将四舍五入到小数点左侧的位置。

（2）向上取整ceil()函数

ceil()函数用于返回大于或者等于指定表达式的最小整数，即向上取整。

【示例57】　对数组元素向上取整。（示例位置：资源包\MR\Code\08\57）
对数组元素向上取整，程序代码如下：
运行程序，输出结果如下：

[-1. 2. -0. 1. 15.]

（3）向下取整floor()函数

floor()函数用于返回小于或者等于指定表达式的最大整数，即向下取整。

【示例58】　对数组元素向下取整。（示例位置：资源包\MR\Code\08\58）

对数组元素向下取整，程序代码如下：

01 import numpy as np
02 n = np.array([-1.8, 1.66, -0.2, 0.888, 15]) #创建数组
03 print(np.floor(n)) #向下取整
运行程序，输出结果如下：

[-2. 1. -1. 0. 15.]

8.5.2　统计分析函数

4．加权平均average()

在日常生活中，常用平均数表示一组数据的“平均水平”。在一组数据里，一个数据出现的次数称为权。将一组数据与出现的次数相乘再平均就是“加权平均”。加权平均能够反映一组数据中各个数据的重要程度，以及对整体趋势的影响。加权平均在日常生活应用非常广泛，如考试成绩、股票价格、竞技比赛等。

【示例64】　计算电商各活动销售的加权平均价。（示例位置：资源包\MR\Code\08\64）
某电商在开学季、6.18、双十一、双十二等活动价格均不同，下面计算加权平均价，程序代码如下：

运行程序，输出结果如下：

加权平均价：
34.84920634920635

5．中位数median()

中位数用来衡量数据取值的中等水平或一般水平，可以避免极端值的影响。在数据处理过程中，当数据中存在少量异常值时，它不受其影响，基于这一特点，一般使用中位数来评价分析结果。
那么，什么是中位数？将各个变量值按大小顺序排列起来，形成一个数列，居于数列中间位置的那个数即为中位数。例如，1、2、3、4、5这5个数，中位数就是中间的数字3，而1、2、3、4、5、6这6个数，中位数则是中间两个数的平均值，即3.5。

知识胶囊
中位数与平均数不同，它不受异常值的影响。例如，将1、2、3、4、5、6改为1、2、3、4、5、288，中位数依然是3.5。

【示例65】　计算电商活动价格的中位数。（示例位置：资源包\MR\Code\08\65）
计算电商在开学季、6.18、双十一、双十二等活动价格的中位数，程序代码如下：
运行程序，输出结果如下：

数组排序：
[33.6 34.5 36. 37.8 39. 39.8]数组中位数为：
36.9

8.5.3　数组的排序

数组的排序是对数组元素进行排序。

1．sort()

使用sort()函数进行排序，直接改变原数组，参数axis指定按行排序还是按列排序。

2．argsort()函数

使用argsort()函数对数组进行排序，返回升序排序之后数组值从小到大的索引值。

3．lexsort()函数

lexsort()函数用于对多个序列进行排序。可以把它当作是对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

NumPy用于图像灰度处理

案例位置：资源包\MR\Code\08\example\02
首先了解一下图像，图像其实是由若干像素组成，每一个像素都有明确的位置和被分配的颜色值，因此一张图像也就构成了一个像素矩阵。例如，一张灰度图片的像素块，如图8.32所示。

​ 图8.32　灰度图片像素矩阵示意图
从图8.32得知：灰度图的数据是一个二维数组，颜色取值为0～255，其中，0为黑色，255为白色。从0～255逐渐由暗色变为亮色。由此可见，图像灰度处理是不是就可以通过数组计算来实现呢？
接下来，了解一个公式，RGB转换成灰度图像的常用公式：

Gray = R0.299 + G0.587 + B*0.114
其中，Gray表示灰度值，R、G、B表示红、绿、蓝颜色值，0.299、0.587、0.114表示灰度公式的固定值。

下面使用NumPy结合Matplotlib实现图像的灰度处理，程序代码如下：

上述代码，显示灰度图时，需要在imshow()函数中设置参数cmap=”gray”。