Python的第三方擴(kuò)展庫，是其他數(shù)據(jù)分析模塊的基礎(chǔ)，主要用于數(shù)組、矩陣計算（比列表快得多）等方面

安裝

pip install numpy

常用方法

array()

創(chuàng)建數(shù)組，舉例：
創(chuàng)建一維數(shù)組：numpy.array([x,y,...])
二維數(shù)組：numpy.array([[x,y...],[x,y...],[x,y...])
注：
創(chuàng)建的數(shù)組如果想看格式（幾行幾列），就通過array.shape來看就行了，要知道是幾維的數(shù)據(jù)，可以通過array.ndim查看，舉例：

>>> z = np.array([[1,2],[3,4],[5,6]])
>>> z.ndim
2
#2維
>>> z.shape
(3, 2)
#3行兩列
>>> m = np.array([1,2])
>>> m.shape
(2,)
#1行兩列

注2：
數(shù)組創(chuàng)建后大小就固定了，所以如果想要進(jìn)行增刪改查則可以參考如下方法：

• 增：使用tile()擴(kuò)展、vstack()合并、轉(zhuǎn)成列表操作再轉(zhuǎn)回來（參考后面）
• 刪：可以直接像a=a[0]，那么就只有一行了、分片操作
• 改：直接改
• 查：直接查，可以參考后面的數(shù)組切片
  舉例：

>>> a = np.array([1,2,3,4])
>>> np.tile(a, 2)  #此時第二個參數(shù)相當(dāng)于(1,2)，即擴(kuò)展成1行2列（x軸變成原來2倍）
array([1, 2, 3, 4, 1, 2, 3, 4])

數(shù)組操作

對數(shù)組的操作都是通過依次對其中的元素進(jìn)行相同操作，舉例：

>>> x = np.array([-1,0,1,2,3])
>>> x
array([-1,  0,  1,  2,  3])
>>> x > 1  #依次判斷，若滿足條件則True，否則False
array([False, False, False,  True,  True])
>>> x * 2  #依次對所有元素乘2
array([-2,  0,  2,  4,  6])
>>> x = np.array([[1,2],[3,4]])
>>> x[x>2] = 0
# 將數(shù)組中大于2的值都置0
>>> x
array([[1, 2],
       [0, 0]])
>>> x = np.arange(0, 5)
>>> x
array([0, 1, 2, 3, 4])
>>> y = x[:, np.newaxis]
# 把x轉(zhuǎn)成二維就是y
>>> y
array([[0],
       [1],
       [2],
       [3],
       [4]])
>>> x + y
# 對于兩個不是相同格式的數(shù)據(jù)添加，會自動拓展成兩個都合適的維度進(jìn)行計算，后面會還原計算過程
array([[0, 1, 2, 3, 4],
       [1, 2, 3, 4, 5],
       [2, 3, 4, 5, 6],
       [3, 4, 5, 6, 7],
       [4, 5, 6, 7, 8]])
>>> x1 = np.tile(x, (5, 1))
# 把x的行復(fù)制成原來的5倍
>>> x1
array([[0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4]])
>>> y1 = np.tile(y, (1, 5))
# 把y的列復(fù)制成原來的5倍
>>> y1
array([[0, 0, 0, 0, 0],
       [1, 1, 1, 1, 1],
       [2, 2, 2, 2, 2],
       [3, 3, 3, 3, 3],
       [4, 4, 4, 4, 4]])
>>> x1 + y1
# 可以看到結(jié)果和之前是一樣的
array([[0, 1, 2, 3, 4],
       [1, 2, 3, 4, 5],
       [2, 3, 4, 5, 6],
       [3, 4, 5, 6, 7],
       [4, 5, 6, 7, 8]])

注：
數(shù)組是可以定義里面所有的類型統(tǒng)一的（通過astype方法或者有些數(shù)據(jù)讀取自帶類型，比如圖片讀取默認(rèn)是np.uint8），所以在對數(shù)組進(jìn)行操作前需要判斷數(shù)據(jù)類型是否符合要求或者需要轉(zhuǎn)型，否則將可能發(fā)生數(shù)據(jù)被自動轉(zhuǎn)型或者操作失敗等問題，舉例：

>>> x = np.array([[-1,0,1], [2,3,4]], np.int8)
# 數(shù)據(jù)類型是int8：-256~255
>>> x[1, :] = [1., 2., 300.]
>>> x
array([[-1,  0,  1],
       [ 1,  2, 44]], dtype=int8)
# 300超過邊界，被自動轉(zhuǎn)成44（300-255，從0開始）

數(shù)組索引

數(shù)組除了可以通過輸入對應(yīng)行列或者切片（后面會介紹）進(jìn)行索引以外，也可以輸入一個列表進(jìn)行批量指定索引，舉例：

>>> x = np.array([-1,0,1,2,3])
>>> x[[1,2,4]]
# 索引第2,3,5個數(shù)據(jù)
array([0, 1, 3])

注：
輸入列表是批量索引，但輸入的如果是元組，則是指定坐標(biāo)索引，舉例：

>>> x = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> x
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> x[[0,1]]
# 輸入列表，代表要第一行和第二行
array([[1, 2, 3],
       [4, 5, 6]])
>>> x[(0,1)]
# 輸入元組，代表要第一行第二列的數(shù)據(jù)
2
>>> x[(0,1), (1,1)]
# 要坐標(biāo)為0,1和1,1的數(shù)據(jù)
array([2, 5])
>>> x[(0,1,1)]
# 用元組默認(rèn)是當(dāng)成一組坐標(biāo)，因此必須是2個值成對出現(xiàn)，這里輸入3個，而數(shù)據(jù)是二維，自然就報錯了
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    x[(0,1,1)]
IndexError: too many indices for array

邏輯操作

從前面的代碼可以知道數(shù)組可以進(jìn)行整體的邏輯判斷，但是前面的示例都是單個條件判斷，如果想進(jìn)行多個判斷后再進(jìn)行與或異或這些操作，可以使用logical_and()等這類邏輯操作方法，舉例：

>>> a = np.array([[1,2,3], [1,2,""], [1,2,None]])
>>> np.logical_and.reduce([a!="", a!=None])
array([[ True,  True,  True],
       [ True,  True, False],
       [ True,  True, False]])
# 同時判斷值不為空字符串和None

上面的方法只能對兩個條件進(jìn)行判斷，多個條件的情況參考：
http://www.itdecent.cn/p/1146b51ae6de

sort()

排序，正常排，遇到無法排序的放最后，舉例：

>>> x = np.array([1,3,2,'a',5])
>>> x
array(['1', '3', '2', 'a', '5'], dtype='<U11')  #排序前
>>> x.sort()
>>> x
array(['1', '2', '3', '5', 'a'], dtype='<U11')  #排序后

注：
二維數(shù)組排序只排每一行里面的，其他行之間互不干擾

max()

求最大值，如果在二維數(shù)組中，每行的列數(shù)相等，那么最大值就是所有元素里最大的，舉例：

>>> x = np.array([[1,2,3,5],[1,2,0,0],[5,8,23,1]])
>>> x.max()
23

但如果每行列數(shù)不同，返回的就是數(shù)開頭最大的那一行（假如第一個一樣，再比第二個...），舉例：

>>> x = np.array([[3,2,1,4,10],[1,2,0,0],[3,6,9,1]])
>>> x.max()
[3, 6, 9, 1]

注：
最小值min()，平均值是mean()，加權(quán)平均值是average()，標(biāo)準(zhǔn)差是std()

[:]

數(shù)組切片，參考列表，舉例：

>>> b = np.array([1,2,3,4,5])
>>> b[1:3]
array([2, 3])
>>> a = np.array(([1,2,3,4],[5,6,7,8],[9,10,11,12]))
>>> a[1:]
array([[ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> a[:][1]  #切出所有行，取第2個
array([5, 6, 7, 8])
>>> a[:][1:]    #切出所有行，取第二個2到最后一個
array([[ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

可以看出上面只能切出行而不能切分列（其將行看作整體來切分），所以推薦使用下面的針對數(shù)組特殊的切片方法來切分行列，格式：[:,:]，在一個括號里寫分片，逗號分隔行列，舉例：

>>> a = np.array(([1,2,3,4],[5,6,7,8],[9,10,11,12]))
>>> a[1:, 1]  #取第二、三行的第二列數(shù)據(jù)
array([ 6, 10])
>>> a[:, 0:3]  #取所有行的第一列到第三列數(shù)據(jù)
array([[ 1,  2,  3],
       [ 5,  6,  7],
       [ 9, 10, 11]])

...

省略號在數(shù)組當(dāng)中也是可以使用的，也是切片的一種，但有所不同，舉例：

>>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
>>> x.shape
(2, 3, 1)
>>> x[...,0]
array([[1, 2, 3],
       [4, 5, 6]])
>>> x[:,0]
# 發(fā)現(xiàn)和x[...,0]結(jié)果不一樣
array([[1],
       [4]])
>>> x[:,:,0]
# 和x[...,0]結(jié)果一樣
array([[1, 2, 3],
       [4, 5, 6]])

從上面可以看出...的切片效果就是將所有...以外沒設(shè)置范圍的地方都調(diào)整為:

random.randint(x,y,n)

隨機(jī)數(shù)整數(shù)生成，前兩個參數(shù)代表范圍，第三個為可選，表示生成格式或者數(shù)量，比如：

>>> np.random.randint(1,10,10)
# 隨機(jī)生成10個1到10的隨機(jī)數(shù)
array([ 6,  5,  7,  6,  5,  4,  9,  9, 10,  5])
>>> np.random.randint(0, 256, (100, 80))
# 隨機(jī)生成格式為100行80列的數(shù)組
array([[ 46, 100,  98, ...,  56,  97, 172],
       [ 60, 141, 217, ..., 208, 157,  70],
       [189, 200,  13, ..., 193,  95,  80],
       ...,
       [ 88, 155, 253, ..., 183, 139, 182],
       [ 24, 101, 117, ..., 103,  30,  77],
       [ 88, 236,  35, ...,  47, 211, 189]])

上面那個是生成整數(shù)的隨機(jī)數(shù)，還有rand()用來生成0到1之間的隨機(jī)數(shù)，中間可以加參數(shù)代表生成幾個，舉例：

>>> np.random.rand(10)  #生成10個0-1的隨機(jī)數(shù)
array([0.42462596, 0.0985224 , 0.22108224, 0.46230285, 0.40928969,
       0.54201574, 0.88982411, 0.8450716 , 0.21384846, 0.38896833])

random.random.normal(μ,σ,n)

生成一堆符合正態(tài)分布的數(shù)，第一個參數(shù)是均值，第二個參數(shù)是標(biāo)準(zhǔn)差，第三個參數(shù)是生成數(shù)，舉例：

>>> a = np.random.normal(0,1,10)
>>> a
array([-0.55491277, -1.1161704 ,  0.97514814,  1.99653332, -0.08500584,
        0.64075696,  1.96409159, -0.11636198,  0.52605946,  0.90563603])
>>> a.mean()
0.513577451404013
>>> a.std()
0.9612030098851562
#當(dāng)生成的數(shù)多了，精度自然也會提高

更多numpy.random參考：
http://www.mamicode.com/info-detail-507676.html

arange()

類似range，前兩個參數(shù)代表范圍，第三個代表階值類似range，舉例：

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(1,10,2)
array([1, 3, 5, 7, 9])

注：
發(fā)現(xiàn)了嗎，像python自帶的random、range雖然和這些幾乎一樣，但有個區(qū)別就是numpy下的這幾個方法生成的都是array類型的，原來那些都是list類型

concatenate()

將數(shù)組整合在一起，數(shù)組不像列表那樣可以直接加著整合，比如列表里：

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a+b
[1, 2, 3, 4, 5, 6]
>>> a*2
[1, 2, 3, 1, 2, 3]

從上面可以看出對列表進(jìn)行運(yùn)算都是把列表當(dāng)成整體來運(yùn)算，而對于數(shù)組里：

>>> a = np.array([1,2,3])
>>> b = np.array([4,5,6])
>>> a + b
array([5, 7, 9])
>>> a * 2
array([2, 4, 6])

可以看出對數(shù)組的運(yùn)算是對他里面的值進(jìn)行運(yùn)算，因此要對數(shù)組進(jìn)行列表那樣的操作，就需要用上面那個方法，對上面的a、b舉例：

>>> np.concatenate((a, b))  #以元組形式傳入
array([1, 2, 3, 4, 5, 6])

sum()

計算總和，舉例：

>>> np.sum([1,2,3])
6

上面的是對行內(nèi)相加，如果是多行數(shù)據(jù)，并且希望是各行的對應(yīng)數(shù)據(jù)之間相加，可以設(shè)置參數(shù)：axis=0（默認(rèn)為1，即行內(nèi)相加），舉例：

>>> a = np.array([[1,2,3,4], [5,6,7,8], [1, 2, 3, 4]])
>>> a.sum()  #全部數(shù)據(jù)之和
46
>>> a.sum(axis=0)  #各行對應(yīng)數(shù)據(jù)之和
array([ 7, 10, 13, 16])

注：
其他計算操作如：求對數(shù)用np.log()，向上取整用np.ceil()，比如3.1就變成4

unique()

去重，舉例：

>>> np.unique([1,2,3,1,2,3,5,6,4])
array([1, 2, 3, 4, 5, 6])
>>> np.unique(np.array([1,2,3,1,2,3,5,6,4]))  #對數(shù)組、列表都可以，但最終都是變成數(shù)組
array([1, 2, 3, 4, 5, 6])

drop()

丟棄

fillna()

對丟失值的填充

tile()

復(fù)制擴(kuò)展數(shù)組，有兩個參數(shù)，第一個是要復(fù)制擴(kuò)展的數(shù)組，第二個參數(shù)是個元組，意思是變成幾行幾列，舉例：

>>> a = np.array([1,2,3,4])
>>> np.tile(a, 2)  #此時第二個參數(shù)相當(dāng)于(1,2)，即擴(kuò)展成1行2列（x軸變成原來2倍）
array([1, 2, 3, 4, 1, 2, 3, 4])

第二個參數(shù)的元組有幾位，就代表幾維，一般都是用二維，即兩個值，代表幾行幾列，在列上擴(kuò)展舉例1：

>>> np.tile(a, (2, 1))  #擴(kuò)展成2行1列
array([[1, 2, 3, 4],
       [1, 2, 3, 4]])

其還能擴(kuò)展到更多維，如三維舉例：

>>> np.tile(a, (3, 2, 1))  #在三維下，分3組，每組2行1列
array([[[1, 2, 3, 4],
        [1, 2, 3, 4]],

       [[1, 2, 3, 4],
        [1, 2, 3, 4]],

       [[1, 2, 3, 4],
        [1, 2, 3, 4]]])

四維舉例：

>>> np.tile(a, (2, 3, 3, 2))    #在4維下，分2組，每組3個，每個3行2列
array([[[[1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4]],

        [[1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4]],

        [[1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4]]],


       [[[1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4]],

        [[1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4]],

        [[1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4],
         [1, 2, 3, 4, 1, 2, 3, 4]]]])

發(fā)現(xiàn)了嗎，可以這樣理解第二個參數(shù)，那就是元組的最后兩個數(shù)代表變成原來的幾行幾列，前面的數(shù)都是分多少組多少個，比如三維的3個數(shù)分別代表：幾組幾行幾列；四維分別代表：幾組幾個幾行幾列；五維：幾組幾個幾塊幾行幾列；六…（單位是瞎編的，但是意思沒錯）

zero()

生成一個自定義大小值全為0的數(shù)組，傳入?yún)?shù)是一個列表或元組，代表幾行幾列，舉例：

>>> np.zeros([2,5])
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

其傳入的列表也可以是多維的，比如：

>>> np.zeros([2,2,5])  #2組，每組2行5列
array([[[0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.]],

       [[0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.]]])

多維的用法和tile()函數(shù)的基本一樣，參考上面即可
注：
numpy里還有生成一個自定義大小值全為1的數(shù)組放方法：ones()，還有值都為空的數(shù)組：empty()

vstack()/hstack()

將兩個數(shù)組在垂直/水平方向合并，舉例：

>>> a = np.array([1,2,3,4])
>>> b = np.array([5,6,7,8])
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6, 7, 8])
>>> np.vstack((a,b))
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

注：
如果是對當(dāng)前數(shù)組自己進(jìn)行垂直/水平方向合并，則相當(dāng)于轉(zhuǎn)成二維或者一維，舉例：

>>> a = np.array([1,2,3,4])
>>> b = np.array([5,6,7,8])
>>> np.hstack(a)
array([1, 2, 3, 4])
>>> np.vstack(a)
array([[1],
       [2],
       [3],
       [4]])

stack

也是把數(shù)組堆疊在一起，可以指定維度，默認(rèn)維度是0，,即把數(shù)組看作一個整體堆疊在后面，和concatenate/vstack/hstack的區(qū)別參考：
https://cloud.tencent.com/developer/article/1378491
https://www.cnblogs.com/nkh222/p/8932369.html
舉例：

>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> a
array([[1, 2, 3],
       [4, 5, 6]])
>>> b = a
>>> np.vstack((a, b))
array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3],
       [4, 5, 6]])
