numpy

什麼是numpy

一個在python中作科學計算的基礎庫，重在數值計算，也是大部分PYTHON科學計算庫的基礎庫，多用於大型、多維數組上執行數值運算

numpy建立數組（矩陣）

建立數組：

import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = np.array(range(1, 6))
c = np.arange(1, 6)
# 上面a, b, c內容相同，注意arange和range的區別
np.arange的用法：arange([start,] stop[, step,], dtype=None)

數組的類名：

In [1]: a = np.array([1, 2, 3, 4, 5])
In [2]: type(a)
Out[2]: numpy.ndarray

數據的類型

In [3]: a.dtype
Out[3]: dtype('int64')

數據類型的操做

指定建立的數組的數據類型：

In [11]: a = np.array([1, 0, 1, 0], dtype=np.bool)  # 或者使用dtype='?'
In [12]: a
Out[12]: array([ True, False,  True, False])

修改數組的數據類型：

In [13]: a.astype('i2')  # 或者使用a.astype(np.int16)
Out[13]: array([1, 0, 1, 0], dtype=int16)

修改浮點型的小數位數：

In [30]: b
Out[30]:
array([0.07996214, 0.89966202, 0.27985576, 0.84551686, 0.77378861,
       0.69867185, 0.83677068, 0.30732802, 0.84521435, 0.88867764])

In [31]: np.round(b, 2)
Out[31]: array([0.08, 0.9 , 0.28, 0.85, 0.77, 0.7 , 0.84, 0.31, 0.85, 0.89])

數組的形狀

b = a.reshape(3, 4)

In [36]: b
Out[36]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [37]: b.shape
Out[37]: (3, 4)

把數據轉化爲1維度數據

In [38]: b.reshape(1, 12)
Out[38]: array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]])
# 這是一維數組麼？

In [39]: b.flatten()
Out[39]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

數組和數的計算

In [43]: a
Out[43]:
array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])

加法減法

In [44]: a + 1
Out[44]:
array([[ 2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11]])

乘法除法

In [45]: a *3
Out[45]:
array([[ 3,  6,  9, 12, 15],
       [18, 21, 24, 27, 30]])

這是一個numpy的廣播機制形成的，在運算過程當中，加減乘除的值被廣播到全部的元素上面

不一樣維度的數組計算

In [46]: a
Out[46]:
array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])

In [47]: c = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

In [48]: a * c
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-48-3f6f667472ca> in <module>()
----> 1 a * c

ValueError: operands could not be broadcast together with shapes (2,5) (3,4)

廣播原則

若是兩個數組的後緣維度（trailing dimension，即從末尾開始算起的維度）的軸長度相符或其中一方的長度爲1，則認爲它們是廣播兼容的。廣播會在缺失和（或）長度爲1的維度上進行。

軸(axis)

在numpy中能夠理解爲方向，使用0，1，2...數字表示，對於一個一維數組，只有一個0軸，對於二維數組(shape(2, 2))，有0軸和1軸，對於三維數組(shape(2, 2, 3)), 有0，1，2軸

有了軸的概念之後，咱們計算會更加方便，好比計算一個2維數組的平均值，必須指定是計算哪一個方向上面的數字的平均值

numpy讀取數據

CSV:Comma-Separated Value，逗號分隔值文件
顯示：表格狀態
源文件：換行和逗號分隔行列的格式化文本，每一行的數據表示一條記錄
因爲csv便於展現，讀取和寫入，因此不少地方也是用csv的格式存儲和傳輸中小型的數據，爲了方便教學，咱們會常常操做csv格式的文件，可是操做數據庫中的數據也是很容易實現的

np.loadtxt(frame, dtype=np.float, delimiter=None, skiprows=0, usecols=None, unpack=False)

參數	解釋
frame	文件、字符串或產生器，能夠是.gz或bz2壓縮文件
dtype	數據類型，可選，csv的字符串以什麼數據類型讀入數組中，默認np.float
delimiter	分隔字符串，默認是任何空格，改成 逗號
skiprows	跳過前x行，通常跳過第一行表頭
usecols	讀取指定的列，索引，元組類型
unpack	若是True，讀入屬性將分別寫入不一樣數組變量，False讀入數據只寫入一個數組變量，默認False

numpy中的轉置

轉置是一種變換，對於numpy中的數組來講，就是在對角線方向交換數據，目的也是爲了更方便的去處理數據

