上下滑動查看更多目錄
1. 創(chuàng)建數(shù)組的幾種方式
1.0. 引入Numpy庫
1.1. 使用np.array創(chuàng)建數(shù)組
1.2. 使用np.arange創(chuàng)建數(shù)組
1.3. np.random.random創(chuàng)建數(shù)組
1.4. np.random.randint創(chuàng)建數(shù)組
1.5. 特殊函數(shù)
1.6. 注意
2. 數(shù)組數(shù)據(jù)類型
2.1 數(shù)據(jù)類型
2.2 創(chuàng)建數(shù)組指定數(shù)據(jù)類型
2.3 查詢數(shù)據(jù)類型
2.4 修改數(shù)據(jù)類型
2.5 總結
3. 多維數(shù)組
3.1 數(shù)組維度查詢
3.2 數(shù)組形狀查詢
3.3 修改數(shù)組形狀
3.4 數(shù)組元素個數(shù)與所占內(nèi)存
3.5 總結
4. 數(shù)組索引和切片
4.1 一維數(shù)組
4.2 二維數(shù)組
4.3 總結
5. 布爾索引
5.1總結
6. 數(shù)組元素值的替換
6.1 方式一：索引
6.2 方式二：條件索引
6.3 方式三：函數(shù)
6.4 總結
7. 數(shù)組的廣播機制
7.0. 數(shù)組的廣播原則
7.1. 數(shù)組與數(shù)字運算
7.2. 數(shù)組與數(shù)組運算
7.3總結
8. 數(shù)組形狀的操作
8.1. 數(shù)組形狀的改變
8.2 數(shù)組的疊加
8.3. 數(shù)組的切割
8.4. 矩陣轉置
8.5 總結
9. View或者淺拷貝
9.1 不拷貝
9.2 淺拷貝
9.3 深拷貝
9.4 總結
10. 文件操作
10.1 操作CSV文件
10.2 np獨有的存儲解決方案
10.3 總結
11. NAN和INF值處理
11.1 介紹
11.2 NAN特點
11.3 處理缺失值的方式
11.4 總結
12. random模塊
12.1 np.random.seed
12.2 np.random.rand
12.3 np.random.randn
12.4 np.random.randint
12.5 np.random.choice
12.6 np.random.shuffle
13. Axis理解
13.1 Axis
13.2 三維數(shù)組及多維數(shù)組
13.3 總結
14. 通用函數(shù)
14.1 一元函數(shù)
14.2 二元函數(shù)
14.3 聚合函數(shù)
14.4 布爾數(shù)組的函數(shù)
14.5 排序
14.5.2 np.argsort
14.5.3 np.sort（降序）
14.6 其他函數(shù)
#引入numpy庫
import numpy as np
# 1. 使用np.array創(chuàng)建數(shù)組
a = np.array([1,2,3,4])
#打印數(shù)組
print(a)
#查看類型
print(type(a))
#2. 使用np.arange創(chuàng)建數(shù)組
#創(chuàng)建0-10步數(shù)為2的數(shù)組 結果為[0,2,4,6,8]
b = np.arange(0,10,2)
#3. np.random.random創(chuàng)建一個N行N列的數(shù)組
# 其中里面的值是0-1之間的隨機數(shù)
# 創(chuàng)建2行2列的數(shù)組
c = np.random.random((2,2))
#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))
#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)
數(shù)組中的數(shù)據(jù)類型必須一致，要么全部為整型，要么全部為浮點類型，要么全部為字符串類型
不能同時出現(xiàn)多種數(shù)據(jù)類型
| 數(shù)據(jù)類型 | 描述 | 唯一標識符 |
|---|---|---|
| bool | 用一個字節(jié)存儲的布爾類型（True或False） | b |
| int8 | 一個字節(jié)大小，-128 至 127 | i1 |
| int16 | 整數(shù)，16 位整數(shù)(-32768 ~ 32767) | i2 |
| int32 | 整數(shù)，32 位整數(shù)(-2147483648 ~ 2147483647) | i4 |
| int64 | 整數(shù)，64 位整數(shù)(-9223372036854775808 ~ 9223372036854775807) | i8 |
| uint8 | 無符號整數(shù)，0 至 255 | u1 |
| uint16 | 無符號整數(shù)，0 至 65535 | u2 |
| uint32 | 無符號整數(shù)，0 至 2 ** 32 - 1 | u4 |
| uint64 | 無符號整數(shù)，0 至 2 ** 64 - 1 | u8 |
| float16 | 半精度浮點數(shù)：16位，正負號1位，指數(shù)5位，精度10位 | f2 |
| float32 | 單精度浮點數(shù)：32位，正負號1位，指數(shù)8位，精度23位 | f4 |
| float64 | 單精度浮點數(shù)：64位，正負號1位，指數(shù)11位，精度52位 | f8 |
| complex64 | 復數(shù)，分別用兩個32位浮點數(shù)表示實部和虛部 | c8 |
| complex128 | 復數(shù)，分別用兩個64位浮點數(shù)表示實部和虛部 | c16 |
| object_ | python對象 | O |
| string_ | 字符串 | S |
| unicode_ | unicode類型 | U |
import numpy as np
a = np.array([1,2,3,4,5],dtype='i1')
a = np.array([1,2,3,4,5],dtype=int32)
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)
f = a.astype('f2')
（1） Numpy是基于C語言編寫，引用了C語言的數(shù)據(jù)類型，所以Numpy的數(shù)組中數(shù)據(jù)類型多樣
（2） 不同的數(shù)據(jù)類型有利于處理海量數(shù)據(jù)，針對不同數(shù)據(jù)賦予不同數(shù)據(jù)類型，從而節(jié)省內(nèi)存空間
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)
a1 = np.array([1,2,3])
# 結果為(3,)
print(a1.shape)
a2 = np.array([[1,2,3],[4,5,6]])
# 結果為(2,3)
print(a2.shape)
a3 = np.array([
[
[1,2,3],
[4,5,6]
],
[
[7,8,9],
[10,11,12]
]
])
# 結果為(2,2,3)
print(a3.shape)
a1 = np.array([
[
[1,2,3],
[4,5,6]
],
[
[7,8,9],
[10,11,12]
]
])
a2 = a1.reshape((2,6))
print(a2)
#結果為(2, 6)
print(a2.shape)
# 扁平化 （多維數(shù)組轉化為一維數(shù)組）
a3 = a2.flatten()
print(a3)
print(a3.ndim)
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)
（1）一般情況下，數(shù)組維度最大到三維，一般會把三維以上的數(shù)組轉化為二維數(shù)組來計算
（2）ndarray.ndmin查詢數(shù)組的維度
（3）ndarray.shape可以看到數(shù)組的形狀（幾行幾列），shape是一個元組，里面有幾個元素代表是幾維數(shù)組
（4）ndarray.reshape可以修改數(shù)組的形狀。條件只有一個，就是修改后的形狀的元素個數(shù)必須和原來的個數(shù)一致。比如原來是（2,6），那么修改完成后可以變成（3,4），但是不能變成（1,4）。reshape不會修改原來數(shù)組的形狀，只會將修改后的結果返回。
（5）ndarray.size查詢數(shù)組元素個數(shù)
（6）ndarray.itemsize可以看到數(shù)組中每個元素所占內(nèi)存的大小，單位是字節(jié)。（1個字節(jié)=8位）
import numpy as np
# 1. 一維數(shù)組的索引和切片
a1 = np.arange(10)
## 結果為：[0 1 2 3 4 5 6 7 8 9]
print(a1)
# 1.1 進行索引操作
## 結果為：4
print(a1[4])
# 1.2 進行切片操作
## 結果為：[4 5]
print(a1[4:6])
# 1.3 使用步長
## 結果為：[0 2 4 6 8]
print(a1[::2])
# 1.4 使用負數(shù)作為索引
## 結果為：9
print(a1[-1])
# 2. 多維數(shù)組
# 通過中括號來索引和切片，在中括號中使用逗號進行分割
#逗號前面的是行，逗號后面的是列，如果多維數(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]])
1. 如果數(shù)組是一維的，那么索引和切片就是和python的列表是一樣的
2. 如果是多維的（這里以二維為例），那么在中括號中，給兩個值，兩個值是通過逗號分隔的，逗號前面的是行，逗號后面的是列。如果中括號中只有一個值，那么就是代表行。
3. 如果是多維數(shù)組（以二維為例），那么行的部分和列的部分，都是遵循一維數(shù)組的方式，可以使用整型、切片，還可以使用中括號的形式代表不連續(xù)的。比如a[[1,2],[3,4]]，那么返回的就是第一行第三列、第二行第四列的兩個值。
#生成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)]
（1） 布爾索引是通過相同數(shù)據(jù)上的True還是False來進行提取的。
（2） 提取條件可以為一個或多個，當提取條件為多個時使用&代表且，使用|代表或
（3） 當提取條件為多個時，每個條件要使用圓括號括起來
#利用索引可以做值的替換，把滿足條件的位置的值替換成其他值
#創(chuàng)建數(shù)組元素值為[0,10)隨機數(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ù)要對應
a3[1] = np.array([1,2,3,4,5])
print(a3)
#數(shù)組中值小于3的元素全部替換為1
a3[a3 < 3] = 1
print(a3)
#將a3數(shù)組中小于5的值替換為0，剩余值替換為1
result = np.where(a3<5,0,1)
result
（1）使用索引或者切片來替換值
（2）使用條件索引來替換值
（3）使用where函數(shù)來實現(xiàn)替換值
如果兩個數(shù)組的后緣維度（即從末尾開始算起的維度）的軸長度相符或其中一方的長度為1，則認為他們是廣播兼容的。廣播會在全是和（或）長度為1的維度上進行。
案例分析：
import numpy as np
#生成3行5列 值為0-5隨機整數(shù)的數(shù)組
a1 = np.random.randint(0,5,size=(3,5))
#數(shù)組中的所有元素都乘2
print(a1*2)
#數(shù)組中所有的元素只保留2位小數(shù)
print(a1.round(2))
#數(shù)組形狀一致時 各個元素相加減(滿足數(shù)組廣播機制)
a2 = np.random.randint(0,5,size=(3,5))
a1+a2
#形狀不一致的數(shù)組不能相加減(不滿足數(shù)組廣播機制)
a3 = np.random.randint(0,5,size=(3,4))
# a1+a3 報錯
#兩個數(shù)組行數(shù)相同 ，其中一個數(shù)組列數(shù)為1(滿足數(shù)組廣播機制)
a4 = np.random.randint(0,5,size=(3,1))
a1+a4
#兩個數(shù)組列數(shù)相同 ，其中一個數(shù)組行數(shù)為1(滿足數(shù)組廣播機制)
a5 = np.random.randint(0,5,size=(1,5))
a1+a5
(1) 數(shù)組和數(shù)字直接進行運算是沒有問題的
(2) 兩個shape想要的數(shù)組是可以進行運算的
(3) 如果兩個shape不同的數(shù)組，想要進行運算，那么需要看他們是否滿足廣播原則
import numpy as np
# reshape與resize都是用來修改數(shù)組形狀的，但是存在不同
a1 = np.random.randint(0,10,size=(3,4))
# reshape是將數(shù)組轉換成指定的形狀，然后返回轉換后的結果，對于原數(shù)組的形狀是不會發(fā)生改變的
a2 = a1.reshape((2,6))
# resize是將數(shù)組轉換成指定的形狀，會直接修改數(shù)組本身，并且不會返回任何值
a1.resize((4,3))
print(a1)
# faltten與ravel都是將多維數(shù)組轉換為一維數(shù)組，但是存在不同
a3 = np.random.randint(0,10,size=(3,4))
# flatten是將數(shù)組轉換為一維數(shù)組后，然后將這個拷貝返回回去，然后后續(xù)對這個返回值進行修改不會影響之前的數(shù)組
a4 = a3.flatten()
a4[0] = 100
# 結果為：2
print(a3[0,0])
# 結果為：100
print(a4[0])
# ravel是將數(shù)組轉換為一維數(shù)組后，將這個視圖（引用）返回回去，后續(xù)對這個返回值進行修改會影響之前的數(shù)組
a5 = a3.ravel()
a5[0] = 100
# 結果為：100
print(a3[0,0])
# 結果為：100
print(a5[0])
#vstack代表在垂直方向疊加，如果想要疊加成功，那么列數(shù)必須一致
#hstack代表在水平方向疊加，如果想要疊加成功，那么行數(shù)必須一致
#concatenate可以手動的指定axis參數(shù)具體在哪個方向疊加
##（1）如果axis=0，代表在水平方向疊加
##（2）如果axis=1，代表在垂直方向疊加
##（3）如果axis=None，會先進行疊加，再轉化為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)
#先識別垂直疊加或水平疊加 后轉換為一維數(shù)組
h5 = np.concatenate([h2,h1],axis=None)
print(h5)
#hsplit代表在水平方向切割，按列進行切割。
#hsplit切割方式兩種，第一種直接指定平均切割成多少列，第二種是指定切割的下標值
#vsplit代表在垂直方向切割，按行進行切割。切割方式與hsplit相同
#split/array_split是手動的指定axis參數(shù)，axis=0代表按行進行切割，axis=1代表按列進行切割
hs1 = np.random.randint(0,10,size=(3,4))
print(hs1)
#水平方向平均分為2份 (要求列數(shù)可被此數(shù)整除)
np.hsplit(hs1,2)
#水平方向分為1,1,2列（在下標為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)
#通過ndarray.T的形式進行轉置
t1 = np.random.randint(0,10,size=(3,4))
print(t1)
#數(shù)組t1轉置
t1.T
#矩陣相乘
t1.dot(t1.T)
#通過ndarray.transpose()進行轉置
#transpose返回的是一個View，所以對返回值上進行修改會影響到原來的數(shù)組。
t2 = t1.transpose()
t2
1. 數(shù)據(jù)的形狀改變
（1）reshape和resize都是重新定義形狀的，但是reshape不會修改數(shù)組本身，而是將修改后的結果返回回去，而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，那么會先進行疊加，再轉化成一維數(shù)組
3. 數(shù)組的切割
（1）hsplit代表在水平方向切割，按列進行切割。切割方式有兩種，第一種就是直接指定平均切割成多少列，第二種就是指定切割的下標值
（2）vsplit代表在垂直方向切割，按行進行切割。切割方式與hsplit一致。
（3）split/array_split是手動的指定axis參數(shù)，axis=0代表按行進行切割，axis=1代表按列進行切割
4. 矩陣轉置
（1）可以通過ndarray.T的形式進行轉置
（2）也可以通過ndarray.transpose()進行轉置，這個方法返回的是一個View，所以對返回值上進行修改，會影響到原來的數(shù)組
如果只是簡單的賦值，那么就不會進行拷貝
import numpy as np
a = np.arange(12)
#這種情況不會進行拷貝
b = a
#返回True，說明b和a是相同的
print(b is a)
有些情況，會進行變量的拷貝，但是他們所指向的內(nèi)存空間都是一樣的，那么這種情況叫做淺拷貝，或者叫做View(視圖)
c = a.view()
#返回false,說明c與a在棧區(qū)空間不同，但是所指向的內(nèi)存空間是一樣的
print(c is a)
#對c的值修改 同時也會對a進行修改
c[0] = 100
#array([100,1,2,3,4,5,6,7,8,9,10,11])
print(a)
將之前數(shù)據(jù)完完整整的拷貝一份放到另外一塊內(nèi)存空間中，這樣就是兩個完全不同的值了
d = a.copy()
#返回False 說明在不同棧區(qū)
print(d is a)
#數(shù)組d值被修改，數(shù)組a值不會被修改 說明內(nèi)存空間不同
d[1]=200
在數(shù)組操作中分成三種拷貝：
（1）不拷貝：直接賦值，那么棧區(qū)沒有拷貝，只是用同一個棧區(qū)定義了不同的名稱
（2）淺拷貝：只拷貝棧區(qū)，棧區(qū)指定的堆區(qū)并沒有拷貝
（3）深拷貝：棧區(qū)和堆區(qū)都拷貝
np.savetxt(frame,array,fmt='%.18e',delimiter=None)
函數(shù)功能：將數(shù)組保存到文件中
參數(shù)說明：
· frame：文件、字符串或產(chǎn)生器，可以是.gz或.bz2的壓縮文件
· array：存入文件的數(shù)組
· fmt：寫入文件的格式，例如：%d %.2f %.18e
· delimter：分割字符串，默認是空格
import numpy as np
scores = np.random.randint(0,100,size=(10,2))
#保存csv文件
np.savetxt('score.csv',scores,fmt='%d',delimiter=',',header='英語,數(shù)學',comments='')
np.loadtxt(frame,dtype=np.float,delimiter=None,unpack=False)
函數(shù)功能：將數(shù)組保存到文件中
參數(shù)說明：
· frame：文件、字符串或產(chǎn)生器，可以是.gz或.bz2的壓縮文件
· dtype：數(shù)據(jù)類型，可選
· delimiter：分割字符串，默認是任何空格
· skiprows：跳過前面x行
· usecols：讀取指定的列，用元組組合
· unpack：如果True，讀取出來的數(shù)組是轉置后的
#讀取csv文件 跳過第一行的表頭
b = np.loadtxt('score.csv',dtype=np.int,delimiter=',',skiprows=1)
b
numpy中還有一種獨有的存儲解決方案。文件名是以.npy或者npz結尾的。以下是存儲和加載的函數(shù)：
1. 存儲
np.save(fname,a rray)
或np.savez(fname,array)
其中，前者函數(shù)的擴展名是.npy，后者的擴展名是.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
1. np.savetxt和np.loadtxt一般用來操作CSV文件，可以設置header，但是不能存儲3維以上的數(shù)組。
2. np.save和np.load一般用來存儲非文本類型的文件，不可以設置header，但是可以存儲3維以上的數(shù)組
3. 如果想專門的操作csv文件，還存在另一個模塊叫做csv，這個模塊是python內(nèi)置的，不需要安裝
NAN：Not A number,不是一個數(shù)字的意思，但是他是浮點類型的，所以想要進行數(shù)據(jù)操作的時候需要注意他的類型
import numpy as np
data = np.random.randint(0,10,size=(3,5))
data = data.astype(np.float)
#將數(shù)組中某個位置的值設置為NAN
data[0,1]=np.NAN
data
INF：Infinity，代表的是無窮大的意思，也是屬于浮點類型。np.inf表示正無窮大，-np.inf表示負無窮大，一般在出現(xiàn)除數(shù)為0的時候為無窮大。比如2/0
有時候，我們想要將數(shù)組中的NAN刪掉，那么我們可以換一種思路，就是只提取不為NAN的值
#第一種方式： 刪除所有NAN的值，因為刪除了值后數(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)
#從文件中讀取數(shù)據(jù)
scores = np.loadtxt('scores.csv',delimiter=',',skiprows=1,dtype=np.str)
#將空數(shù)據(jù)轉換成NAN
scores[scores == ''] = np.NAN
#轉化成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進行深拷貝
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
（1）NAN：Not A Number的簡寫，不是一個數(shù)字，但是是屬于浮點類型
（2）INF：無窮大，在除數(shù)為0的情況下會出現(xiàn)INF
（3）NAN和所有的值進行計算結果都是等于NAN
（4）NAN != NAN
（5）可以通過np.isnan來判斷某個值是不是NAN
（6）處理值的時候，可以通過刪除NAN的形式進行處理，也可以通過值的替換進行處理
（7）np.delete比較特殊，通過axis=0來代表行，而其他大部分函數(shù)通過axis=1來代表行
用于指定隨機數(shù)生成時所用算法開始的整數(shù)值，如果使用相同的seed()值，則每次生成的隨機數(shù)都相同，如果不設置這個值，則系統(tǒng)根據(jù)時間來自己選擇這個值，此時每次生成的隨機數(shù)因時間差異不同。一般沒有特殊要求不用設置。
np.random.seed(1)
#打印0.417022004702574
np.random.rand()
#打印其他的值，因為隨機數(shù)種子支隊下一次隨機數(shù)的產(chǎn)生會有影響
np.random.rand()
生成一個值為 [0,1) 之間的數(shù)組，形狀由參數(shù)指定，如果沒有參數(shù)，那么將返回一個隨機值
#產(chǎn)生隨機數(shù)
np.random.rand()
#產(chǎn)生隨機數(shù)組 兩行三列
np.random.rand(2,3)
生成均值(μ)為0，標準差(σ)為1的標準正態(tài)分布的值
#生成一個2行3列的數(shù)組，數(shù)組中的值都滿足標準正態(tài)分布
data = np.random.randn(2,3)
data
生成指定范圍內(nèi)的隨機數(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))
從一個列表或者數(shù)組中，隨機進行采樣?；蛘呤菑闹付ǖ膮^(qū)間中進行采樣，采樣個數(shù)可以通過參數(shù)
#從數(shù)組中隨機選擇三個值
np.random.choice(data,3)
#從數(shù)組中獲取值組成新的數(shù)組
np.random.choice(data,size=(3,4))
#從指定值隨機取值 (示例:從0-10之間隨機取3個值)
np.random.choice(10,3)
把原來數(shù)組的元素的位置打亂
a = np.arange(10)
#將數(shù)組a的元素的位置都會進行隨機更換
#shuffle沒有返回值，直接打亂原數(shù)組位置
np.random.shuffle(a)
a
簡單來說，最外面的括號代表著axis=0，依次往里的括號對應的axis的計數(shù)就依次加1
如下圖，最外面的括號就是axis=0，里面兩個子括號axis=1
操作方式：如果指定軸進行相關的操作，那么他會使用軸下的每一個直接子元素的第0個，第1個，第2個…分別進行相關的操作
示例：
x = np.array([[0,1],[2,3]])
1.求 x 數(shù)組在axis = 0 和 axis=1 兩種情況下的和
#結果為[2,4]
x.sum(axis=0)
分析：按照axis=0的方式相加，那么就會把最外面軸下的所有直接子元素的第0個位置進行相加，第1個位置進行相加…依次類推，得到的就是 0+2 以及 2+3 ，然后進行相加，得到的結果就是 [2,4]
2.用np.max求 axis=0 和 axis=1 兩種情況下的最大值
np.random.seed(100)
x = np.random.randint(1,10,size=(3,5))
#輸出結果為：
#[[9 9 4 8 8]
# [1 5 3 6 3]
# [3 3 2 1 9]]
print(x)
#結果為[9, 9, 4, 8, 9]
x.max(axis=0)
#結果為[9, 6, 9]
x.max(axis=1)
分析：按照axis=0進行求最大值，那么就會在最外面軸里面找直接子元素，然后將每個子元素的第0個值放在一起求最大值，將第1個值放在一起求最大值，以此類推。而如果axis=1，那么就是拿到每個直接子元素，然后求每個子元素中的最大值
3.用 np.delete 在 axis=0 和 axis=1 兩種情況下刪除元素
np.random.seed(100)
x = np.random.randint(1,10,size=(3,5))
#輸出結果為：
#[[9 9 4 8 8]
# [1 5 3 6 3]
# [3 3 2 1 9]]
print(x)
#刪除第0行
#結果為：
#[[1, 5, 3, 6, 3],
# [3, 3, 2, 1, 9]]
np.delete(x,0,axis=0)
分析：np.delete是個例外，按照 axis=0 的方式進行刪除，那么會首先找到最外面的括號下的直接子元素的第0個，然后直接刪掉，剩下最后一行的數(shù)據(jù)。同理，如果我們按照 axis=1 進行刪除，那么會把第一列的數(shù)據(jù)刪掉
#生成一個三維數(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)
#取最大值
#結果為：
#[[12, 13, 14, 15, 16, 17],
# [18, 19, 20, 21, 22, 23]]
y.max(axis=0)
（1）最外面的括號代表著 axis=0，依次往里的括號對應的 axis 的計數(shù)就依次加1
（2）操作方式：如果指定軸進行相關的操作，那么他會使用軸下面的每個直接子元素的第0個，第1個，第2個...分別進行相關的操作
（3）np.delete是直接刪除指定軸下的第幾個直接子元素
| 函數(shù) | 描述 |
|---|---|
| np.abs | 絕對值 |
| np.sqrt | 開方（負數(shù)開方結果為NAN） |
| np.square | 平方 |
| np.exp | 計算指數(shù)(e^x) |
| np.log,np.log10,np.log2,np.log1p | 求以e為底，以10為底，以2為底，以(1+x為底的對數(shù) |
| np.sign | 將數(shù)組中的值標簽化，大于0的變成1，等于0的變成0，小于0的變成-1 |
| np.ceil | 朝著無窮大的方向取整，比如5.1會變成6,-6.3會變成-6 |
| np.floor | 朝著負無窮大的方向取整，比如5.1會變成5,-6.3會變成-7 |
| np.rint,np.round | 返回四舍五入后的值 |
| np.modf | 將整數(shù)和小數(shù)分割開來形成兩個數(shù)組 |
| np.isnan | 判斷是否是nan |
| np.isinf | 判斷是否是inf |
| np.cos,np.cosh,np.sinh,np.tan,np.tanh | 三角函數(shù) |
| np.arccos,np.arcsin,np.arctan | 反三角函數(shù) |
| 函數(shù) | 描述 |
|---|---|
| np.add | 加法運算（即1+1=2），相當于+ |
| np.subtract | 減法運算（即3-2=1），相當于- |
| np.negative | 復數(shù)運算（即-2）。相當于加個負號 |
| np.multiply | 乘法運算（即2_3=6），相當于_ |
| np.divide | 除法運算（即3/2=1.5），相當于/ |
| np.floor_divide | 取整運算，相當于// |
| np.mod | 取余運算，相當于% |
| greater,greater_equal,less,less_equal,equal,not_equal | >,>=,<,<=,=,!=的函數(shù)表達式 |
| logical_and | 且運算符函數(shù)表達式 |
| logical_or | 或運算符函數(shù)表達式 |
| 函數(shù)名稱 | NAN安全版本 | 描述 |
|---|---|---|
| np.sum | np.nansum | 計算元素的和 |
| np.prod | np.nanprod | 計算元素的積 |
| np.mean | np.nanmean | 計算元素的平均值 |
| np.std | np.nanstd | 計算元素的標準差 |
| np.var | np.nanvar | 計算元素的方差 |
| np.min | np.nanmin | 計算元素的最小值 |
| np.max | np.nanmax | 計算元素的最大值 |
| np.argmin | np.nanargmin | 找出最小值的索引 |
| np.argmax | np.nanargmax | 找出最大值的索引 |
| np.median | np.nanmedian | 計算元素的中位數(shù) |
補充：使用np.sum或者是a.sum即可實現(xiàn)。并且在使用的時候，可以指定具體哪個軸。同樣python中也內(nèi)置了sum函數(shù)，但是python內(nèi)置的sum函數(shù)執(zhí)行效率沒有np.sum那么高。
| 函數(shù)名稱 | 描述 |
|---|---|
| np.any | 驗證任何一個元素是否為真 |
| np.all | 驗證所有元素是否為真 |
#查看數(shù)組中是不是所有元素都為0
#方式一
np.all(a==0)
#方式二
(a==0).all()
#查看數(shù)組中是否有等于0的數(shù)
#方式一
np.any(a==0)
#方式二
(a==0).any()
函數(shù)說明：指定軸進行排序。默認是使用數(shù)組的最后一個軸進行排序。
還有ndarray.sort()，這個方法會直接影響到原來的數(shù)組，而不是返回一個新的排序后的數(shù)組
#生成數(shù)組
a = np.random.randint(0,10,size=(5,5))
#按照行進行排序，因為最后一個軸是1，那么就是將最里面的元素進行排序
np.sort(a)
#按照列進行排序，因為指定了axis=0
np.sort(a,axis=0)
#該方法進行排序會影響原數(shù)組
a.sort()
函數(shù)說明：返回排序后的下標值。
#返回排序后的下標值
np.argsort(a)
np.sort()默認會采用升序排序，用一下方案來實現(xiàn)降序排序
#方式一：使用負號
-np.sort(-a)
#方式二：使用sort和argsort以及take
#排序后的結果就是降序的
indexes = np.argsort(-a)
#從a中根據(jù)下標提取相應的元素
np.take(a,indexes)
函數(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表達式
np.apply_along_axis(lambda x:x[np.logical_and(x!=x.max,x!=x.min)].mean(),axis=1,arr=c)
函數(shù)說明：用來將指定區(qū)間內(nèi)的值平均分成多少份
#將0-10分成12份，生成一個數(shù)組
np.linspace(0,10,12)
函數(shù)說明：返回數(shù)組中的唯一值
#返回數(shù)組a中的唯一值
np.unique(d)
#返回數(shù)組a中的唯一值，并且會返回每個唯一值出現(xiàn)的次數(shù)
np.unique(d,return_counts=True)聯(lián)系客服
