系統(tǒng)性總結(jié)了 Numpy 所有知識點(diǎn)

1.0. 引入Numpy庫

#引入numpy庫
import numpy as np

1.1. 使用np.array創(chuàng)建數(shù)組

# 1. 使用np.array創(chuàng)建數(shù)組
a = np.array([1,2,3,4])
#打印數(shù)組
print(a)
#查看類型
print(type(a))

1.2. 使用np.arange創(chuàng)建數(shù)組

#2. 使用np.arange創(chuàng)建數(shù)組
#創(chuàng)建0-10步數(shù)為2的數(shù)組 結(jié)果為[0,2,4,6,8]
b = np.arange(0,10,2)

1.3. np.random.random創(chuàng)建數(shù)組

#3. np.random.random創(chuàng)建一個N行N列的數(shù)組
# 其中里面的值是0-1之間的隨機(jī)數(shù)
# 創(chuàng)建2行2列的數(shù)組
c = np.random.random((2,2))

1.4. np.random.randint創(chuàng)建數(shù)組

#4. np.random.randint創(chuàng)建一個N行N列的數(shù)組
# 其中值的范圍可以通過前面2個參數(shù)來指定
# 創(chuàng)建值的范圍為[0,9)的4行4列數(shù)組
d = np.random.randint(0,9,size=(4,4))

1.5. 特殊函數(shù)

#5. 特殊函數(shù)
#5.1 zeros
## N行N列的全零數(shù)組
### 例如：3行3列全零數(shù)組
array_zeros = np.zeros((3,3))
#5.2 ones
## N行N列的全一數(shù)組
### 例如：4行4列全一數(shù)組
array_ones = np.ones((4,4))
#5.3 full
## 全部為指定值的N行N列數(shù)組
### 例如：值為0的2行3列數(shù)組
array_full = np.full((2,3),9)
#5.4 eye
## 生成一個在斜方形上元素為1，其他元素都為0的N行N列矩陣
### 例如：4行4列矩陣
array_eye = np.eye(4)

1.6. 注意

 數(shù)組中的數(shù)據(jù)類型必須一致，要么全部為整型，要么全部為浮點(diǎn)類型，要么全部為字符串類型
 不能同時出現(xiàn)多種數(shù)據(jù)類型

2. 數(shù)組數(shù)據(jù)類型

2.1 數(shù)據(jù)類型

2.2 創(chuàng)建數(shù)組指定數(shù)據(jù)類型

import numpy as np
a = np.array([1,2,3,4,5],dtype='i1')
a = np.array([1,2,3,4,5],dtype=int32)

2.3 查詢數(shù)據(jù)類型

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
d = np.array([Person('test1',18),Person('test2',20)])
print(d)
print(d.dtype)

2.4 修改數(shù)據(jù)類型

f = a.astype('f2')

2.5 總結(jié)

（1） Numpy是基于C語言編寫，引用了C語言的數(shù)據(jù)類型，所以Numpy的數(shù)組中數(shù)據(jù)類型多樣
（2） 不同的數(shù)據(jù)類型有利于處理海量數(shù)據(jù)，針對不同數(shù)據(jù)賦予不同數(shù)據(jù)類型，從而節(jié)省內(nèi)存空間

3. 多維數(shù)組

3.1 數(shù)組維度查詢

import numpy as np
# 數(shù)組維度
## 維度為1
a1 = np.array([1,2,3])
print(a1.ndim)
## 維度為2
a2 = np.array([[1,2,3],[4,5,6]])
print(a2.ndim)
## 維度為3
a3 = np.array([
    [
        [1,2,3],
        [4,5,6]
    ],
    [
        [7,8,9],
        [10,11,12]
    ]
])
print(a3.ndim)

3.2 數(shù)組形狀查詢

a1 = np.array([1,2,3])
# 結(jié)果為(3,)
print(a1.shape)
a2 = np.array([[1,2,3],[4,5,6]])
# 結(jié)果為(2,3)
print(a2.shape)
a3 = np.array([
    [
        [1,2,3],
        [4,5,6]
    ],
    [
        [7,8,9],
        [10,11,12]
    ]
])
# 結(jié)果為(2,2,3)
print(a3.shape)

3.3 修改數(shù)組形狀

a1 = np.array([
    [
        [1,2,3],
        [4,5,6]
    ],
    [
        [7,8,9],
        [10,11,12]
    ]
])
a2 = a1.reshape((2,6))
print(a2)
#結(jié)果為(2, 6)
print(a2.shape)
# 扁平化 （多維數(shù)組轉(zhuǎn)化為一維數(shù)組）
a3 = a2.flatten()
print(a3)
print(a3.ndim)

