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()

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

     

 

点赞

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。 必填欄位標示為 *