>>> np.hstack((a, b))
array([[1, 2, 3, 1, 2, 3],
       [4, 5, 6, 4, 5, 6]])
# 整個拼在右邊
>>> np.concatenate((a, b))
array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3],
       [4, 5, 6]])
>>> np.stack((a, b))
array([[[1, 2, 3],
        [4, 5, 6]],

       [[1, 2, 3],
        [4, 5, 6]]])

stack的第二個參數(shù)，用于設(shè)置在第幾個維度進(jìn)行堆疊，舉例：

>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> a
array([[1, 2, 3],
       [4, 5, 6]])
>>> a.shape
(2, 3)
>>> b = a
>>> np.stack((a, b), axis=0)
array([[[1, 2, 3],
        [4, 5, 6]],

       [[1, 2, 3],
        [4, 5, 6]]])
# 在第0個維度堆疊，相當(dāng)于新建一個維度
>>> np.stack((a, b), axis=0).shape
(2, 2, 3)
# 所以數(shù)據(jù)a從(2, 3) -> (1, 2, 3) -> (2, 2, 3)
>>> np.stack((a, b), axis=1)
array([[[1, 2, 3],
        [1, 2, 3]],

       [[4, 5, 6],
        [4, 5, 6]]])
>>> np.stack((a, b), axis=1).shape
(2, 2, 3)
# 在第1個維度進(jìn)行堆疊，所以數(shù)據(jù)a從(2, 3) -> (2, 1, 3) -> (2, 2, 3)
>>> np.stack((a, b), axis=2)
array([[[1, 1],
        [2, 2],
        [3, 3]],

       [[4, 4],
        [5, 5],
        [6, 6]]])
