首页 > > 网络编程 > 其它 >

NumPy基础操作（2）

2019-07-24 09:14:38来源：博客园阅读 ()

NumPy基础操作（2）

（注：记得在文件开头导入import numpy as np）

写在前面

　　本篇博文主要讲解了普通转置array.T、轴对换array.swapaxes()、高维转置array.transpose()、绝对值函数np.abs()、np.maximum()、np.argmax()、np.argmin()等函数的调用方法和注意事项

转置和轴对换

array.T

arr = np.arange(16).reshape((4,4))
print(arr)
print("************")
print(arr.T)    #.T进行数组的转置
#输出结果
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
************
[[ 0  4  8 12]
 [ 1  5  9 13]
 [ 2  6 10 14]
 [ 3  7 11 15]]
'''

这里可以看到arr.T的转置直接以正对角线为对称轴进行数组转置，这里有一点需要注意arr.T是对源数据进行复制后进行的操作，因此执行操作后不会改变源数据。

array.swapaxes()

arr = np.arange(9).reshape((3,3))
print(arr.swapaxes(0,1))    #第一个维度与第二个维度数据进行交换，也就是第i行与第i列数据进行交换
print("************")
print(arr)      #swapaxes也是在复制原数组的基础上进行的操作，不会更改原数组
#输出结果
'''
[[0 3 6]
 [1 4 7]
 [2 5 8]]
************
[[0 1 2]
 [3 4 5]
 [6 7 8]]
 '''

array.transpose()

arr = np.arange(16).reshape((2, 2, 4))
print(arr)
print("************")
print(arr.transpose((2, 1, 0)))  #三维数组，有三个维度，将第三个维度变为第二个维度，第二维度变成第一维度，第一维度变为第三维度
#输出结果
'''
[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]
************
[[[ 0  8]
  [ 4 12]]

 [[ 1  9]
  [ 5 13]]

 [[ 2 10]
  [ 6 14]]

 [[ 3 11]
  [ 7 15]]]
