【NumPy数值计算基础】NumPy数组的基本操作

目录


一、数组的索引和切片

(一)数组的索引

首先,导入 NumPy 库。

python 复制代码
import numpy as np

一维数组的索引与 Python 列表的索引用法相同。

python 复制代码
m = np.array([23,79,16,5,32])
print("m =",m)
print('m[1] =',m[1],'\t','m[-3] =',m[-3])

输出:

python 复制代码
m = [23 79 16  5 32]
m[1] = 79 	 m[-3] = 16

对于多维数组,它的每一个维度都有一个索引,各个维度的索引之间用逗号分隔。

python 复制代码
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])   # 虽然与上面等价,但更推荐上面的写法

输出:

python 复制代码
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 复制代码
# 一维数组的切片与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个开始、隔一个取一个、一直取到倒数第二个。

输出:

python 复制代码
m = [23 79 16  5 32]
m[::-1] = [32  5 16 79 23]
m[1:-1:2] = [79  5]

二维数组允许在每个维度上使用切片,相互间用逗号分隔。

python 复制代码
# 二维数组允许在每个维度上使用切片,相互间用逗号分隔
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])    # 单个冒号:出现在行的位置上,表示所有行

注意此处二维数组的冒号与前面一维数组***处冒号的区别:前者冒号是分隔符 ,后者表示所有行/列。

输出:

python 复制代码
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 列表的切片返回的却是副本,因此通过数组切片赋值将会修改原数组。

python 复制代码
# 通过数组切片赋值将会修改原数组
p = n[:,:]
print("获取n的全部元素后产生的数组p=",p)
# 通过切片赋值,会改变原来的数组
p[1:2,:] = 555
print("切片赋值后数组p=",p)
print("切片赋值后数组n=",n)

输出:

python 复制代码
获取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(对象)

python 复制代码
q = m.copy()  # 等价于q = np.copy(m)
print(q)  # 复制后的数组
q[-1] = 100
print(q)  # 修改了m的副本q的最后一个元素
print(m)  # m并没有改变

输出:

python 复制代码
[23 79 16  5 32]
[ 23  79  16   5 100]
[23 79 16  5 32]

二、数组的变换

(一)数组转置

python 复制代码
r = n.T  
print("转置后的数组r=",r)

输出:

python 复制代码
转置后的数组r= [[   1  555  111 1111]
 [   2  555  222 2222]
 [   3  555  333 3333]]

(二)数组重塑

对于定义好的数组,可以通过reshape()方法改变其数据维度。

参数名称格式: np.reshape(a, newshape, order='C')

参数名称 说明
a 需要处理的数据
newshape 新维度------整数或整数元组
python 复制代码
print("变形前数组r的形状:",r.shape)
s = r.reshape((2,6))    # 注意参数是一个元组
print("变形后数组r=",r)
print("变形后新数组s=",s)

输出:

python 复制代码
变形前数组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()方法都会直接修改原数组对象。

python 复制代码
s.shape = (4,3)
print(s)
print("*************")
s.resize((3,4))
print(s)

输出:

python 复制代码
[[   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函数分别实现数组的横向、纵向和指定方向的分割。

三、数组的运算

(一)数组和标量间的运算

数组之所以很强大是因为不需要通过循环就可以完成批量计算。

python 复制代码
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)

输出:

python 复制代码
b数组: [1, 4, 9]
c数组: [2 4 6]

(二)ufunc函数

ufunc 函数全称为通用函数,是一种能够对数组中的所有元素进行操作的函数,对数组实施向量化操作(逐元素进行相同的操作)。对一个数组进行重复运算时,使用 ufunc 函数比使用 math 库中的函数效率要高很多,方便程序书写(替代了循环)。

1、常用的 ufunc 函数运算

常用的 ufunc 函数运算有四则运算、比较运算和逻辑运算。

(1)四则运算:

加( + )、减( - )、乘( * )、除( / )、幂( ** )。数组间的四则运算表示对每个数组中的元素分别进行四则运算,所以形状必须相同。

(2)比较运算:

< 、 > 、 == 、 >= 、 <= 、 != 。比较运算返回的结果是一个布尔数组,每个元素为每个数组对应元素的比较结果。

(3)逻辑运算:

np.any 函数表示逻辑 "or", np.all 函数表示逻辑 "and",运算结果返回布尔值。

数组的四则运算。

python 复制代码
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)    # 最后三条语句都已经用到了广播机制