>>> np.stack((a, b), axis=2).shape
(2, 3, 2)
# 在第2個維度進(jìn)行堆疊，所以數(shù)據(jù)從(2, 3) -> (2, 3, 1) -> (2, 3, 2)
>>> np.stack((a, b), axis=-1)
array([[[1, 1],
        [2, 2],
        [3, 3]],

       [[4, 4],
        [5, 5],
        [6, 6]]])
# -1代表在最后一個維度進(jìn)行堆疊，所以看出和2的時候結(jié)果一樣

linspace()

生成一個等差數(shù)列，舉例：

>>> np.linspace(-1,1,5, dtype=np.float32)  # -1到1分成5份的等差數(shù)列
array([-1. , -0.5,  0. ,  0.5,  1. ], dtype=float32)

newaxis

如果直接輸出，你會發(fā)現(xiàn)他就是None（源碼里就是newaxis = None），但是他常被用來添加一個新的維度，比如一維向量變二維矩陣，二維則變?nèi)S等等，可能因為None在這里有這個功能，因為為了方便閱讀程序而設(shè)置了一個別名，使用舉例：

>>> np.newaxis == None  # 可以發(fā)現(xiàn)他就是None
True
>>> x = np.array([1,2,3,4])
>>> x
array([1, 2, 3, 4])
>>> x.shape  # 可以看出是一維的向量
(4,)
>>> x[:, np.newaxis]
array([[1],
       [2],
       [3],
       [4]])