3.4 數(shù)組元素個數(shù)與所占內(nèi)存

a1 = np.array([
    [
        [1,2,3],
        [4,5,6]
    ],
    [
        [7,8,9],
        [10,11,12]
    ]
])
#數(shù)組的元素個數(shù)
count = a1.size
print(count)
#各元素所占內(nèi)存
print(a1.itemsize)
#各元素數(shù)據(jù)類型
print(a1.dtype)
#數(shù)組所占內(nèi)存
print(a1.itemsize * a1.size)

3.5 總結(jié)

（1）一般情況下，數(shù)組維度最大到三維，一般會把三維以上的數(shù)組轉(zhuǎn)化為二維數(shù)組來計(jì)算
（2）ndarray.ndmin查詢數(shù)組的維度
（3）ndarray.shape可以看到數(shù)組的形狀（幾行幾列），shape是一個元組，里面有幾個元素代表是幾維數(shù)組
（4）ndarray.reshape可以修改數(shù)組的形狀。條件只有一個，就是修改后的形狀的元素個數(shù)必須和原來的個數(shù)一致。比如原來是（2,6），那么修改完成后可以變成（3,4），但是不能變成（1,4）。reshape不會修改原來數(shù)組的形狀，只會將修改后的結(jié)果返回。
（5）ndarray.size查詢數(shù)組元素個數(shù)
（6）ndarray.itemsize可以看到數(shù)組中每個元素所占內(nèi)存的大小，單位是字節(jié)。（1個字節(jié)=8位）

4. 數(shù)組索引和切片

4.1 一維數(shù)組

import numpy as np
# 1. 一維數(shù)組的索引和切片
a1 = np.arange(10)
## 結(jié)果為：[0 1 2 3 4 5 6 7 8 9]
print(a1)
# 1.1 進(jìn)行索引操作
## 結(jié)果為：4
print(a1[4])
# 1.2 進(jìn)行切片操作
## 結(jié)果為：[4 5]
print(a1[4:6])
# 1.3 使用步長
## 結(jié)果為：[0 2 4 6 8]
print(a1[::2])
# 1.4 使用負(fù)數(shù)作為索引
## 結(jié)果為：9
print(a1[-1])

4.2 二維數(shù)組

# 2. 多維數(shù)組
# 通過中括號來索引和切片，在中括號中使用逗號進(jìn)行分割
#逗號前面的是行，逗號后面的是列，如果多維數(shù)組中只有一個值，那么這個值就是行
a2 = np.random.randint(0,10,size=(4,6))
print(a2)
#獲取第0行數(shù)據(jù)
print(a2[0])
#獲取第1,2行數(shù)據(jù)
print(a2[1:3])
#獲取多行數(shù)據(jù) 例0,2,3行數(shù)據(jù)
print(a2[[0,2,3]])
#獲取第二行第一列數(shù)據(jù)
print(a2[2,1])
#獲取多個數(shù)據(jù) 例:第一行第四列、第二行第五列數(shù)據(jù)
print(a2[[1,2],[4,5]])
#獲取多個數(shù)據(jù) 例:第一、二行的第四、五列的數(shù)據(jù)
print(a2[1:3,4:6])
#獲取某一列數(shù)據(jù) 例:第一列的全部數(shù)據(jù)
print(a2[:,1])
#獲取多列數(shù)據(jù) 例:第一、三列的全部數(shù)據(jù)
print(a2[:,[1,3]])

4.3 總結(jié)

1. 如果數(shù)組是一維的，那么索引和切片就是和python的列表是一樣的
2. 如果是多維的（這里以二維為例），那么在中括號中，給兩個值，兩個值是通過逗號分隔的，逗號前面的是行，逗號后面的是列。如果中括號中只有一個值，那么就是代表行。
3. 如果是多維數(shù)組（以二維為例），那么行的部分和列的部分，都是遵循一維數(shù)組的方式，可以使用整型、切片，還可以使用中括號的形式代表不連續(xù)的。比如a[[1,2],[3,4]]，那么返回的就是第一行第三列、第二行第四列的兩個值。

5. 布爾索引

#生成1-24的4行6列的二維數(shù)組
a2 = np.arange(24).reshape((4,6))
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a2[a2<10]
#array([ 0,  1,  2,  3,  4, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,23])
a2[(a2<5) | (a2>10)]

5.1總結(jié)

（1） 布爾索引是通過相同數(shù)據(jù)上的True還是False來進(jìn)行提取的。
（2） 提取條件可以為一個或多個，當(dāng)提取條件為多個時使用&代表且，使用|代表或
（3） 當(dāng)提取條件為多個時，每個條件要使用圓括號括起來

