一、数组的索引和切片
（一）数组的索引
首先，导入 NumPy 库。
import numpy as np
一维数组的索引与 Python 列表的索引用法相同。
m = np.array([23,79,16,5,32]) print("m =",m) print('m[1] =',m[1],'\t','m[-3] =',m[-3])
m = [23 79 16 5 32] m[1] = 79 m[-3] = 16
对于多维数组，它的每一个维度都有一个索引，各个维度的索引之间用逗号分隔。
n = np.array([[1,2,3,],[11,22,33],[111,222,333],[1111,2222,3333]]) print("n =",n) print("n[1,2] =",n[1,2],'\t',"n[-1,-2] =",n[-1,-2]) print("n[1][2] =",n[1][2],'\t',"n[-1][-2] =",n[-1][-2]) # 虽然与上面等价，但更推荐上面的写法
输出：
n = [[ 1 2 3] [ 11 22 33] [ 111 222 333] [1111 2222 3333]] n[1,2] = 33 n[-1,-2] = 2222 n[1][2] = 33 n[-1][-2] = 2222
（二）数组的切片
数组切片的目的是为了获取子数组。一维数组的切片与 Python 列表的切片用法相同。
# 一维数组的切片与Python列表的切片用法相同 print("m =",m) print("m[::-1] =",m[::-1]) # 逆序 *** print("m[1:-1:2] =",m[1:-1:2]) # 从第2个开始、隔一个取一个、一直取到倒数第二个
m[::-1]表示逆序输出，m[1:-1:2]表示从第2个开始、隔一个取一个、一直取到倒数第二个。
输出：
m = [23 79 16 5 32] m[::-1] = [32 5 16 79 23] m[1:-1:2] = [79 5]
二维数组允许在每个维度上使用切片，相互间用逗号分隔。
# 二维数组允许在每个维度上使用切片，相互间用逗号分隔 print("n =",n) print("n[1:,2:4] =",n[1:,2:4]) # 行：第2行到最后一行，列：第3、4列 print("n[::,-3::2] =",n[::,-3::2]) # 行：所有行，列：第1列开始、每隔1列 print("n[1,:]用于取第2行：",n[1,:]) # 单个冒号:出现在列的位置上，表示所有列 print("n[:,-1]用于取最后一列：",n[:,-1]) # 单个冒号:出现在行的位置上，表示所有行
注意此处二维数组的冒号与前面一维数组***处冒号的区别：前者冒号是分隔符 ，后者表示所有行/列。
输出：
n = [[ 1 2 3] [ 11 22 33] [ 111 222 333] [1111 2222 3333]] n[1:,2:4] = [[ 33] [ 333] [3333]] n[::,-3::2] = [[ 1 3] [ 11 33] [ 111 333] [1111 3333]] n[1,:]用于取第2行： [11 22 33] n[:,-1]用于取最后一列： [ 3 33 333 3333]
注意：
数组切片返回的是数组数据的视图而非副本，但 Python 列表的切片返回的却是副本，因此通过数组切片赋值将会修改原数组。
# 通过数组切片赋值将会修改原数组 p = n[:,:] print("获取n的全部元素后产生的数组p=",p) # 通过切片赋值,会改变原来的数组 p[1:2,:] = 555 print("切片赋值后数组p=",p) print("切片赋值后数组n=",n)
输出：
获取n的全部元素后产生的数组p= [[ 1 2 3] [ 11 22 33] [ 111 222 333] [1111 2222 3333]] 切片赋值后数组p= [[ 1 2 3] [ 555 555 555] [ 111 222 333] [1111 2222 3333]] 切片赋值后数组n= [[ 1 2 3] [ 555 555 555] [ 111 222 333] [1111 2222 3333]]
数组的切片返回的是原始数组的视图，不会产生新的数据，如果需要的并非视图而是要复制数据，则可以通过 copy() 方法实现。要想实现数组复制，需要掉用数组对象的copy()方法或np.copy(对象)。
q = m.copy() # 等价于q = np.copy(m) print(q) # 复制后的数组 q[-1] = 100 print(q) # 修改了m的副本q的最后一个元素 print(m) # m并没有改变
输出：
[23 79 16 5 32] [ 23 79 16 5 100] [23 79 16 5 32]
二、数组的变换
（一）数组转置
r = n.T print("转置后的数组r=",r)
输出：
转置后的数组r= [[ 1 555 111 1111] [ 2 555 222 2222] [ 3 555 333 3333]]
（二）数组重塑
对于定义好的数组，可以通过reshape()方法改变其数据维度。
参数名称格式： np.reshape(a, newshape, order='C')
| 参数名称 | 说明 |
| a | 需要处理的数据 |
| newshape | 新维度——整数或整数元组 |
print("变形前数组r的形状：",r.shape) s = r.reshape((2,6)) # 注意参数是一个元组 print("变形后数组r=",r) print("变形后新数组s=",s)
输出：
变形前数组r的形状： (3, 4) 变形后数组r= [[ 1 555 111 1111] [ 2 555 222 2222] [ 3 555 333 3333]] 变形后新数组s= [[ 1 555 111 1111 2 555] [ 222 2222 3 555 333 3333]]
说明reshape()方法不改变原数组的形状，而是会创建一个新数组。
注意：
数组变形方法包括：reshape()方法，shape属性和resize()方法，后两个会直接修改原数组对象。reshape()方法不改变原数组的形状，而是会创建一个新数组。
设置数组对象的shape属性或调用其resize()方法都会直接修改原数组对象。
s.shape = (4,3) print(s) print("*************") s.resize((3,4)) print(s)
输出：
[[ 1 555 111] [1111 2 555] [ 222 2222 3] [ 555 333 3333]] ************* [[ 1 555 111 1111] [ 2 555 222 2222] [ 3 555 333 3333]]
（三）数组合并
hstack函数：实现横向合并
vstack函数：实现纵向组合是利用 vstack 将数组纵向合并；
concatenate函数：可以实现数组的横向或纵向合并，参数 axis=1 时进行横向合并， axis=0 时进行纵向合并。
（四）数组分割
与数组合并相反， hsplit函数、 vsplit函数和split函数分别实现数组的横向、纵向和指定方向的分割。
三、数组的运算
（一）数组和标量间的运算
数组之所以很强大是因为不需要通过循环就可以完成批量计算。
a = [1,2,3] b = [] for i in a: b.append(i*i) print('b数组:',b) wy = np.array([1,2,3]) c = wy*2 print('c数组:',c)
输出：
b数组: [1, 4, 9] c数组: [2 4 6]
（二）ufunc函数
ufunc 函数全称为通用函数，是一种能够对数组中的所有元素进行操作的函数，对数组实施向量化操作（逐元素进行相同的操作）。对一个数组进行重复运算时，使用 ufunc 函数比使用 math 库中的函数效率要高很多，方便程序书写（替代了循环）。
1、常用的 ufunc 函数运算
常用的 ufunc 函数运算有四则运算、比较运算和逻辑运算。
（1）四则运算：
加（ + ）、减（ - ）、乘（ * ）、除（ / ）、幂（ ** ）。数组间的四则运算表示对每个数组中的元素分别进行四则运算，所以形状必须相同。
（2）比较运算：
< 、 > 、 == 、 >= 、 <= 、 != 。比较运算返回的结果是一个布尔数组，每个元素为每个数组对应元素的比较结果。
（3）逻辑运算：
np.any 函数表示逻辑 “or”， np.all 函数表示逻辑 “and”，运算结果返回布尔值。
数组的四则运算。
s = np.arange(2,10,2) print("s=",s) t = np.arange(1,5) print("t=",t) print("s+t =",s+t) # 逐元素相加 print("s/t =",s/t) # 逐元素相除 print("2**s=",2**s) # 逐元素求以2为底数的幂 print("|s-3t| =",np.abs(s-3*t)) # 逐元素求绝对值 print("s+2 =",s+2) # 最后三条语句都已经用到了广播机制
输出：
s= [2 4 6 8] t= [1 2 3 4] s+t = [ 3 6 9 12] s/t = [ 2. 2. 2. 2.] 2**s= [ 4 16 64 256] |s-3t| = [1 2 3 4] s+2 = [ 4 6 8 10]
数组的比较运算。
x = np.array([1,3,6]) y = np.array([2,3,4]) print('比较结果 (<) ：',x<y) print('比较结果 (>) ：',x>y) print('比较结果 (==) ：',x==y) print('比较结果 (>=) ：',x>=y) print('比较结果 (!=) ：',x!=y)
输出：
比较结果 (<) ： [ True False False] 比较结果 (>) ： [False False True] 比较结果 (==) ： [False True False] 比较结果 (>=) ： [False True True] 比较结果 (!=) ： [ True False True]
2、ufunc 函数的广播机制
广播（ broadcasting ）是指不同形状的数组之间执行算术运算的方式。需要遵循 4 个原则：
（1）让所有输入数组都向其中 shape 最长的数组看齐， shape 中不足的部分都通过在左边加 1 补齐。
（2）如果两个数组的形状在任何一个维度上都不匹配，那么数组的形状会沿着维度为 1 的维度进行扩展，以匹配另一个数组的形状。
（3）输出数组的 shape 是输入数组 shape 的各个轴上的最大值。
（4）如果两个数组的形状在任何一个维度上都不匹配，并且没有任何一个维度等于 1 ，则引发异常。
# 通用函数的广播机制：适用于形状不同但相容的数组间运算 a = np.array([[ 0, 0, 0], [10,10,10], [20,20,20], [30,30,30]]) b = np.array([1,2,3]) print(a + b) print("*************") print(a+2) # 标量2看成shape是(1,1)，然后应用广播机制
输出：
[[ 1 2 3] [11 12 13] [21 22 23] [31 32 33]] ************* [[ 2 2 2] [12 12 12] [22 22 22] [32 32 32]]
（三）条件逻辑运算
在 NumPy 中可以利用基本的逻辑运算就可以实现数组的条件运算。
arr1 = np.array([1,3,5,7]) arr2 = np.array([2,4,6,8]) cond = np.array([True,False,True,False]) result = [(x if c else y)for x,y,c in zip(arr1,arr2,cond)] result
输出：
[1, 4, 5, 8]
这种方法对大规模数组处理效率不高，也无法用于多维数组。 NumPy 提供的 where 方法可以克服这些问题。
np.where() 函数的用法
where()的用法：np.where(condition, x, y)，满足条件 (condition) ，输出 x ，不满足则输出 y 。
用法1：当满足 con 条件时，用数组 x 的值填充原数组元素，否则就用数组 y 的值填充原数组元素，此时 where 函数有三个参数。
days = np.arange(1,8) # 一周7天 con = days<6 # 判断是否工作日 x,y = 100,60 # 工作日每天100元，非工作日每天60元 np.where(con,x,y) # 一周的工资情况
输出：
array([100, 100, 100, 100, 100, 60, 60])
np.where([[True,False], [True,True]], [[1,2], [3,4]], [[9,8], [7,6]])
输出：
array([[1, 8], [3, 4]])
条件为 [[True,False], [True,False]]，分别对应最后输出结果的四个值，运算时第一个值从 [1,9] 中选，因为条件为 True，所以是选 1 。第二个值从 [2,8] 中选，因为条件为 False，所以选 8 ，后面以此类推。
用法2：常用于找到满足条件的元素的下标（例如寻找x数组中3的倍数的元素的下标），此时where()函数只有一个参数。
x = np.arange(15).reshape((3,5)) print(x) print() rows,cols = np.where(x%3==0) print(rows) print(cols) print("数组x中3的倍数的元素下标：") for row,col in zip(rows,cols): print("("+str(row)+","+str(col)+")",end=" ")
输出：
[[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] [0 0 1 1 2] [0 3 1 4 2] 数组x中3的倍数的元素下标： (0,0) (0,3) (1,1) (1,4) (2,2)
where()中若只有条件 (condition)，没有 x 和 y ，则输出满足条件元素的坐标。这里的坐标以 tuple 的形式给出，通常原数组有多少维，输出的 tuple 中就包含几个数组，分别对应符合条件元素的各维坐标。
w = np.array([2,5,6,3,10]) np.where(w>4)
输出：
(array([1, 2, 4], dtype=int64),)
四、布尔数组与花式索引
x = np.arange(5) x1 = x<=2 x1 # 不使用print函数输出，可以直接看到数组元素的类型
输出：
array([ True, True, True, False, False], dtype=bool)
布尔数组用于索引，可以筛选满足条件的元素，等价于np.extract()函数。
x = np.arange(15).reshape((3,5)) print(x) y = x[x%3==0] # 等价于y = np.extract(x%3==0,x) print("数组x中3的倍数构成的新数组y=",y)
注意布尔数组用于索引，筛选的结果是一维数组。
输出：
[[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] 数组x中3的倍数构成的新数组y= [ 0 3 6 9 12]
花式索引（fancy indexing），允许用一个索引数组作为另一个数组的索引以获取后者的子集。
# 设定随机数种子，这样每次运行的数据都相同 np.random.seed(666) z = np.random.randint(1,100,12).reshape((3,4)) print("二维随机整数数组z=：",z)
输出：
二维随机整数数组z=： [[ 3 46 31 63] [71 74 31 37] [62 92 95 52]]
索引数组的第1维表示行，第2维表示列。
注意：花式索引的结果子集的形状与索引数组的形状一致。
idx = [2,[1,3]] # 2表示要获取第3行，[1,3]表示要获取第2、4列 print("索引数组idx=",idx) print("用idx做索引检索数组z得到的子集z[idx]=",z[idx])
输出：
索引数组idx= [2, [1, 3]] 用idx做索引检索数组z得到的子集z[idx]= [92 52]
五、应用统计与排序函数
（一）常用统计函数
NumPy 中提供了很多用于统计分析的函数，常见的有 sum 、mean 、std 、var 、min 和 max 等。几乎所有的统计函数在针对二维数组的时候需要注意轴的概念。axis=0 时表示沿着纵轴进行计算，axis=1 时沿横轴进行计算。
np.random.seed(666) z = np.random.randint(1,100,12).reshape((3,4)) print("二维随机整数数组z =",z)
输出：
二维随机整数数组z = [[ 3 46 31 63] [71 74 31 37] [62 92 95 52]]
计算元素的和。
print("z的全部元素之和：",z.sum()) # z.sum()等价于np.sum(z) print("z的列元素之和：",z.sum(axis=0)) # z.sum(axis=0)等价于np.sum(z,axis=0) print("z的行元素之和：",z.sum(axis=1)) # z.sum(axis=1)等价于np.sum(z,axis=1)
输出：
z的全部元素之和： 657 z的列元素之和： [136 212 157 152] z的行元素之和： [143 213 301]
计算元素的均值。
print("z的全部元素均值：",np.mean(z)) print("z的列元素均值：",z.mean(axis=0)) print("z的行元素均值：",z.mean(axis=1))
输出：
z的全部元素均值： 54.75 z的列元素均值： [ 45.33333333 70.66666667 52.33333333 50.66666667] z的行元素均值： [ 35.75 53.25 75.25]
找出数组的最大值和它们各自所在的索引。
print("z的最大值：",z.max()) print("z的最大值所在的索引：",z.argmax()) print("z的每行最大值：",z.max(axis=1)) print("z的每行最大值所在的索引：",z.argmax(axis=1))
输出：
z的最大值： 95 z的最大值所在的索引： 10 z的每行最大值： [63 74 95] z的每行最大值所在的索引： [3 1 2]
统计满足条件的元素个数。
print("z大于90的元素个数:",np.sum((z>90))) # 统计大于90的元素个数 print("z介于60到80之间的元素个数:",np.sum((z>=60) & (z<=80))) # 统计介于60到80之间的元素个数
输出：
z大于90的元素个数: 2 z介于60到80之间的元素个数: 4
（二）数组排序
sort 函数对数据直接进行排序，调用改变原始数组，无返回值。数组排序，默认按升序。
格式：numpy.sort(a, axis, kind, order)
| 参数 | 使用说明 |
| a | 要排序的数组 |
| kind | 排序算法，默认为“quicksort” |
| order | 排序的字段名，可指定字段排序，默认为 None |
| axis | 使 得 sort 函 数 可 以 沿 着 指 定 轴 对 数 据 集 进 行 排序。 axis=1 为沿横轴排序； axis=0 为沿纵轴排序；axis=None, 将数组平坦化之后进行排序。 |
np.argsort 函数和 np.lexsort 函数根据一个或多个键值对数据集进行排序。
np.argsort()：返回的是数组值从小到大的索引值；
np.lexsort()：返回值是按照最后一个传入数据排序的结果。
使用 argsort 和 lexsort 函数，可以在给定一个或多个键时，得到一个由整数构成的索引数组，索引值表示数据在新的序列中的位置。
#数组排序,默认按升序 print("排序前数组z =",z) #默认按行排序，相当于axis=1 print("按行排序的结果：",np.sort(z)) print("按行排序结果的原索引：",np.argsort(z)) #按列排序 print("按列排序的结果：",np.sort(z,axis=0)) print("按列排序结果的原索引：",np.argsort(z,axis=0))
输出：
排序前数组z = [[ 3 46 31 63] [71 74 31 37] [62 92 95 52]] 按行排序的结果： [[ 3 31 46 63] [31 37 71 74] [52 62 92 95]] 按行排序结果的原索引： [[0 2 1 3] [2 3 0 1] [3 0 1 2]] 按列排序的结果： [[ 3 46 31 37] [62 74 31 52] [71 92 95 63]] 按列排序结果的原索引： [[0 0 0 1] [2 1 1 2] [1 2 2 0]]
使用 lexsort 排序。
a = np.array([7,2,1,4]) b = np.array([5,2,6,7]) c = np.array([5,2,4,6]) d = np.lexsort((a,b,c)) print('排序后：',list(zip(a[d],b[d],c[d])))
输出：
排序后： [(2, 2, 2), (1, 6, 4), (7, 5, 5), (4, 7, 6)]
#二维数组拉成一维后再排序,默认按行拉伸 r = z.flatten() print("z按行拉成的一维数组r =",r) print("拉伸后的数组r的排序结果:",np.sort(r)) #逆序 print("通过切片实现降序排列：",np.sort(r)[::-1]) #注意：不能写成np.sort(-r)，没有这种操作！ print("通过argsort函数实现降序排列：",r[np.argsort(-r)]) #注意此用法很常见：argsort()返回的索引数组用于花式索引
输出：
z按行拉成的一维数组r = [ 3 46 31 63 71 74 31 37 62 92 95 52] 拉伸后的数组r的排序结果: [ 3 31 31 37 46 52 62 63 71 74 92 95] 通过切片实现降序排列： [95 92 74 71 63 62 52 46 37 31 31 3] 通过argsort函数实现降序排列： [95 92 74 71 63 62 52 46 37 31 31 3]
注意np.sort(r)与r.sort()排序的区别：前者会产生新数组存放排序结果，而原数组不变 ；后者会直接改变原数组的元素顺序。
print("排序前的数组r=",r) print("用np.sort(r)排序后的结果：",np.sort(r)) print("排序后的数组r=",r) print("用r.sort()排序后的结果：",r.sort()) print("排序后的数组r=",r)
输出：
排序前的数组r= [ 3 31 31 37 46 52 62 63 71 74 92 95] 用np.sort(r)排序后的结果： [ 3 31 31 37 46 52 62 63 71 74 92 95] 排序后的数组r= [ 3 31 31 37 46 52 62 63 71 74 92 95] 用r.sort()排序后的结果： None 排序后的数组r= [ 3 31 31 37 46 52 62 63 71 74 92 95]
