numpy数组中一些常见的操作以及用法举例(实时更新)

这篇文章是为了解读一些 常用的numpy数组操作，同时也是为了加深自己对numpy的理解。如果后续碰到比较实用的操作，也会同步至这篇文章。

不得不说，numpy的操作实在是太多了，好的方法是边学边用，随时用随时查。如果想要全面学习，或者只是想查询某个函数的功能，可以访问官网，官网有一个非常全面的教程方法，是一个学习numpy的绝佳去处。

1. 数组与标量的计算

运算符操作	含义
a+1	a的所有元素加1
a - 1	a的所有元素减1
a*3	a的所有元素乘以3
1/a	1除以所有a中的元素
1//a	1除以所有a中的元素，并 取整
a**0.5	a的所有元素取0.5次方

代码举例：

import numpy as np

a = np.array([1,2,3,4]).reshape(2,2)

print(a+2) #加法
'''
[[3 4]
 [5 6]]
'''
print(a*3) #乘法
'''
[[ 3  6]
 [ 9 12]]
'''
print(1//a) #整除
'''
[[1 0]
 [0 0]]
'''
print(a**0.5) #开根号
'''
[[1.         1.41421356]
 [1.73205081 2.        ]]
'''

2. 两个数组之间的数学计算

运算符操作	含义
a+b	a,b对应元素相加
a-b	a,b对应元素相减
a*b	a,b对应元素相乘
a/b	a,b对应元素相除
a//b	a,b对应元素相整除
np.multiply(a, b)	对应元素相乘，同*号

代码举例：

import numpy as np

a = np.array([1.2,2.6,-3.9,4.5]).reshape(2,2)
b = np.array([-2.6,3.6,2.8,13.6]).reshape(2,2)

print(a*b)
'''
[[ -3.12   9.36]
 [-10.92  61.2 ]]
'''
print(a//b)
'''
[[-1.  0.]
 [-2.  0.]]
'''

3. 数组一元函数的数学操作

函数	含义
np.sqrt(array)	平方根函数
np.exp(array)	e^array[i]的数组
np.abs/fabs(array)	计算绝对值
np.square(array)	计算各元素的平方，等于array**2
np.log/log10/log2(array)	计算各元素的各种对数
np.sign(array)	计算各元素正负号
np.isnan(array)	NaN(not a number)：不等于任何浮点数
np.isinf(array)	inf：比任何浮点数都大
np.cos/cosh/sin/sinh/tan/tanh(array)	三角函数
np.modf(array)	将array中值得整数和小数分离，作两个数组返回
np.ceil(array)	向上取整,也就是取比这个数大的整数
np.floor(array)	向下取整,也就是取比这个数小的整数
np.rint(array)	四舍五入，但是当整数部分以0结束时，小数以5结尾时，向下取整，10.5->10。
np.round(array)	四舍五入,但是当整数部分以0结束时，小数为5时，向0取整，10.5->10。
np.trunc(array)	向0取整
np.cos(array)	正弦值
np.sin(array)	余弦值
np.tan(array)	正切值
np.sum(array)	求和
np.cumsum(array)	求前缀和(当前值等于当前元素与前面所有元素相加)
np.mean(array)	求平均数
np.std(array)	求标准差
np.var(array)	求方差
np.min(array)	求最小值
np.max(array)	求最大值
np.argmin(array)	求最小值索引
np.argmax(array)	求最大值索引
np.media(array)	奇数取中间数，偶数个则取中间两个数的平均值

代码举例：

import numpy as np

a = np.array([1.2,2.6,-3.9,4.5]).reshape(2,2)

print(np.rint(a)) #四舍五入
'''
[[ 1.  3.]
 [-4.  4.]]
'''
print(np.abs(a)) #绝对值
'''
[[1.2 2.6]
 [3.9 4.5]]
'''
print(np.sin(a)) #sin值
'''
[[ 0.93203909  0.51550137]
 [ 0.68776616 -0.97753012]]
'''

print(np.sum(a)) #求和4.4

print(np.cumsum(a)) # 当前数与之前的所有数之和：[ 1.2  3.8 -0.1  4.4]

print(np.argmin(a)) #最小值索引：2

4. 数组二元函数的数学操作

函数	含义
np.add(array1,array2)	元素级加法
np.subtract(array1,array2)	元素级减法
np.multiply(array1,array2)	元素级乘法
np.divide(array1,array2)	元素级除法 array1./array2
np.power(array1,array2)	元素级指数 array1.^array2
np.maximum/minimum(array1,aray2)	元素级最大值
np.fmax/fmin(array1,array2)	元素级最大值，忽略NaN
np.mod(array1,array2)	元素级求模
np.copysign(array1,array2)	将第二个数组中值得符号复制给第一个数组中值
np.greater/greater_equal/less/less_equal/equal/not_equal (array1,array2)	元素级比较运算，产生布尔数组
np.logical_end/logical_or/logic_xor(array1,array2)	元素级的真值逻辑运算
np.dot(a,b)或者a@b	内积
np.cross(a,b)	叉乘

代码举例：

import numpy as np

a = np.array([1.2,2.6,-3.9,4.5]).reshape(2,2)
b = np.array([-2.6,3.6,2.8,13.6]).reshape(2,2)

print(np.add(a,b)) #元素的加法
'''
[[-1.4  6.2]
 [-1.1 18.1]]
'''
print(np.multiply(a,b)) #元素乘法
'''
[[ -3.12   9.36]
 [-10.92  61.2 ]]
'''
print(np.maximum(a,b)) #a,b之间的最大元素
'''
[[ 1.2  3.6]
 [ 2.8 13.6]]
'''
print(np.copysign(a,b))#将b的符号给a
'''
[[-1.2  2.6]
 [ 3.9  4.5]]
'''

5. 数组的常用属性

属性	含义
dtype	数组元素的数据类型
size	数组元素的个数
ndim	数组的维数
shape	数组的维度大小（以元组形式）
T	数组的转置

代码举例：

import numpy as np

a = np.array([1,2,3,4]).reshape(2,2)
print(a.dtype) #类型：int64
print(a.ndim)#维度：2
print(a.shape)#数组大小(2,2)
print(a.size)#数组元素个数：4
print(a.T) #转置
'''
[[1 3]
 [2 4]]
'''

6. 数组的常用方法

注意这里是方法，而不是函数。

方法	含义
reshape()	不改变数据的条件下修改形状
flat	不是方法，它是数组元素迭代器
flatten()	返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel()	返回展开数组

其中flatten和ravel都可以选定展开的顺序：order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。

import numpy as np

a = np.arange(4).reshape(2, 2)

for element in a.flat:
    print(element,end=", ") # 0, 1, 2, 3,
print('\n')
print (a.flatten()) #[0 1 2 3]

print (a.ravel(order = 'F')) #[0 2 1 3]

7. 随机操作

numpy.random 模块对 Python 内置的 random 进行了补充，增加了一些用于高效生成多种概率分布的样本值的函数，如正态分布、泊松分布等。由于暂时还没有涉及到使用正态分布等内容的应用，所以这部分只是介绍一些简单实用的随机操作。

操作	意义
random.rand()	根据给定维度生成[0,1)之间的数据
random.randn()	根据给定维度（不给维度时为单个数），产生符合标准正态分布的随机数
random.normal()	可定义均值和标准差的正态分布的随机数
random.randint()	返回给定维度的随机整数
random.random()、random.random_sample()	返回给定维度的[0,1)之间的随机数
random.choice()	从给定的一维数组中生成随机数
numpy.random.uniform(low=0.0, high=1.0, size=None)	[low,high)随机取值

代码举例：

import numpy as np

print(np.random.rand(3, 3)) #3 * 3维度的[0,1)的随机数
print(np.random.random((3, 3))) #3 * 3维度的[0,1)的随机数

print(np.random.randint(0, 2, size=(3, 3))) #3*3维度的[0，2]的随机整数

print(np.random.choice(['a', 'b', 'c'], p=[0.5, 0.3, 0.2])) #p的概率值和必须为1

8. 拼接数组——concatenate、hstack、vstack和append

拼接数组的方法有：concatenate、hstack、vstack和append。举例说明如下：

import numpy as np

a = np.arange(4).reshape(2,2)
b = np.array([[5,6],[7,8]])

c = np.concatenate((a,b),axis=1)#指定axis=1拼接，默认是axis=0拼接
'''
[[0 1 5 6]
 [2 3 7 8]]
'''
c = np.concatenate((a,b))#默认axis=0
'''
[[0 1]
 [2 3]
 [5 6]
 [7 8]]
'''
c=np.hstack([a,b])#横向拼接
'''
[[0 1 5 6]
 [2 3 7 8]]
'''
c=np.vstack([a,b])#纵向拼接
'''
[[0 1]
 [2 3]
 [5 6]
 [7 8]]
'''
b = np.array([[1,1],[1,1]])
c = np.append(b,a)#没有指定axis，则默认展成一维，如果有axis则如下所示。
'''
[1 1 1 1 0 1 2 3 4 5 6 7]
'''

append设置了axis的情况。

import numpy as np
a=[1,2,3]
b=[4,5]
c=[[6,7],[8,9]]
d=[[10,11],[12,13]]
print('在一维数组a后添加values,结果如下：{0}'.format(np.append(a,b,axis=0)))
print('沿二维数组c的行方向添加values结果如下：{0}'.format(np.append(c,d,axis=0)))
print('沿二维数组c的列方向添加values结果如下：{0}'.format(np.append(c,d,axis=1)))
#print('使用了axis，若arr和values的形状不同，则报错：'.format(np.append(a,c,axis=0)))

输出：

在一维数组a后添加values,结果如下：[1 2 3 4 5]
沿二维数组c的行方向添加values结果如下：[[ 6  7]
 [ 8  9]
 [10 11]
 [12 13]]
沿二维数组c的列方向添加values结果如下：[[ 6  7 10 11]
 [ 8  9 12 13]]

9. 切分数组——split

import numpy as np

a = np.arange(9)
print(np.split(a,[3,6]))#按照指定切分点对原数组进行切分
'''
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
'''

10. 插入和删除——insert和delete

import numpy as np

a = np.arange(8).reshape(2,4)

c = np.delete(a,[0,2],axis=1)#axis = 1上进行删除,0,2列
'''
[[1 3]
 [5 7]]
'''
c = np.insert(a,1,5,axis=1)#axis=1上进行插入指定数值，第1列插入数字5
'''
[[0 5 1 2 3]
 [4 5 5 6 7]]
'''

11. 数组扩展——tile和repeat

numpy提供了tile函数和repeat方法，可以很轻松的将数组进行扩展。

import numpy as np

a = np.array([1,2,3]) #注意：这里的a只有一个维度(3,)
print(np.tile(a,[3,1])) #复制成3行1列
'''
[[1 2 3]
 [1 2 3]
 [1 2 3]]
'''
print(a.repeat(3,axis=0))#在axis=0上面复制3行
'''
[1 1 1 2 2 2 3 3 3]
'''
a=np.array([[1,2,3]]) #注意：这里的a是2维，(1, 3)
print(np.tile(a,[3,1])) #复制成3行1列
'''
[[1 2 3]
 [1 2 3]
 [1 2 3]]
'''
print(a.repeat(3,axis=0))#在axis=0上面复制3行
'''
[[1 2 3]
 [1 2 3]
 [1 2 3]]
'''

12. 其它方法实时更新

（1）裁剪方法——np.clip

np.clip是一个截取函数，该函数的作用是将数组a中的所有数限定到范围a_min和a_max中，超出范围的值取最大值或者最小值。

np.clip(a, a_min, a_max, out=None):

• a：输入矩阵；
• a_min：被限定的最小值，所有比a_min小的数都会强制变为a_min；
• a_max：被限定的最大值，所有比a_max大的数都会强制变为a_max；
• out：可以指定输出矩阵的对象，shape与a相同

• 举例

import numpy as np

x= np.arange(12)
print(type(x))
print('clip：',np.clip(x,3,8))

输出：

x： [ 0  1  2  3  4  5  6  7  8  9 10 11]
clip： [3 3 3 3 4 5 6 7 8 8 8 8]

（2）条件元素查找——np.where

np.where() 有两种用法：

• 第一种：满足条件输出x，不满足输出y：np.where(condition, x, y)
• 第二种：输出满足条件的元素坐标，坐标以tuple的形式给出：np.where(condition)

• 第一种举例：

import numpy as np

x = np.arange(6) # [0 1 2 3 4 5]
y = np.where(x>3, 2, -2)
print(y) #输出：[-2 -2 -2 -2  2  2]

#对应元素比较
x = np.where([[True,False], [True,True]],    # 官网上的例子
			 [[1,2], [3,4]],
             [[9,8], [7,6]])

print(x)

'''
[[1 8]
 [3 4]]
'''

• 第二种举例：

import numpy as np

x = np.array([2,4,6,8,10])
print(np.where(x > 5)) #返回大于5的索引，(array([2, 3, 4]),)

print(x[np.where(x > 5)] )# 根据索引取值，[6,8,10]

（3）nan值判断——np.isnan

import numpy as np

test_data = np.arange(6).reshape(2,3)
data = test_data.astype(np.float) #必须是float类型
data[1,1] = np.nan #或者np.NAN
print('==================nan值判断=====================')
print(np.isnan(data))

print('==================删除nan所在行或者列=====================')
# 如果选取列，则取np.where(np.isnan(data))[1]
lines = np.where(np.isnan(data))[0]  #np.where返回行[0]和列[1]的索引
print(f'第 {lines} 行有nan值' )
# 删除含有 NAN 值的行, 如果删除列 则 axis = 1
new_data = np.delete(data,lines,axis=0)# 有重复的也没关系，只会删除一次

print(data)#原值不受影响
print(new_data)

• 输出

==================nan值判断=====================
[[False False False]
 [False  True False]]
==================删除nan所在行或者列=====================
第 [1] 行有nan值
[[ 0.  1.  2.]
 [ 3. nan  5.]]
[[0. 1. 2.]]

（4）数组拼接——np.concatenate

np.concatenate((a1,a2,…), axis=0)函数，能够一次完成多个数组的拼接。其中a1,a2,…是数组类型的参数

import numpy as np

print('======================axis=0================================')
a=np.array([1,2,3])
b=np.array([11,22,33])
c=np.array([44,55,66])
d = np.concatenate((a,b,c),axis=0)  # 默认情况下，axis=0可以不写

print(d)

print('======================axis=1================================')

a=np.array([[1,2,3],[4,5,6]])
b=np.array([[11,21,31],[7,8,9]])
c = np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接
print(c)

输出：

======================axis=0================================
[ 1  2  3 11 22 33 44 55 66]
======================axis=1================================
[[ 1  2  3 11 21 31]
 [ 4  5  6  7  8  9]]

（5）随机打乱顺序——np.random.permutation

import numpy as np

a = np.random.permutation([1, 2, 3, 4, 5, 6])
print(type(a), a)

输出：

<class 'numpy.ndarray'> [5 3 2 4 1 6]

（6）返回非0值的索引——np.nonzero

import numpy as np

a = np.array([[1,0,3], [0,5,6]])

c = np.nonzero(a)
print(c)

输出：

(array([0, 0, 1, 1]), array([0, 2, 1, 2]))#分别为第一维度和第二维度

（7）根据索引提取元素——np.extract

import numpy as np

arr = np.arange(10)
condition = np.mod(arr, 3)==0

print(condition)

# 根据索引提取元素
s = np.extract(condition, arr)
print(s)

输出：

[ True False False  True False False  True False False  True]
[0 3 6 9]

（8）元素集合操作——并集、交集、差集等

差集 setdiff1d()，异或集 setxor1d()，并集 union1d()，交集 intersect1d()，以及判断是否存在的 in1d() 和 isin()

import numpy as np

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
b = np.array([3,4,7,6,7,8,11,12,14])

print('并集: ', np.union1d(a,b))
print('交集: ', np.intersect1d(a,b))
print('差集: ', np.setdiff1d(a,b))
print('异或集: ', np.setxor1d(a,b))

c = np.array([1,2,3])
print('是否存在: ', np.in1d(c,a))
print('是否存在: ', np.isin(c,a))

输出：

并集:  [ 1  2  3  4  5  6  7  8  9 11 12 14]
交集:  [3 4 6 7 8]
差集:  [1 2 5 9]
异或集:  [ 1  2  5  9 11 12 14]
是否存在:  [ True  True  True]
是否存在:  [ True  True  True]

（9）any与all

numpy版的any与all。(python自身也有all和any操作)

import numpy as np

a = np.ones([2,3])
a[0,0] = 0
print(np.all(a)) #False
print(np.any(a)) #True

（10）numpy、list与torch的转换

a=torch.ones([1,2,3])
#torch ->numpy
b=a.numpy()   
# numpy->list
d=a.tolist() #与list(a)的结果不同，list(a)的内部元素任然为tensor
#从numpy -> torch     
c=torch.from_numpy(b)

（11）矩阵元素翻转——np.flip(a, axis = None)

表示矩阵翻转，其中axis表示翻转的轴。

• axis=0：上下翻转，意味着把行看成整体，行的顺序发生颠倒，每一行的元素不发生改变
• axis=1：左右翻转，意味着把列看成整体，列的顺序发生颠倒，每一列的元素不发生改变