6. 數(shù)組元素值的替換

6.1 方式一：索引

#利用索引可以做值的替換，把滿足條件的位置的值替換成其他值
#創(chuàng)建數(shù)組元素值為[0,10)隨機(jī)數(shù)的3行5列數(shù)組
a3 = np.random.randint(0,10,size=(3,5))
print(a3)
#將a3數(shù)組第一行數(shù)據(jù)全部更換為0
a3[1] = 0
print(a3)
#將a3數(shù)組第一行數(shù)據(jù)更換為[1,2,3,4,5] -- 數(shù)據(jù)個數(shù)要對應(yīng)
a3[1] = np.array([1,2,3,4,5])
print(a3)

6.2 方式二：條件索引

#數(shù)組中值小于3的元素全部替換為1
a3[a3 < 3] = 1
print(a3)

6.3 方式三：函數(shù)

#將a3數(shù)組中小于5的值替換為0，剩余值替換為1
result = np.where(a3<5,0,1)
result

6.4 總結(jié)

（1）使用索引或者切片來替換值
（2）使用條件索引來替換值
（3）使用where函數(shù)來實(shí)現(xiàn)替換值

7. 數(shù)組的廣播機(jī)制

7.0. 數(shù)組的廣播原則

如果兩個數(shù)組的后緣維度（即從末尾開始算起的維度）的軸長度相符或其中一方的長度為1，則認(rèn)為他們是廣播兼容的。廣播會在全是和（或）長度為1的維度上進(jìn)行。
案例分析：

1. shape為(3,8,2)的數(shù)組能和(8,3)的數(shù)組進(jìn)行運(yùn)算嗎？分析：不能，因?yàn)榘惭b廣播原則，從后面網(wǎng)前面數(shù)，(3,8,2)和(8,3)中的2和3不相等，所以不能進(jìn)行運(yùn)算
2. shape為(3,8,2)的數(shù)組能和(8,1)的數(shù)組進(jìn)行運(yùn)算嗎？分析：能，因?yàn)榘凑諒V播原則，從后面往前面數(shù)，(3,8,2)和(8,1)中的2和1雖然不相等，但因?yàn)橛幸环降拈L度為1，所以能參加運(yùn)算
3. shape為(3,1,8)的數(shù)組能和(8,1)的數(shù)組進(jìn)行運(yùn)算嗎？分析：能，因?yàn)榘凑諒V播原則，從后面往前面數(shù)，(3,1,8)和(8,1)中的4和1雖然不相等且1和8不相等，但是因?yàn)檫@兩項(xiàng)中有一方的長度為1，所以能參加運(yùn)算

7.1. 數(shù)組與數(shù)字運(yùn)算

import numpy as np
#生成3行5列 值為0-5隨機(jī)整數(shù)的數(shù)組
a1 = np.random.randint(0,5,size=(3,5))
#數(shù)組中的所有元素都乘2
print(a1*2)
#數(shù)組中所有的元素只保留2位小數(shù)
print(a1.round(2))

7.2. 數(shù)組與數(shù)組運(yùn)算

#數(shù)組形狀一致時 各個元素相加減(滿足數(shù)組廣播機(jī)制)
a2 = np.random.randint(0,5,size=(3,5))
a1+a2
#形狀不一致的數(shù)組不能相加減(不滿足數(shù)組廣播機(jī)制)
a3 = np.random.randint(0,5,size=(3,4))
# a1+a3 報錯
#兩個數(shù)組行數(shù)相同 ，其中一個數(shù)組列數(shù)為1(滿足數(shù)組廣播機(jī)制)
a4 = np.random.randint(0,5,size=(3,1))
a1+a4
#兩個數(shù)組列數(shù)相同 ，其中一個數(shù)組行數(shù)為1(滿足數(shù)組廣播機(jī)制)
a5 = np.random.randint(0,5,size=(1,5))
a1+a5

7.3總結(jié)

(1) 數(shù)組和數(shù)字直接進(jìn)行運(yùn)算是沒有問題的
(2) 兩個shape想要的數(shù)組是可以進(jìn)行運(yùn)算的
(3) 如果兩個shape不同的數(shù)組，想要進(jìn)行運(yùn)算，那么需要看他們是否滿足廣播原則

8. 數(shù)組形狀的操作

8.1. 數(shù)組形狀的改變

8.1.1 reshape與resize

import numpy as np
# reshape與resize都是用來修改數(shù)組形狀的，但是存在不同
a1 = np.random.randint(0,10,size=(3,4))
# reshape是將數(shù)組轉(zhuǎn)換成指定的形狀，然后返回轉(zhuǎn)換后的結(jié)果，對于原數(shù)組的形狀是不會發(fā)生改變的
a2 = a1.reshape((2,6))
# resize是將數(shù)組轉(zhuǎn)換成指定的形狀，會直接修改數(shù)組本身，并且不會返回任何值
a1.resize((4,3))
print(a1)