输出:

python 复制代码
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]

数组的比较运算。

python 复制代码
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)

输出:

python 复制代码
比较结果 (<) : [ 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 ,则引发异常。

python 复制代码
# 通用函数的广播机制:适用于形状不同但相容的数组间运算
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),然后应用广播机制

输出:

python 复制代码
[[ 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 中可以利用基本的逻辑运算就可以实现数组的条件运算。

python 复制代码
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

输出:

python 复制代码
[1, 4, 5, 8]

这种方法对大规模数组处理效率不高,也无法用于多维数组。 NumPy 提供的 where 方法可以克服这些问题。

np.where() 函数的用法

where()的用法:np.where(condition, x, y),满足条件 (condition) ,输出 x ,不满足则输出 y 。

用法1:当满足 con 条件时,用数组 x 的值填充原数组元素,否则就用数组 y 的值填充原数组元素,此时 where 函数有三个参数。

python 复制代码
days = np.arange(1,8)   # 一周7天
con = days<6    # 判断是否工作日
x,y = 100,60    # 工作日每天100元,非工作日每天60元
np.where(con,x,y)    # 一周的工资情况

输出:

python 复制代码
array([100, 100, 100, 100, 100,  60,  60])
python 复制代码
np.where([[True,False], [True,True]], [[1,2], [3,4]], [[9,8], [7,6]])

输出:

python 复制代码
array([[1, 8],
       [3, 4]])

条件为 [[True,False], [True,False]],分别对应最后输出结果的四个值,运算时第一个值从 [1,9] 中选,因为条件为 True,所以是选 1 。第二个值从 [2,8] 中选,因为条件为 False,所以选 8 ,后面以此类推。

用法2 :常用于找到满足条件的元素的下标(例如寻找x数组中3的倍数的元素的下标),此时where()函数只有一个参数。

python 复制代码
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=" ")

输出:

python 复制代码
[[ 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 中就包含几个数组,分别对应符合条件元素的各维坐标。

python 复制代码
w = np.array([2,5,6,3,10])
np.where(w>4)

输出:

python 复制代码
(array([1, 2, 4], dtype=int64),)

四、布尔数组与花式索引

python 复制代码
x = np.arange(5)
x1 = x<=2
x1  # 不使用print函数输出,可以直接看到数组元素的类型

输出:

python 复制代码
array([ True,  True,  True, False, False], dtype=bool)

布尔数组用于索引,可以筛选满足条件的元素,等价于np.extract()函数。

python 复制代码
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)

注意布尔数组用于索引,筛选的结果是一维数组。

输出:

python 复制代码
[[ 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),允许用一个索引数组作为另一个数组的索引以获取后者的子集。

python 复制代码
# 设定随机数种子,这样每次运行的数据都相同
np.random.seed(666)
z = np.random.randint(1,100,12).reshape((3,4))
print("二维随机整数数组z=:",z)

输出:

python 复制代码
二维随机整数数组z=: [[ 3 46 31 63]
 [71 74 31 37]
 [62 92 95 52]]

索引数组的第1维表示行,第2维表示列。

注意:花式索引的结果子集的形状与索引数组的形状一致。

python 复制代码
idx = [2,[1,3]]   # 2表示要获取第3行,[1,3]表示要获取第2、4列
print("索引数组idx=",idx)
print("用idx做索引检索数组z得到的子集z[idx]=",z[idx]) 

输出:

python 复制代码
索引数组idx= [2, [1, 3]]
用idx做索引检索数组z得到的子集z[idx]= [92 52]

五、应用统计与排序函数

(一)常用统计函数

NumPy 中提供了很多用于统计分析的函数,常见的有 sum 、mean 、std 、var 、min 和 max 等。几乎所有的统计函数在针对二维数组的时候需要注意轴的概念。axis=0 时表示沿着纵轴进行计算,axis=1 时沿横轴进行计算。

python 复制代码
np.random.seed(666)
z = np.random.randint(1,100,12).reshape((3,4))
print("二维随机整数数组z =",z)

输出:

python 复制代码
二维随机整数数组z = [[ 3 46 31 63]
 [71 74 31 37]
 [62 92 95 52]]

计算元素的和。

python 复制代码
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)

输出:

python 复制代码
z的全部元素之和: 657
z的列元素之和: [136 212 157 152]
z的行元素之和: [143 213 301]

计算元素的均值。

python 复制代码
print("z的全部元素均值:",np.mean(z))
print("z的列元素均值:",z.mean(axis=0))
print("z的行元素均值:",z.mean(axis=1))

输出:

python 复制代码
z的全部元素均值: 54.75
z的列元素均值: [ 45.33333333  70.66666667  52.33333333  50.66666667]
z的行元素均值: [ 35.75  53.25  75.25]

找出数组的最大值和它们各自所在的索引。

python 复制代码
print("z的最大值:",z.max())
print("z的最大值所在的索引:",z.argmax())
print("z的每行最大值:",z.max(axis=1))
print("z的每行最大值所在的索引:",z.argmax(axis=1))

输出:

python 复制代码
z的最大值: 95
z的最大值所在的索引: 10
z的每行最大值: [63 74 95]
z的每行最大值所在的索引: [3 1 2]

统计满足条件的元素个数。

python 复制代码
print("z大于90的元素个数:",np.sum((z>90)))    # 统计大于90的元素个数
print("z介于60到80之间的元素个数:",np.sum((z>=60) & (z<=80)))    # 统计介于60到80之间的元素个数

输出:

python 复制代码
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 函数,可以在给定一个或多个键时,得到一个由整数构成的索引数组,索引值表示数据在新的序列中的位置。

python 复制代码
#数组排序,默认按升序
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))