>>> x[:, np.newaxis].shape  # 變成二維了
(4, 1)

sin()/cos()

正弦/余弦函數(shù)，舉例：

>>> np.sin(math.pi/6)
0.49999999999999994

astype()

類型轉(zhuǎn)換，舉例：

>>> y
array([False, False, False,  True,  True])
>>> y.astype(np.int)  #將bool類型轉(zhuǎn)int
array([0, 0, 0, 1, 1])

數(shù)據(jù)類型范圍：
這里列一些常用數(shù)據(jù)類型及對應(yīng)范圍：

NaN  沒有填東西，也就是空
inf  無窮大
int8  -128~127
uint8  0~256
int16  32768~32767
uint16  0~65535
int/int32  -2^32~2^32-1
float16  半精度浮點型
float32  單精度浮點型
float_/float64  雙精度浮點型

更多參考：https://www.runoob.com/numpy/numpy-dtype.html

dot()

矩陣相乘，舉例：

>>> x = np.array([[1,2],[3,4]])
>>> y = np.array([[1,1],[1,1]])
>>> np.dot(x, y)
array([[3, 3],
       [7, 7]])

也可以通過python內(nèi)置的@符號實現(xiàn)矩陣相乘，舉例：

>>> x = np.array([[1,2],[3,4]])
>>> y = np.array([[1,1],[1,1]])
>>> x@y
array([[3, 3],
       [7, 7]])