8.1.2 flatten與ravel

 # faltten與ravel都是將多維數(shù)組轉(zhuǎn)換為一維數(shù)組，但是存在不同
 a3 = np.random.randint(0,10,size=(3,4))
 # flatten是將數(shù)組轉(zhuǎn)換為一維數(shù)組后，然后將這個拷貝返回回去，然后后續(xù)對這個返回值進(jìn)行修改不會影響之前的數(shù)組
 a4 = a3.flatten()
 a4[0] = 100
 # 結(jié)果為：2
 print(a3[0,0])
 # 結(jié)果為：100
 print(a4[0])
 # ravel是將數(shù)組轉(zhuǎn)換為一維數(shù)組后，將這個視圖（引用）返回回去，后續(xù)對這個返回值進(jìn)行修改會影響之前的數(shù)組
 a5 = a3.ravel()
 a5[0] = 100
 # 結(jié)果為：100
 print(a3[0,0])
  # 結(jié)果為：100
 print(a5[0])

8.2 數(shù)組的疊加

#vstack代表在垂直方向疊加，如果想要疊加成功，那么列數(shù)必須一致
#hstack代表在水平方向疊加，如果想要疊加成功，那么行數(shù)必須一致
#concatenate可以手動的指定axis參數(shù)具體在哪個方向疊加
##（1）如果axis=0，代表在水平方向疊加
##（2）如果axis=1，代表在垂直方向疊加
##（3）如果axis=None，會先進(jìn)行疊加，再轉(zhuǎn)化為1維數(shù)組
vstack1 = np.random.randint(0,10,size=(3,4))
print(vstack1)
vstack2 = np.random.randint(0,10,size=(2,4))
print(vstack2)

#垂直方向疊加的兩種方式
vstack3 = np.vstack([vstack1,vstack2])
print(vstack3)
vstack4 = np.concatenate([vstack1,vstack2],axis=0)
print(vstack4)

h1 = np.random.randint(0,10,size=(3,4))
print(h1)
h2 = np.random.randint(0,10,size=(3,1))
print(h2)

#水平方向疊加的兩種方式
h3 = np.hstack([h2,h1])
print(h3)
h4 = np.concatenate([h2,h1],axis=1)
print(h4)

#先識別垂直疊加或水平疊加 后轉(zhuǎn)換為一維數(shù)組
h5 = np.concatenate([h2,h1],axis=None)
print(h5)

8.3. 數(shù)組的切割

#hsplit代表在水平方向切割，按列進(jìn)行切割。
#hsplit切割方式兩種，第一種直接指定平均切割成多少列，第二種是指定切割的下標(biāo)值
#vsplit代表在垂直方向切割，按行進(jìn)行切割。切割方式與hsplit相同
#split/array_split是手動的指定axis參數(shù)，axis=0代表按行進(jìn)行切割，axis=1代表按列進(jìn)行切割
hs1 = np.random.randint(0,10,size=(3,4))
print(hs1)
#水平方向平均分為2份  (要求列數(shù)可被此數(shù)整除)
np.hsplit(hs1,2)
#水平方向分為1,1,2列（在下標(biāo)為1,2處切割）
np.hsplit(hs1,(1,2))

vs1 = np.random.randint(0,10,size=(4,5))
print(vs1)
#垂直方向平均分為4份
np.vsplit(vs1,4)
#垂直方向分為1,2,1
np.vsplit(vs1,(1,3))

#split/array_split(array,indicate_or_section,axis):用于指定切割方式，在切割的時候需要指定按照行還是列，axis=1代表按照列，axis=0代表按照行
#按列平均切割
np.split(hs1,4,axis=1)
#按行平均切割
np.split(vs1,4,axis=0)

8.4. 矩陣轉(zhuǎn)置

#通過ndarray.T的形式進(jìn)行轉(zhuǎn)置
t1 = np.random.randint(0,10,size=(3,4))
print(t1)
#數(shù)組t1轉(zhuǎn)置
t1.T

#矩陣相乘
t1.dot(t1.T)

#通過ndarray.transpose()進(jìn)行轉(zhuǎn)置
#transpose返回的是一個View，所以對返回值上進(jìn)行修改會影響到原來的數(shù)組。
t2 = t1.transpose()
t2

8.5 總結(jié)