In [102]: t = np.array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11], [12, 13, 14, 15,16, 17]])

In [103]: t.transpose()
Out[103]:
array([[ 0,  6, 12],
       [ 1,  7, 13],
       [ 2,  8, 14],
       [ 3,  9, 15],
       [ 4, 10, 16],
       [ 5, 11, 17]])

In [104]: t.swapaxes(1, 0)
Out[104]:
array([[ 0,  6, 12],
       [ 1,  7, 13],
       [ 2,  8, 14],
       [ 3,  9, 15],
       [ 4, 10, 16],
       [ 5, 11, 17]])

In [105]: t.T
Out[105]:
array([[ 0,  6, 12],
       [ 1,  7, 13],
       [ 2,  8, 14],
       [ 3,  9, 15],
       [ 4, 10, 16],
       [ 5, 11, 17]])

以上的三種方法均可以實現二維數組的轉置的效果，你們可以看出來，轉置和交換軸的效果同樣

numpy索引和切片

對於剛剛加載出來的數據，我若是隻想選擇其中的某一列（行）咱們應該怎麼作呢？
其實操做很簡單，和python中列表的操做同樣

In [118]: a
Out[118]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [119]: a[1]  # 取一行
Out[119]: array([4, 5, 6, 7])

In [120]: a[:,2]  # 取一列
Out[120]: array([ 2,  6, 10])

In [121]: a[1:3]  # 取多行
Out[121]:
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [122]: a[:,2:4]  # 取多列
Out[122]:
array([[ 2,  3],
       [ 6,  7],
       [10, 11]])
       
In [128]: a[[0, 2],[0, 3]]  # 取多個不相鄰的點
Out[128]: array([ 0, 11])

numpy中數值的修改

In [132]: t
Out[132]:
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

In [133]: t[:, 2:4]
Out[133]:
array([[ 2,  3],
       [ 8,  9],
       [14, 15],
       [20, 21]])

In [134]: t[:, 2:4] = 0

In [135]: t
Out[135]:
array([[ 0,  1,  0,  0,  4,  5],
       [ 6,  7,  0,  0, 10, 11],
       [12, 13,  0,  0, 16, 17],
       [18, 19,  0,  0, 22, 23]])

numpy中布爾索引

In [142]: t
Out[142]:
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

In [143]: t<10
Out[143]:
array([[ True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True, False, False],
       [False, False, False, False, False, False],
       [False, False, False, False, False, False]])

In [144]: t[t<10]
Out[144]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [145]: t
Out[145]:
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

In [146]: t[t<10] = 0