T

矩陣轉(zhuǎn)置，即x和y對調(diào)過來，舉例：

>>> x = np.array([[1,2], [0, 1]])
>>> x
array([[1, 2],
       [0, 1]])
>>> x.T
array([[1, 0],
       [2, 1]])

mat()

定義矩陣，雖然array也能夠定義矩陣，但并不是真正的矩陣，只是可以定義矩陣的形狀，因此也缺少了一些矩陣專門有的方法，比如求逆矩陣（I屬性實現(xiàn)），舉例：

>>> x = np.mat([[1,2], [0, 1]])
>>> x
matrix([[1, 2],
        [0, 1]])
>>> x.I
matrix([[ 1., -2.],
        [ 0.,  1.]])
>>> x @ x.I
# 可以看到相乘結(jié)果為1001，也就證明是逆矩陣了
matrix([[1., 0.],
        [0., 1.]])

argmax()/argmin()

索引維度當(dāng)中最大值/最小值，舉例：

>>> x = np.array([[0.1, 0.6, 0.1], [0.3, 0.1, 0.6],[0.2, 0.5, 0.3], [0.8, 0.1, 0.1]])
>>> y = np.argmax(x)  #索引整個數(shù)組最大元素
>>> y
9
#第10個最大，為0.8
>>> y = np.argmax(x, axis=1)  #在每個維度（沿著一維方向）里面索引最大值
>>> y
array([1, 2, 1, 0], dtype=int32)
#每個維度最大的分別是0.6,0.6,0.5,0.8，位置分別是1,2,1,0