1. 數(shù)據(jù)的形狀改變
（1）reshape和resize都是重新定義形狀的，但是reshape不會修改數(shù)組本身，而是將修改后的結(jié)果返回回去，而resize是直接修改數(shù)組本身的
（2）flatten和ravel都是用來將數(shù)組變成一維數(shù)組的，并且他們都不會對原數(shù)組造成修改，但是flatten返回的是一個拷貝，所以對flatten的返回值的修改不會影響到原來數(shù)組，而ravel返回的是一個View，那么對返回值的修改會影響到原來數(shù)組的值
2. 數(shù)據(jù)的疊加
（1）hstack代表在水平方向疊加，如果想要疊加成功，那么他們的行必須一致
（2）vastack代表在垂直方向疊加，如果想要疊加成功，那么他們的列必須一致
（3）concatenate可以手動指定axis參數(shù)具體在哪個方向疊加，如果axis=0，代表在水平方向疊加，如果axis=1，代表在垂直方向疊加，如果axis=None，那么會先進(jìn)行疊加，再轉(zhuǎn)化成一維數(shù)組
3. 數(shù)組的切割
（1）hsplit代表在水平方向切割，按列進(jìn)行切割。切割方式有兩種，第一種就是直接指定平均切割成多少列，第二種就是指定切割的下標(biāo)值
（2）vsplit代表在垂直方向切割，按行進(jìn)行切割。切割方式與hsplit一致。
（3）split/array_split是手動的指定axis參數(shù)，axis=0代表按行進(jìn)行切割，axis=1代表按列進(jìn)行切割
4. 矩陣轉(zhuǎn)置
（1）可以通過ndarray.T的形式進(jìn)行轉(zhuǎn)置
（2）也可以通過ndarray.transpose()進(jìn)行轉(zhuǎn)置，這個方法返回的是一個View，所以對返回值上進(jìn)行修改，會影響到原來的數(shù)組

9. View或者淺拷貝

9.1 不拷貝

如果只是簡單的賦值，那么就不會進(jìn)行拷貝

import numpy as np
a = np.arange(12)
#這種情況不會進(jìn)行拷貝
b = a
#返回True，說明b和a是相同的
print(b is a)

9.2 淺拷貝

有些情況，會進(jìn)行變量的拷貝，但是他們所指向的內(nèi)存空間都是一樣的，那么這種情況叫做淺拷貝，或者叫做View(視圖)

c = a.view()
#返回false,說明c與a在棧區(qū)空間不同，但是所指向的內(nèi)存空間是一樣的
print(c is a)
#對c的值修改 同時也會對a進(jìn)行修改
c[0] = 100
#array([100,1,2,3,4,5,6,7,8,9,10,11])
print(a)

9.3 深拷貝

將之前數(shù)據(jù)完完整整的拷貝一份放到另外一塊內(nèi)存空間中，這樣就是兩個完全不同的值了

d = a.copy()
#返回False 說明在不同棧區(qū)
print(d is a)
#數(shù)組d值被修改，數(shù)組a值不會被修改 說明內(nèi)存空間不同
d[1]=200

9.4 總結(jié)

在數(shù)組操作中分成三種拷貝：
（1）不拷貝：直接賦值，那么棧區(qū)沒有拷貝，只是用同一個棧區(qū)定義了不同的名稱
（2）淺拷貝：只拷貝棧區(qū)，棧區(qū)指定的堆區(qū)并沒有拷貝
（3）深拷貝：棧區(qū)和堆區(qū)都拷貝

10. 文件操作

10.1 操作CSV文件

10.1.1 文件保存

np.savetxt(frame,array,fmt="%.18e",delimiter=None)
函數(shù)功能：將數(shù)組保存到文件中
參數(shù)說明：
· frame：文件、字符串或產(chǎn)生器，可以是.gz或.bz2的壓縮文件
· array：存入文件的數(shù)組
· fmt：寫入文件的格式，例如：%d %.2f %.18e
· delimter：分割字符串，默認(rèn)是空格

import numpy as np
scores = np.random.randint(0,100,size=(10,2))

#保存csv文件
np.savetxt("score.csv",scores,fmt="%d",delimiter=",",header="英語,數(shù)學(xué)",comments="")

10.1.2 讀取文件

np.loadtxt(frame,dtype=np.float,delimiter=None,unpack=False)
函數(shù)功能：將數(shù)組保存到文件中
參數(shù)說明：
· frame：文件、字符串或產(chǎn)生器，可以是.gz或.bz2的壓縮文件
· dtype：數(shù)據(jù)類型，可選
· delimiter：分割字符串，默認(rèn)是任何空格
· skiprows：跳過前面x行
· usecols：讀取指定的列，用元組組合
· unpack：如果True，讀取出來的數(shù)組是轉(zhuǎn)置后的

