NumPy基础操作（2）

---

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	计算各元素的指数ex
  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计算AB后，放到对应位置上
  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
  '''