argsort()

沿著索引維度從小到大排序，返回的是排序后的索引，舉例：

>>> x = np.array([2,1,5,4,3])
>>> x.argsort()
# 可以看到從小到大排序的索引
array([1, 0, 4, 3, 2], dtype=int64)
>>> x[x.argsort()]
# 通過索引查看對應(yīng)排序的值
array([1, 2, 3, 4, 5])
>>> (-x).argsort()
# 如果想要從大到小排序，可以乘個負(fù)號
array([2, 3, 4, 0, 1], dtype=int64)

arctan

計算某個點的正切，舉例：

>>> np.arctan(2/1)
1.1071487177940904

如果想知道對應(yīng)的角度就可以乘以180/π，也可以用numpy下的rad2deg()方法，舉例：

>>> np.arctan(2/1) * 180 / np.pi
63.43494882292201
>>> np.rad2deg(np.arctan(2/1))
63.43494882292201
# 可以看出結(jié)果一樣

arctan2

和上面的很像，也是計算某個點的正切。但前者是計算某個點在正切曲線上對應(yīng)的值，而這個則是計算某個點相對坐標(biāo)(0, 0)的正切值，傳入前兩個參數(shù)分別是：y和x（記住第一個參數(shù)是y不是x），舉例：

>>> np.arctan2(2, 1) * 180 / np.pi
# 坐標(biāo)(1, 2)的正切值，可以看出和np.arctan(2/1)一樣
63.43494882292201
>>> np.arctan2(-2, 1) * 180 / np.pi
# 坐標(biāo)(1, -2)的正切值，想象一下，是在x軸下方，但是角度一樣，因此為負(fù)
-63.43494882292201
>>> np.arctan2(2, -1) * 180 / np.pi
# 坐標(biāo)(-1, 2)的正切值
116.56505117707799