#讀取csv文件 跳過第一行的表頭
b = np.loadtxt("score.csv",dtype=np.int,delimiter=",",skiprows=1)
b

10.2 np獨(dú)有的存儲解決方案

numpy中還有一種獨(dú)有的存儲解決方案。文件名是以.npy或者npz結(jié)尾的。以下是存儲和加載的函數(shù)：

1. 存儲
np.save(fname,a rray)
或np.savez(fname,array)
其中，前者函數(shù)的擴(kuò)展名是.npy，后者的擴(kuò)展名是.npz，后者是經(jīng)過壓縮的。

2.加載
np.load(fname)

c = np.random.randint(0,10,size=(2,3))
#存儲
np.save("c",c)
#讀取
c1 = np.load("c.npy")
c1

10.3 總結(jié)

1. np.savetxt和np.loadtxt一般用來操作CSV文件，可以設(shè)置header，但是不能存儲3維以上的數(shù)組。
2. np.save和np.load一般用來存儲非文本類型的文件，不可以設(shè)置header，但是可以存儲3維以上的數(shù)組
3. 如果想專門的操作csv文件，還存在另一個模塊叫做csv，這個模塊是python內(nèi)置的，不需要安裝

11. NAN和INF值處理

11.1 介紹

NAN：Not A number,不是一個數(shù)字的意思，但是他是浮點(diǎn)類型的，所以想要進(jìn)行數(shù)據(jù)操作的時候需要注意他的類型

import numpy as np
data = np.random.randint(0,10,size=(3,5))
data = data.astype(np.float)
#將數(shù)組中某個位置的值設(shè)置為NAN
data[0,1]=np.NAN
data

INF：Infinity，代表的是無窮大的意思，也是屬于浮點(diǎn)類型。np.inf表示正無窮大，-np.inf表示負(fù)無窮大，一般在出現(xiàn)除數(shù)為0的時候?yàn)闊o窮大。比如2/0

11.2 NAN特點(diǎn)

1. NAN和NAN不相等。比如 np.NAN != np.NAN 這個條件是成立的
2. NAN和任何值做運(yùn)算，結(jié)果都是NAN

11.3 處理缺失值的方式

11.3.1 刪除缺失值

有時候，我們想要將數(shù)組中的NAN刪掉，那么我們可以換一種思路，就是只提取不為NAN的值

#第一種方式： 刪除所有NAN的值，因?yàn)閯h除了值后數(shù)組將不知道該怎么變化，所以會被變成一維數(shù)組
data[~np.isnan(data)]

#第二種方式： 刪除NAN所在行
## 獲取哪些行有NAN
lines = np.where(np.isnan(data))[0]
## 使用delete方法刪除指定的行，lines表示刪除的行號，axis=0表示刪除行
np.delete(data,lines,axis=0)

11.3.2 用其他值進(jìn)行替代

#從文件中讀取數(shù)據(jù)
scores = np.loadtxt("scores.csv",delimiter=",",skiprows=1,dtype=np.str)
#將空數(shù)據(jù)轉(zhuǎn)換成NAN
scores[scores == ""] = np.NAN
#轉(zhuǎn)化成float類型
scores1 = scores.astype(np.float)
#將NAN替換為0
scores1[np.isnan(scores1)]=0
#除了delete用axis=0表示行以外，其他的大部分函數(shù)都是axis=1來表示行
#對指定軸求和 axis=1按行
scores1.sum(axis=1)

#將空值替換為均值
#對scores進(jìn)行深拷貝
scores2 = scores.astype()
#循環(huán)遍歷每一列
for x in range(score2.shape[1]):
    col = scores2[:,x]
    #去除該列中值為NAN
    non_nan_col = col[~np.isnan(col)]
    #求平均值
    mean = non_nan_col.mean()
    #將該列中值為NAN的數(shù)值替換為平均值
    col[np.isnan(col)] = mean
scores2

11.4 總結(jié)

（1）NAN：Not A Number的簡寫，不是一個數(shù)字，但是是屬于浮點(diǎn)類型
（2）INF：無窮大，在除數(shù)為0的情況下會出現(xiàn)INF
（3）NAN和所有的值進(jìn)行計(jì)算結(jié)果都是等于NAN
（4）NAN != NAN
（5）可以通過np.isnan來判斷某個值是不是NAN
（6）處理值的時候，可以通過刪除NAN的形式進(jìn)行處理，也可以通過值的替換進(jìn)行處理
（7）np.delete比較特殊，通過axis=0來代表行，而其他大部分函數(shù)通過axis=1來代表行

12. random模塊

12.1 np.random.seed

