正文

NumPy基础操作（2）

IP云
IP云V管理员/3 阅读
11/30
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

NumPy基础操作（2）

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

目录：

  • 写在前面
  • 转置和轴对换
  • NumPy常用函数

写在前面

本篇博文主要讲解了普通转置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() 

     arr = np.random.randn(9).reshape((3,3))
    
 print(arr)
    
 print("************")
    
 arr_abs = np.abs(arr)
    
 print(arr_abs)
    
 #输出结果
    
 '''
    
 [[-0.58979776  0.01673949  1.22808794]
    
  [-2.44004574 - 0.36391562 - 1.68938497]
    
  [0.25851057 - 0.05289508 - 1.1986467]]
    
 ** ** ** ** ** **
    
 [[0.58979776 0.01673949 1.22808794]
    
  [2.44004574 0.36391562 1.68938497]
    
  [0.25851057 0.05289508 1.1986467 ]]
    
 '''

  • np.sqrt() 

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

  • np.exp() 

     arr = np.arange(4).reshape((2, 2))
    
 print(arr)
    
 print("************")
    
 arr_exp = np.exp(arr)
    
 print(arr_exp)
    
 #输出结果
    
 '''
    
 [[0 1]
    
  [2 3]]
    
 ************
    
 [[ 1.          2.71828183]
    
  [ 7.3890561  20.08553692]]
    
 '''

  • np.log1p() 

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

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

  • np.rint() 

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

  • np.sign() 

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

  • np.modf() 

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

  • np.add() 

     arr1 = np.arange(4).reshape((2, 2))
    
 arr2 = np.arange(4).reshape((2, 2))
    
 print(arr1)
    
 print(arr2)
    
 print("************")
    
 arr_add = np.add(arr1, arr2)     #各元素值对应相加
    
 print(arr_add)
    
 #输出结果
    
 '''
    
 [[0 1]
    
  [2 3]]
    
 [[0 1]
    
  [2 3]]
    
 ************
    
 [[0 2]
    
  [4 6]]
    
 '''

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

  • np.subtract() 

     arr1 = np.arange(4).reshape((2, 2))
    
 arr2 = np.arange(4).reshape((2, 2)) * 2
    
 print(arr1)
    
 print(arr2)
    
 print("************")
    
 arr_subtract = np.subtract(arr1, arr2)     #各元素值对应相减
    
 print(arr_subtract)
    
 #输出结果
    
 '''
    
 [[0 1]
    
  [2 3]]
    
 [[0 2]
    
  [4 6]]
    
 ************
    
 [[ 0 -1]
    
  [-2 -3]]
    
 '''

  • np.maximum() 

     arr1 = np.random.randn(4).reshape((2, 2))
    
 arr2 = np.random.randn(4).reshape((2, 2))
    
 print(arr1)
    
 print(arr2)
    
 print("************")
    
 arr_maximum = np.maximum(arr1, arr2)     #各元素值对应相比较，取较大的放在对应位置上
    
 print(arr_maximum)
    
 #输出结果
    
 '''
    
 [[-0.13552856 -0.19105196]
    
  [ 0.38300898 -1.67164528]]
    
 [[ 0.08309537 -1.33379454]
    
  [-1.03875546  0.62144675]]
    
 ************
    
 [[ 0.08309537 -0.19105196]
    
  [ 0.38300898  0.62144675]]
    
 '''

  • np.copysign() 

     arr1 = np.random.randn(4).reshape((2, 2))
    
 arr2 = np.random.randn(4).reshape((2, 2))
    
 print(arr1)
    
 print(arr2)
    
 print("************")
    
 arr_copysign = np.copysign(arr1, arr2)     #新生成的arr_copysign使用第一个数组的值，第二个数组的符号
    
 print(arr_copysign)
    
 #输出结果
    
 '''
    
 [[-0.04938378 -0.18659454]
    
  [-0.07878375 -1.9639056 ]]
    
 [[ 0.65798049 -1.69537425]
    
  [ 0.10808436 -0.58918707]]
    
 ************
    
 [[ 0.04938378 -0.18659454]
    
  [ 0.07878375 -1.9639056 ]]
    
 '''

  • np.greater_equal() 

     arr1 = np.random.randn(4).reshape((2, 2))
    
 arr2 = np.random.randn(4).reshape((2, 2))
    
 print(arr1)
    
 print(arr2)
    
 print("************")
    
 arr_greater_equal = np.greater_equal(arr1, arr2)     #进行arr1 ≥ arr2比较，返回布尔型数组
    
 print(arr_greater_equal)
    
 #输出结果
    
 '''
    
 [[ 2.42425288 -0.1535605 ]
    
  [-0.09387474  0.07655643]]
    
 [[-0.56279806  0.55879896]
    
  [ 0.199348    1.33215315]]
    
 ************
    
 [[ True False]
    
  [False False]]
    
 '''

  • np.logical_and() 

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

  • np.where() 

     xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
    
 yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
    
 cond = np.array([True, False, True, False, False])
    
 result = np.where(cond, xarr, yarr)
    
 print(result)
    
 #输出结果
    
 '''
    
 [1.1 2.2 1.3 2.4 2.5]
    
 '''

  • np.unique(x) 

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

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

     names1 = np.array(['Bob', 'Joe', 'Will', 'Jason', 'Morvan', 'Morvan', 'Joe'])
    
 names2 = np.array(['Jayhe', 'Joe', 'Jobs', 'Jason', 'Morvan', 'Jayheyang'])
    
 result1 = np.intersect1d(names1, names2)   #计算names1与names2的交集，并返回有序的结果
    
 result2 = np.union1d(names1, names2)       #计算names1与names2的并集，并返回有序的结果
    
 print(result1)
    
 print(result2)
    
 #输出结果
    
 '''
    
 ['Jason' 'Joe' 'Morvan']
    
 ['Bob' 'Jason' 'Jayhe' 'Jayheyang' 'Jobs' 'Joe' 'Morvan' 'Will']
    
 ''' 

  • np.in1d(x, y) 

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

  • np.setdiff1d(x,y) 

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

  • array.min()、array.max() 

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

  • array.argmin()、array.argmax() 

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

  • 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
    
'''

相关阅读

目录[+]