reshape

改變數(shù)組的形狀，其中-1代表對剩下的進(jìn)行合并處理，舉例：

>>> a = np.random.randint(0, 255, (50, 50, 50))
>>> a.shape
>>> a.reshape(500, 25, 10).shape
# 轉(zhuǎn)成(500, 25, 10)
(500, 25, 10)
>>> a.reshape(50, -1).shape
# 轉(zhuǎn)成(50, 剩下的)
(50, 2500)
>>> a.reshape(500, 10, -1).shape
# 轉(zhuǎn)成(500, 10, 剩下的)
(500, 10, 25)

clip

限制數(shù)組范圍，舉例：

>>> x = np.array([i for i in range(10)])
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(x, 0, 5)
# 限制數(shù)組x范圍在0~5
array([0, 1, 2, 3, 4, 5, 5, 5, 5, 5])
>>> x = np.array([i+.1 for i in range(10)])
>>> x
array([0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 8.1, 9.1])
>>> np.clip(x, 0., 5.)
# 對于超過范圍的數(shù)進(jìn)行邊界值處理，其他值不會處理
array([0.1, 1.1, 2.1, 3.1, 4.1, 5. , 5. , 5. , 5. , 5. ])

fabs

對數(shù)組的值去絕對值，舉例：

>>> x = np.array([i for i in range(0, -10, -1)])
>>> x
array([ 0, -1, -2, -3, -4, -5, -6, -7, -8, -9])
>>> np.fabs(x)
array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

prod

計算階乘，舉例：

>>> np.prod(np.array([1,2,3,4]))
# 1*2*3*4
24

cum開頭的方法

比如cumsum，可以知道sum是計算總和，那么cumsum返回的就是從第一個到第n個數(shù)里第n次進(jìn)行操作的結(jié)果，舉例：

>>> np.cumsum(np.array([1,2,3,4]))
# 1, 1+2, 1+2+3, 1+2+3+4
array([ 1,  3,  6, 10], dtype=int32)
>>> np.cumprod(np.array([1,2,3,4]))
array([ 1,  2,  6, 24], dtype=int32)

浮點數(shù)轉(zhuǎn)換整數(shù)

參考：https://blog.csdn.net/sinat_34072381/article/details/84567523`

nonzero

返回所有不為0的數(shù)的索引，舉例：

>>> np.nonzero(np.array([1,2,3,0,-1,0]))
# 第0、1、2、4個數(shù)不為0
(array([0, 1, 2, 4], dtype=int64),)
>>> x = np.array([[1,0,3], [4,5,0]])
>>> np.nonzero(x)
# 返回2個數(shù)組，第一個數(shù)組代表行的索引，第二個代表列的索引，比如這里就是：
# 0行0列、0行2列、1行0列、1行1列的都不為0，這樣也方便我們索引數(shù)據(jù)
(array([0, 0, 1, 1], dtype=int64), array([0, 2, 0, 1], dtype=int64))
>>> x[np.nonzero(x)]
# 可以看到返回所有的非0數(shù)據(jù)
array([1, 3, 4, 5])