用于指定隨機(jī)數(shù)生成時所用算法開始的整數(shù)值，如果使用相同的seed()值，則每次生成的隨機(jī)數(shù)都相同，如果不設(shè)置這個值，則系統(tǒng)根據(jù)時間來自己選擇這個值，此時每次生成的隨機(jī)數(shù)因時間差異不同。一般沒有特殊要求不用設(shè)置。

np.random.seed(1)
#打印0.417022004702574
np.random.rand()
#打印其他的值，因?yàn)殡S機(jī)數(shù)種子支隊(duì)下一次隨機(jī)數(shù)的產(chǎn)生會有影響
np.random.rand()

12.2 np.random.rand

生成一個值為 [0,1) 之間的數(shù)組，形狀由參數(shù)指定，如果沒有參數(shù)，那么將返回一個隨機(jī)值

#產(chǎn)生隨機(jī)數(shù)
np.random.rand()
#產(chǎn)生隨機(jī)數(shù)組 兩行三列
np.random.rand(2,3)

12.3 np.random.randn

生成均值(μ)為0，標(biāo)準(zhǔn)差(σ)為1的標(biāo)準(zhǔn)正態(tài)分布的值

#生成一個2行3列的數(shù)組，數(shù)組中的值都滿足標(biāo)準(zhǔn)正態(tài)分布
data = np.random.randn(2,3)
data

12.4 np.random.randint

生成指定范圍內(nèi)的隨機(jī)數(shù)，并且可以通過size參數(shù)指定維度

#生成值在0-10之間，3行5列的數(shù)組
data1 = np.random.randint(10,size=(3,5))
#生成值在1-20之間，3行6列的數(shù)組
data2 = np.random.randint(1,20,size=(3,6))

12.5 np.random.choice

從一個列表或者數(shù)組中，隨機(jī)進(jìn)行采樣?；蛘呤菑闹付ǖ膮^(qū)間中進(jìn)行采樣，采樣個數(shù)可以通過參數(shù)

#從數(shù)組中隨機(jī)選擇三個值
np.random.choice(data,3)
#從數(shù)組中獲取值組成新的數(shù)組
np.random.choice(data,size=(3,4))
#從指定值隨機(jī)取值 (示例:從0-10之間隨機(jī)取3個值)
np.random.choice(10,3)

12.6 np.random.shuffle

把原來數(shù)組的元素的位置打亂

a = np.arange(10)
#將數(shù)組a的元素的位置都會進(jìn)行隨機(jī)更換
#shuffle沒有返回值，直接打亂原數(shù)組位置
np.random.shuffle(a)
a

13. Axis理解

13.1 Axis

簡單來說，最外面的括號代表著axis=0，依次往里的括號對應(yīng)的axis的計(jì)數(shù)就依次加1

如下圖，最外面的括號就是axis=0，里面兩個子括號axis=1

操作方式：如果指定軸進(jìn)行相關(guān)的操作，那么他會使用軸下的每一個直接子元素的第0個，第1個，第2個…分別進(jìn)行相關(guān)的操作
示例：

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

1.求 x 數(shù)組在axis = 0 和 axis=1 兩種情況下的和

#結(jié)果為[2,4]
x.sum(axis=0)

分析：按照axis=0的方式相加，那么就會把最外面軸下的所有直接子元素的第0個位置進(jìn)行相加，第1個位置進(jìn)行相加…依次類推，得到的就是 0+2 以及 2+3 ，然后進(jìn)行相加，得到的結(jié)果就是 [2,4]

2.用np.max求 axis=0 和 axis=1 兩種情況下的最大值

np.random.seed(100)
x = np.random.randint(1,10,size=(3,5))
#輸出結(jié)果為：
#[[9 9 4 8 8]
# [1 5 3 6 3]
# [3 3 2 1 9]]
print(x)
#結(jié)果為[9, 9, 4, 8, 9]
x.max(axis=0)
#結(jié)果為[9, 6, 9]
x.max(axis=1)

分析：按照axis=0進(jìn)行求最大值，那么就會在最外面軸里面找直接子元素，然后將每個子元素的第0個值放在一起求最大值，將第1個值放在一起求最大值，以此類推。而如果axis=1，那么就是拿到每個直接子元素，然后求每個子元素中的最大值

3.用 np.delete 在 axis=0 和 axis=1 兩種情況下刪除元素

np.random.seed(100)
x = np.random.randint(1,10,size=(3,5))
#輸出結(jié)果為：
#[[9 9 4 8 8]
# [1 5 3 6 3]
# [3 3 2 1 9]]
print(x)
#刪除第0行
#結(jié)果為：
#[[1, 5, 3, 6, 3],
# [3, 3, 2, 1, 9]]
np.delete(x,0,axis=0)