In [147]: t
Out[147]:
array([[ 0,  0,  0,  0,  0,  0],
       [ 0,  0,  0,  0, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

numpy中三元運算符

In [149]: t
Out[149]:
array([[ 0,  0,  0,  0,  0,  0],
       [ 0,  0,  0,  0, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

In [150]: t = np.arange(24).reshape((4, 6))

In [151]: t
Out[151]:
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

In [152]: np.where(t<10,0,10)
Out[152]:
array([[ 0,  0,  0,  0,  0,  0],
       [ 0,  0,  0,  0, 10, 10],
       [10, 10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10, 10]])

numpy中的clip(裁剪)

In [166]: t
Out[166]:
array([[ 0.,  1.,  2.,  3.,  4.,  5.],
       [ 6.,  7.,  8.,  9., 10., 11.],
       [12., 13., 14., 15., 16., 17.],
       [18., 19., 20., nan, nan, nan]], dtype=float32)

In [167]: t.clip(10, 18)
Out[167]:
array([[10., 10., 10., 10., 10., 10.],
       [10., 10., 10., 10., 10., 11.],
       [12., 13., 14., 15., 16., 17.],
       [18., 18., 18., nan, nan, nan]], dtype=float32)

小於10的替換爲10，大於18的替換爲了18，可是nan沒有被替換

數組的拼接

In [169]: t1 = np.arange(12).reshape(2, 6)

In [170]: t1
Out[170]:
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])

In [171]: t2 = np.arange(12, 24).reshape(2, 6)

In [172]: t2
Out[172]:
array([[12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

In [173]: np.vstack((t1, t2))  # 豎直拼接（vertically）
Out[173]:
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

In [174]: np.hstack((t1, t2))  # 水平拼接（horizontally）
Out[174]:
array([[ 0,  1,  2,  3,  4,  5, 12, 13, 14, 15, 16, 17],
       [ 6,  7,  8,  9, 10, 11, 18, 19, 20, 21, 22, 23]])

數組的行列交換

In [216]: t1
Out[216]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [217]: t1[[1, 2], :] = t1[[2, 1], :]

In [218]: t1
Out[218]:
array([[ 0,  1,  2,  3],
       [ 8,  9, 10, 11],
       [ 4,  5,  6,  7]])

In [219]: t1[:, [0, 2]] = t1[:, [2, 0]]

In [220]: t1
Out[220]:
array([[ 2,  1,  0,  3],
       [10,  9,  8, 11],
       [ 6,  5,  4,  7]])

numpy中的nan和inf

nan(NAN, Nan):not a number表示不是一個數字

何時numpy中會出現nan：
當咱們讀取的本地文件爲float的時候，若是有缺失，就會出現nan當作了一個不合適的計算的時候（好比無窮大（inf）減去無窮大）

inf(-inf, inf):infinity,inf表示正無窮，-inf表示負無窮

何時會出現inf包括（-inf, +inf）
好比一個數字除以0，（python中直接會報錯，numpy中是一個inf或者-inf）

numpy中的nan的注意點

1. 兩個nan是不相等的

In [27]: np.nan == np.nan
Out[27]: False

1. np.nan != np.nan

In [34]: np.nan != np.nan
Out[34]: True

1. 利用以上的特性，判斷數組中nan的個數

In [38]: t
Out[38]: array([ 1.,  2., nan])

In [39]: np.count_nonzero(t!=t)
Out[39]: 1

1. 因爲2，那麼如何判斷一個數字是否爲nan呢？經過np.isnan(a)來判斷，返回bool類型好比但願把nan替換爲0

In [40]: t
Out[40]: array([ 1.,  2., nan])

In [41]: np.isnan(t)
Out[41]: array([False, False,  True])

1. nan和任何值計算都爲nan

那麼問題來了，在一組數據中單純的把nan替換爲0，合適麼？會帶來什麼樣的影響？

好比，所有替換爲0後，替換以前的平均值若是大於0，替換以後的均值確定會變小，因此更通常的方式是把缺失的數值替換爲均值（中值）或者直接刪除有缺失值的一行

numpy中經常使用的統計函數

求和：t.sum(axis=None)
均值：t.mean(axis=None) 受離羣點的影響較大
中值：np.median(t.axis=None)
最大值：t.max(axis=None)
最小值：t.min(axis=None)
極差：np.ptp(t, axis=None)  即最大值和最小值之差
標準差：t.std(axis=None)
標準差是一組組數據平均值分散程度的一種度量。一個較大的標準差，表明大部分數值和其平均值之間的差別較大；一個較小的標準差，表明這些數值較接近平均值反映出數據的波動穩定狀況，越大表示波動越大，越不穩定

默認返回多維數組的所有的統計結果，若是指定axis則返回一個當前軸上的結果

numpy更多好用的方法

1. 獲取最大值最小值的位置

1. np.argmax(t.axis=0)
2. np.argmin(t.axit=1)

1. 建立一個全0的數組：np.zero((3, 4))
2. 建立一個全1的數組：np.ones((3, 4))
3. 建立一個對角線爲1的正方形數組（方針）：np.eye(3)

numpy生產隨機數

參數	解釋
.rand(d0, d1, ..dn)	建立d0-dn維度的均勻分佈的隨機數數組，浮點數，範圍從0-1
.randn(d0, d1, ..dn)	建立d0-dn維度的正態分佈的隨機數數組，浮點數，平均數0，標準差1
.randint(low, high, (shape))	從給定上下限範圍選取隨機數整數，範圍是low,high, 形狀是shape
uniform(low, high, (size))	產生具備均勻分佈的數組，low爲起始值，high結束值，size形狀
.normal(loc, scale, (size))	從指定正態分佈中隨機抽取樣本，分佈中心是loc(機率分佈的均值)，標準差是scale，形狀是size
seed(s)	隨機數種子，s是給定的種子值。由於計算機生成的是僞隨機數，因此經過設定相同的隨機數種子，能夠生成相同的隨機數

numpy的注意點copy和view

1. a = b 徹底不復制，a和b相互影響
2. a = b[:]，視圖的操做，一種切片，會建立新的對象a，可是a的數據徹底由b保管，它們兩個徹底的數據變化是一致的，
3. a = b.copy()，複製，a和b互不影響