'''
#从输出结果可以看出原来第三维有四个元素，现在第一维变成第三维，第一维度变成四个元素，其他维度以此类推

NumPy常用函数

常用函数简单说明（包含的有些冗杂了，不必全记得）

函数	说明
abs、fabs	计算整数、浮点数或复数的绝对值。对于非复数值，使用fabs可以更快计算
sqrt	计算数组各元素的平方根。
square	计算数组各元素的平方。
exp	计算各元素的指数e^x
log、log10、log2、log1p	分别计算自然对数（底数为e）、底数为10的log、底数为2的log以及底数为e的log(1+x)。
sign	计算数组各元素的正负号：1（正数）、0（零）、-1（负数）。
ceil	取数组各元素大于等于该值的最小整数，相当于对各元素向上取整
floor	取数组各元素小于等于该值的最大整数，相当于对各元素向下取整
rint	将各元素值四舍五入到最接近的整数，保留dtype
modf	将数组的小数和整数部分以两个独立数组的形式返回
isnan	返回一个表示“哪些值是NaN”的布尔型数组
isfinite、isinf	返回一个表示“哪些元素值是有穷的”、“哪些元素值是无穷的”布尔型数组
cos、sin、tan	返回分别一个数组各元素的余弦、正弦和正切数组
add	将数组中对应元素相加
subtract	从第一个数组中减去第二个数组的元素
multiply	数组元素相乘
divide、floor_divide	数组的除法、忽略余数的除法
power	对第一个数组中的元素A和第二个数组中相同位置的元素B计算A^B后，放到对应位置上
maximum、fmax	元素级的最大值计算。fmax将忽略NaN
minimum、fmin	元素级的最小值计算。fmin将忽略NaN
mod	元素级的求模运算
copysign	将第二个数组中的值的符号复制给第一个数组中的值
greater、greater_equal、less、less_equal、equal、not_equal	执行元素级的比较运算，返回布尔型的数组。对应运算符＞、≥、＜、≤、==、！=
logical_and、logical_or、logical_xor	执行元素级的真值逻辑运算。对应运算符&、\|、^（异或）
np.where(cond, xarr, yarr)	x if condition else y的矢量化，当cond中的值为True时选取xarr的值，否则选yarr的值
array.mean()	对数组中全部元素或者某轴向求算数平均。用axis指定轴向
array.sum()	对数组中全部元素或者某轴向求算数平均。用axis指定轴向
array.std()、array.var()	对数组中全部元素求标准差和方差
array.min()、array.max()	求数组中元素的最小值和最大值
array.argmin() array.argmax()	返回元素中最小值和最大值的索引号
array.cumsum()、array.cumprod()	计算数组中元素的累计和、累计积
bools_arr.all()、bools_arr.any()	检查布尔型数组中是否全是True或者至少有一个是True
array.sort()	对数组进行从小到大排序
np.unique(x)、np.intersect1d(x,y)	计算x中的唯一元素，并返回有序结果、计算x和y中的交集，并返回有序结果
np.union1d(x,y)	计算x和y的并集，并返回有序结果
np.in1d(x,y)	返回一个表示“x的元素是否包含于y”的布尔型数组
np.setdiff1d(x,y)	两个集合的差，即元素在x中但不在y中

部分函数使用操作

np.abs()

 1 arr = np.random.randn(9).reshape((3,3))
 2 print(arr)
 3 print("************")
 4 arr_abs = np.abs(arr)
 5 print(arr_abs)
 6 #输出结果
 7 '''
 8 [[-0.58979776  0.01673949  1.22808794]
 9  [-2.44004574 - 0.36391562 - 1.68938497]
10  [0.25851057 - 0.05289508 - 1.1986467]]
11 ** ** ** ** ** **
12 [[0.58979776 0.01673949 1.22808794]
13  [2.44004574 0.36391562 1.68938497]
14  [0.25851057 0.05289508 1.1986467 ]]
15 '''

np.sqrt()

 1 arr = np.random.randn(9).reshape((3,3))
 2 print(arr)
 3 print("************")
 4 arr_abs = np.abs(arr)   #因为随机生成的复数没有平方根，所以这里把它正值化
 5 arr_sqrt = np.sqrt(arr_abs)
 6 print(arr_sqrt)
 7 #输出结果
 8 '''
 9 [[ 1.24656464  0.46394912  0.05438404]
10  [ 0.81477287 -1.38440578 -1.11762692]
11  [-0.70715997  1.72679159 -0.95080044]]
12 ************
13 [[1.11649659 0.68113811 0.23320385]
14  [0.9026477  1.17660774 1.05717876]
15  [0.84092804 1.31407442 0.97508997]]
16 '''

np.exp()

 1 arr = np.arange(4).reshape((2, 2))
 2 print(arr)
 3 print("************")
 4 arr_exp = np.exp(arr)
 5 print(arr_exp)
 6 #输出结果
 7 '''
 8 [[0 1]
 9  [2 3]]
10 ************
11 [[ 1.          2.71828183]
12  [ 7.3890561  20.08553692]]
13 '''

np.log1p()

 1 arr = np.arange(1, 5).reshape((2, 2))
 2 print(arr)
 3 print("************")
 4 arr_log1p = np.log1p(arr)   #log1p(x) := log(1+x)（自然对数）,元素级操作
 5 print(arr_log1p)
 6 #输出结果
 7 '''
 8 [[1 2]
 9  [3 4]]
10 ************
11 [[0.69314718 1.09861229]
12  [1.38629436 1.60943791]]
13 '''

　　　log1p()函数的作用主要是数据平滑处理，处理当计算数组过小时计算浮点精度损失的情况。（若想进一步了解log1p()函数的相关计算原理请参看这篇博文：https://blog.csdn.net/liyuanbhu/article/details/8544644）

np.rint()

 1 arr = np.random.randn(4).reshape((2, 2))
 2 print(arr)
 3 print("************")
 4 arr_rint = np.rint(arr)     #将各元素值四舍五入转换为最接近的整数
 5 print(arr_rint)
 6 #输出结果
 7 '''
 8 [[-0.86550191  1.64419254]
 9  [-0.51164907  0.06845004]]