输出:

python 复制代码
排序前数组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 排序。

python 复制代码
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])))

输出:

python 复制代码
排序后: [(2, 2, 2), (1, 6, 4), (7, 5, 5), (4, 7, 6)]
python 复制代码
#二维数组拉成一维后再排序,默认按行拉伸
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()返回的索引数组用于花式索引

输出:

python 复制代码
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()排序的区别:前者会产生新数组存放排序结果,而原数组不变 ;后者会直接改变原数组的元素顺序。

python 复制代码
print("排序前的数组r=",r)
print("用np.sort(r)排序后的结果:",np.sort(r))
print("排序后的数组r=",r)
print("用r.sort()排序后的结果:",r.sort())
print("排序后的数组r=",r)

输出:

python 复制代码
排序前的数组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]
相关推荐
Lizhihao_几秒前
JAVA-队列
java·开发语言
denghai邓海几秒前
红黑树删除之向上调整
python·b+树
远望清一色19 分钟前
基于MATLAB边缘检测博文
开发语言·算法·matlab
封步宇AIGC26 分钟前
量化交易系统开发-实时行情自动化交易-3.4.1.2.A股交易数据
人工智能·python·机器学习·数据挖掘
何曾参静谧27 分钟前
「Py」Python基础篇 之 Python都可以做哪些自动化?
开发语言·python·自动化
Prejudices31 分钟前
C++如何调用Python脚本
开发语言·c++·python
我狠狠地刷刷刷刷刷44 分钟前
中文分词模拟器
开发语言·python·算法
wyh要好好学习1 小时前
C# WPF 记录DataGrid的表头顺序,下次打开界面时应用到表格中
开发语言·c#·wpf
AitTech1 小时前
C#实现:电脑系统信息的全面获取与监控
开发语言·c#
qing_0406031 小时前
C++——多态
开发语言·c++·多态