zoukankan      html  css  js  c++  java
  • Numpy数组

    数组维度变化

    • numpy的基本类型是ndarray,即n维数组
    • 想用ndarray进行矩阵运算,首先要保证运算对象是二维数组
    • 一维数组并不等价于线性代数中的向量,它永远是一行,没有转置,如果想进行矩阵运算必须先升为二维数组:
    a = a[:,None]                   # 方法一
    a = np.expand_dims(a, axis=1)   # 方法二
    

    例如:

    In [1]: import numpy as np                                                                                                        
    In [2]: a = np.array([1,2,3])                                                                                                     
    In [3]: a                                                                                                                         
    Out[3]: array([1, 2, 3])
    In [4]: a.T                                                                                                                       
    Out[4]: array([1, 2, 3])
    
    In [5]: a = a[:,None]                                                                                                             
    In [6]: a                                                                                                                         
    Out[6]: 
    array([[1],
           [2],
           [3]])
    In [7]: a.T                                                                                                                       
    Out[7]: array([[1, 2, 3]])
    
    • 二维数组进行矩阵运算不改变数组的维数,即使结果是一个向量也是二维数组
    In [8]: a=np.array([[1,2,3]])                                                                                                     
    In [9]: b=a                                                                                                                       
    In [10]: c=np.dot(a, b.T)                                                                                                         
    In [11]: c                                                                                                                        
    Out[11]: array([[14]])
    
    • 二维数组通过索引取出一行/列时会降维
    In [14]: a=np.ones((3,3))                                                                                                         
    In [15]: a                                                                                                                        
    Out[15]: 
    array([[1., 1., 1.],
           [1., 1., 1.],
           [1., 1., 1.]])
    In [16]: a[1,:]                                                                                                                   
    Out[16]: array([1., 1., 1.])
    
    • np.mean()等内置函数运算后会自动降维,否则要手动指定keepdims=True
    In [17]: np.mean(a, axis=1)                                                                                                       
    Out[17]: array([1., 1., 1.])
    In [18]: np.mean(a, axis=1, keepdims=True)                                                                                        
    Out[18]: 
    array([[1.],
           [1.],
           [1.]])
    
    • 所以在对ndarray进行运算之前先进行shape的检查是个好习惯

    常用函数集锦

    • np.clip()
    • np.percentile()
    • np.indice()
    • np.lexsort()
      np.lexsort完成了这下面几步:
      index: 0 1 2 3 5 6
      a: 1 5 1 4 3 4 4
      先根据 a 内的数据对每个元素从小到大进行排序可以得到
      index_sorted_v1: 0 2 4 3 5 6 1
      但是可以看到0, 2的大小同为1,3,5,6大小同为4,一般argsort的话会按照原本的顺序来拍,但这里是lexsort,并且我们有b,所以利用b内对应位置元素的大小来进行排序
      b_sorted_v1: 9 0 0 4 2 1 4
      index_sorted_v2: 2 0 4 6 5 3 1
      这就是我们得到的结果ind。
  • 相关阅读:
    2. Add Two Numbers
    1. Two Sum
    22. Generate Parentheses (backTracking)
    21. Merge Two Sorted Lists
    20. Valid Parentheses (Stack)
    19. Remove Nth Node From End of List
    18. 4Sum (通用算法 nSum)
    17. Letter Combinations of a Phone Number (backtracking)
    LeetCode SQL: Combine Two Tables
    LeetCode SQL:Employees Earning More Than Their Managers
  • 原文地址:https://www.cnblogs.com/tofengz/p/13799346.html
Copyright © 2011-2022 走看看