NumPy基础操作(2)

阿里云2000元红包!本站用户参与享受九折优惠!


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


     

 

你或许想:《去原作者写文章的地方

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
Python
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论