10 ************
11 [[-1.  2.]
12  [-1.  0.]]

np.sign()

 1 arr = np.random.randn(4).reshape((2, 2))
 2 print(arr)
 3 print("************")
 4 arr_sign = np.sign(arr)     #计算各元素值的符号：正为1，负为-1，零为0
 5 print(arr_sign)
 6 #输出结果
 7 '''
 8 [[-0.21646709  0.40155285]
 9  [ 0.72099109 -0.32066459]]
10 ************
11 [[-1.  1.]
12  [ 1. -1.]]
13 '''

np.modf()

 1 arr = (np.random.randn(4).reshape((2, 2))) * 5
 2 print(arr)
 3 print("************")
 4 arr_modf = np.modf(arr)     #分别返回各元素值的整数部分与小数部分
 5 print(arr_modf)
 6 #输出结果
 7 '''
 8 [[-1.31916494  8.26473292]
 9  [ 2.20634408 -0.14092464]]
10 ************
11 (array([[-0.31916494,  0.26473292],
12        [ 0.20634408, -0.14092464]]), 
13        array([[-1.,  8.],
14               [ 2., -0.]]))     
15 '''

np.add()

 1 arr1 = np.arange(4).reshape((2, 2))
 2 arr2 = np.arange(4).reshape((2, 2))
 3 print(arr1)
 4 print(arr2)
 5 print("************")
 6 arr_add = np.add(arr1, arr2)     #各元素值对应相加
 7 print(arr_add)
 8 #输出结果
 9 '''
10 [[0 1]
11  [2 3]]
12 [[0 1]
13  [2 3]]
14 ************
15 [[0 2]
16  [4 6]]
17 '''

　　　np.add()函数只能进行二元操作，输入操作数只能是两个

np.subtract()

 1 arr1 = np.arange(4).reshape((2, 2))
 2 arr2 = np.arange(4).reshape((2, 2)) * 2
 3 print(arr1)
 4 print(arr2)
 5 print("************")
 6 arr_subtract = np.subtract(arr1, arr2)     #各元素值对应相减
 7 print(arr_subtract)
 8 #输出结果
 9 '''
10 [[0 1]
11  [2 3]]
12 [[0 2]
13  [4 6]]
14 ************
15 [[ 0 -1]
16  [-2 -3]]
17 '''

np.maximum()

 1 arr1 = np.random.randn(4).reshape((2, 2))
 2 arr2 = np.random.randn(4).reshape((2, 2))
 3 print(arr1)
 4 print(arr2)
 5 print("************")
 6 arr_maximum = np.maximum(arr1, arr2)     #各元素值对应相比较，取较大的放在对应位置上
 7 print(arr_maximum)
 8 #输出结果
 9 '''
10 [[-0.13552856 -0.19105196]
11  [ 0.38300898 -1.67164528]]
12 [[ 0.08309537 -1.33379454]
13  [-1.03875546  0.62144675]]
14 ************
15 [[ 0.08309537 -0.19105196]
16  [ 0.38300898  0.62144675]]
17 '''

np.copysign()

 1 arr1 = np.random.randn(4).reshape((2, 2))
 2 arr2 = np.random.randn(4).reshape((2, 2))
 3 print(arr1)
 4 print(arr2)
 5 print("************")
 6 arr_copysign = np.copysign(arr1, arr2)     #新生成的arr_copysign使用第一个数组的值，第二个数组的符号
 7 print(arr_copysign)
 8 #输出结果
 9 '''
10 [[-0.04938378 -0.18659454]
11  [-0.07878375 -1.9639056 ]]
12 [[ 0.65798049 -1.69537425]
13  [ 0.10808436 -0.58918707]]
14 ************
15 [[ 0.04938378 -0.18659454]
16  [ 0.07878375 -1.9639056 ]]
17 '''