pad

填充數(shù)組，舉例：

>>> x = np.array([1,2,3])
>>> x
array([1, 2, 3])
>>> np.pad(x, (1,0), 'constant')
# 在左邊添加一個0
array([0, 1, 2, 3])
>>> np.pad(x, (1,2), 'constant')
# 在左邊添加1個0，右邊添加2個0
array([0, 1, 2, 3, 0, 0])
>>> np.pad(x, (1,2), 'mean')
# 在左邊添加1個平均值，右邊添加2個平均值
array([2, 1, 2, 3, 2, 2])
>>> np.pad(x, (1,2), 'edge')
# 填充邊緣值
array([1, 1, 2, 3, 3, 3])
>>> y = np.random.rand(2, 3)
>>> y
array([[0.47236851, 0.1362846 , 0.16687831],
       [0.57028361, 0.22399912, 0.49424253]])
>>> np.pad(y, (1, 1), 'constant')
# 對二維數(shù)據(jù)填充，如果只傳入2個值，那么第一個默認(rèn)是左邊和上邊的填充，第二個是右邊和下邊的填充
# 可以看出四邊都填充了0
array([[0.        , 0.        , 0.        , 0.        , 0.        ],
       [0.        , 0.47236851, 0.1362846 , 0.16687831, 0.        ],
       [0.        , 0.57028361, 0.22399912, 0.49424253, 0.        ],
       [0.        , 0.        , 0.        , 0.        , 0.        ]])
>>> np.pad(y, (1, 0), 'constant')
# 就左邊和上邊填充0
array([[0.        , 0.        , 0.        , 0.        ],
       [0.        , 0.47236851, 0.1362846 , 0.16687831],
       [0.        , 0.57028361, 0.22399912, 0.49424253]])
>>> np.pad(y, ((0, 1), (1, 1)), 'constant')
# 如果希望上下左右填充的維度都自己控制，那么就傳入2個元組，依次代表上下左右
# 可以看到這里就上面沒填充
array([[0.        , 0.47236851, 0.1362846 , 0.16687831, 0.        ],
       [0.        , 0.57028361, 0.22399912, 0.49424253, 0.        ],
       [0.        , 0.        , 0.        , 0.        , 0.        ]])
>>> np.pad(y, ((0, 1), (0, 1)), 'constant')
# 填充右下
array([[0.47236851, 0.1362846 , 0.16687831, 0.        ],
       [0.57028361, 0.22399912, 0.49424253, 0.        ],
       [0.        , 0.        , 0.        , 0.        ]])

更多參考：https://blog.csdn.net/qq_36332685/article/details/78803622

打印數(shù)組顯示省略問題

numpy中一般對于數(shù)組超過一定大小，就會以省略號形式顯示，因此為了解決該問題，可以通過np.set_printoptions(threshold=行數(shù))設(shè)置超過某個行數(shù)才以省略形式打印，舉例：

>>> np.set_printoptions(threshold=10)
# 超過10行就省略號展示
>>> np.array([[[i] for i in range(100)]])
array([[[ 0],
        [ 1],
        [ 2],
        ...,
        [97],
        [98],
        [99]]])
>>> np.set_printoptions(threshold=100)
# 超過100行...
>>> np.array([[[i] for i in range(100)]])
# 此處省略100行...
>>> np.set_printoptions(threshold=np.inf)
# 直接點，設(shè)置無窮大展示

踩坑記錄

TypeError: only integer scalar arrays can be converted to a scalar index

看看你使用的方法里是不是傳參有誤，例如使用concatenate方法拼接數(shù)組時應(yīng)該把數(shù)組都拼成一個列表/元組放進(jìn)去：

>>> x = np.array([1,2,3])
>>> y = np.array([4,5,6])
>>> np.concatenate(x, y)
# 拼接報錯，因為人家規(guī)定第一個參數(shù)就是接受所有的數(shù)組
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    np.concatenate(x, y)
TypeError: only integer scalar arrays can be converted to a scalar index
>>> np.concatenate((x, y))
# 可以看到拼接成功
array([1, 2, 3, 4, 5, 6])