分析：np.delete是個例外，按照 axis=0 的方式進(jìn)行刪除，那么會首先找到最外面的括號下的直接子元素的第0個，然后直接刪掉，剩下最后一行的數(shù)據(jù)。同理，如果我們按照 axis=1 進(jìn)行刪除，那么會把第一列的數(shù)據(jù)刪掉

13.2 三維數(shù)組及多維數(shù)組

#生成一個三維數(shù)組
#[[[ 0,  1,  2,  3,  4,  5],
#       [ 6,  7,  8,  9, 10, 11]],

#       [[12, 13, 14, 15, 16, 17],
#        [18, 19, 20, 21, 22, 23]]]
y = np.arange(24).reshape(2,2,6)
#取最大值
#結(jié)果為：
#[[12, 13, 14, 15, 16, 17],
#       [18, 19, 20, 21, 22, 23]]
y.max(axis=0)

13.3 總結(jié)

（1）最外面的括號代表著 axis=0，依次往里的括號對應(yīng)的 axis 的計(jì)數(shù)就依次加1
（2）操作方式：如果指定軸進(jìn)行相關(guān)的操作，那么他會使用軸下面的每個直接子元素的第0個，第1個，第2個...分別進(jìn)行相關(guān)的操作
（3）np.delete是直接刪除指定軸下的第幾個直接子元素

14. 通用函數(shù)

14.1 一元函數(shù)

14.2 二元函數(shù)

14.3 聚合函數(shù)

補(bǔ)充：使用np.sum或者是a.sum即可實(shí)現(xiàn)。并且在使用的時候，可以指定具體哪個軸。同樣python中也內(nèi)置了sum函數(shù)，但是python內(nèi)置的sum函數(shù)執(zhí)行效率沒有np.sum那么高。

14.4 布爾數(shù)組的函數(shù)

#查看數(shù)組中是不是所有元素都為0 
#方式一
np.all(a==0)
#方式二
(a==0).all()

#查看數(shù)組中是否有等于0的數(shù)
#方式一
np.any(a==0)
#方式二
(a==0).any()

14.5 排序

14.5.1 np.sort

函數(shù)說明：指定軸進(jìn)行排序。默認(rèn)是使用數(shù)組的最后一個軸進(jìn)行排序。

還有ndarray.sort()，這個方法會直接影響到原來的數(shù)組，而不是返回一個新的排序后的數(shù)組

#生成數(shù)組
a = np.random.randint(0,10,size=(5,5))
#按照行進(jìn)行排序，因?yàn)樽詈笠粋€軸是1，那么就是將最里面的元素進(jìn)行排序
np.sort(a)
#按照列進(jìn)行排序，因?yàn)橹付薬xis=0
np.sort(a,axis=0)
#該方法進(jìn)行排序會影響原數(shù)組
a.sort()

14.5.2 np.argsort

函數(shù)說明：返回排序后的下標(biāo)值。

#返回排序后的下標(biāo)值
np.argsort(a)

14.5.3 np.sort (降序)

np.sort()默認(rèn)會采用升序排序，用一下方案來實(shí)現(xiàn)降序排序

#方式一：使用負(fù)號
-np.sort(-a)

#方式二：使用sort和argsort以及take
#排序后的結(jié)果就是降序的
indexes = np.argsort(-a)
#從a中根據(jù)下標(biāo)提取相應(yīng)的元素
np.take(a,indexes)

14.6 其他函數(shù)

14.6.1 np.apply_along_axis

函數(shù)說明：沿著某個軸執(zhí)行指定的函數(shù)

#求數(shù)組a按行求平均值，并且要去掉最大值和最小值
#函數(shù)
def get_mean(x):
    #排除最大值和最小值后求平均值
   y=x[np.logical_and(x!=x.max,x!=x.min)].mean()
    return y
#方式一：調(diào)用函數(shù)
np.apply_along_axis(get_mean,axis=1,arr=c)
#方式二：lambda表達(dá)式
np.apply_along_axis(lambda x:x[np.logical_and(x!=x.max,x!=x.min)].mean(),axis=1,arr=c)

14.6.2 np.linspace

函數(shù)說明：用來將指定區(qū)間內(nèi)的值平均分成多少份

#將0-10分成12份，生成一個數(shù)組
np.linspace(0,10,12)

14.6.3 np.unique

函數(shù)說明：返回數(shù)組中的唯一值

#返回數(shù)組a中的唯一值
np.unique(d)
#返回數(shù)組a中的唯一值，并且會返回每個唯一值出現(xiàn)的次數(shù)
np.unique(d,return_counts=True)