np.greater_equal()

 1 arr1 = np.random.randn(4).reshape((2, 2))
 2 arr2 = np.random.randn(4).reshape((2, 2))
 3 print(arr1)
 4 print(arr2)
 5 print("************")
 6 arr_greater_equal = np.greater_equal(arr1, arr2)     #进行arr1 ≥ arr2比较，返回布尔型数组
 7 print(arr_greater_equal)
 8 #输出结果
 9 '''
10 [[ 2.42425288 -0.1535605 ]
11  [-0.09387474  0.07655643]]
12 [[-0.56279806  0.55879896]
13  [ 0.199348    1.33215315]]
14 ************
15 [[ True False]
16  [False False]]
17 '''

np.logical_and()

 1 arr1 = np.random.randn(4).reshape((2, 2))
 2 arr2 = np.arange(4).reshape((2, 2))
 3 print(arr1)
 4 print(arr2)
 5 print("************")
 6 arr_logical_and = np.logical_and(arr1, arr2)     #对两个数组进行逻辑真值与操作，返回布尔型数组
 7 print(arr_logical_and)
 8 #输出结果
 9 '''
10 [[-1.81030446 -1.04702541]
11  [-0.17202973  1.7891667 ]]
12 [[0 1]
13  [2 3]]
14 ************
15 [[False  True]
16  [ True  True]]
17 '''

np.where()

1 xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
2 yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
3 cond = np.array([True, False, True, False, False])
4 result = np.where(cond, xarr, yarr)
5 print(result)
6 #输出结果
7 '''
8 [1.1 2.2 1.3 2.4 2.5]
9 '''

np.unique(x)

1 names = np.array(['Bob', 'Joe', 'Will', 'Jason', 'Morvan', 'Morvan', 'Joe'])
2 result = np.unique(names)   #找出数组其中唯一的值，并返回已排序的结果
3 print(result)
4 #输出结果
5 '''
6 ['Bob' 'Jason' 'Joe' 'Morvan' 'Will']
7 '''

np.intersect1d(x,y)、 np.union1d(x,y)

 1 names1 = np.array(['Bob', 'Joe', 'Will', 'Jason', 'Morvan', 'Morvan', 'Joe'])
 2 names2 = np.array(['Jayhe', 'Joe', 'Jobs', 'Jason', 'Morvan', 'Jayheyang'])
 3 result1 = np.intersect1d(names1, names2)   #计算names1与names2的交集，并返回有序的结果
 4 result2 = np.union1d(names1, names2)       #计算names1与names2的并集，并返回有序的结果
 5 print(result1)
 6 print(result2)
 7 #输出结果
 8 '''
 9 ['Jason' 'Joe' 'Morvan']
10 ['Bob' 'Jason' 'Jayhe' 'Jayheyang' 'Jobs' 'Joe' 'Morvan' 'Will']
11 '''

np.in1d(x, y)

1 values = np.array([6, 0, 0, 3, 2, 5, 6])
2 result = np.in1d(values, [2, 3, 6])     #得到一个"values是否包含于[2, 3, 6]"的布尔型数组
3 print(result)
4 #输出结果
5 '''
6 [ True False False  True  True False  True]
7 '''

np.setdiff1d(x,y)

1 values = np.array([6, 0, 0, 3, 2, 5, 6])
2 result = np.setdiff1d(values, [2, 3, 6])     #得到一个由元素在values中不在[2, 3, 6]中的数组
3 print(result)
4 #输出结果
5 '''
6 [0 5]
7 '''

array.min()、array.max()

 1 values = np.array([6, 0, 0, 3, 2, 5, 6])
 2 result_max = values.max()
 3 result_min = values.min()
 4 print(result_max)
 5 print(result_min)
 6 #输出结果
 7 '''
 8 6
 9 0
10 '''

array.argmin()、array.argmax()

 1 values = np.array([6, 0, 0, 3, 2, 5, 6])
 2 result_argmax = values.argmax()       #返回数组中元素最大值对应的索引号
 3 result_argmin = values.argmin()
 4 print(values[result_argmax])
 5 print(values[result_argmin])
 6 #输出结果
 7 '''
 8 6
 9 0
10 '''

bools_array.any()

values = np.array([ True, False, False,  True,  True, False,  True])
result_any = values.any()
result_all = values.all()       #数组中是不是每个元素都是True
print(result_any)
print(result_all)
#输出结果
'''
True
False
'''