Numpy系列（一）- array

初始Numpy

1、什麼是Numpy?

簡單來講，Numpy 是 Python 的一個科學計算包，包含了多維數組以及多維數組的操做。

 

Numpy 的核心是 ndarray 對象，這個對象封裝了同質數據類型的n維數組。起名 ndarray 的緣由就是由於是 n-dimension-array 的簡寫。

2、ndarray 與 python 原生 array 有什麼區別

• NumPy 數組在建立時有固定的大小，不一樣於Python列表（能夠動態增加）。更改ndarray的大小將建立一個新的數組並刪除原始數據。

• NumPy 數組中的元素都須要具備相同的數據類型，所以在存儲器中將具備相同的大小。數組的元素若是也是數組（能夠是 Python 的原生 array，也能夠是 ndarray）的狀況下，則構成了多維數組。

• NumPy 數組便於對大量數據進行高級數學和其餘類型的操做。一般，這樣的操做比使用Python的內置序列可能更有效和更少的代碼執行。愈來愈多的科學和數學的基於Python的包使用NumPy數組，因此須要學會 Numpy 的使用。

3、Numpy 的矢量化（向量化）功能

若是想要將一個2-D數組 a 的每一個元素與長度相同的另一個數組 b 中相應位置的元素相乘，使用 Python 原生的數組實現以下：

for (i = 0; i < rows; i++): {
  for (j = 0; j < columns; j++): {
    c[i][j] = a[i][j]*b[i][j];
  }}

使用 Numpy 實現的話，則能夠直接使用矢量化功能：

c = a * b

矢量化代碼有不少優勢，其中包括：

• 矢量化代碼更簡潔易讀

• 更少的代碼行一般意味着更少的錯誤

• 該代碼更接近地相似於標準數學符號（使得更容易，一般，以正確地編碼數學構造）

• 矢量化致使更多的「Pythonic」代碼。若是沒有向量化，咱們的代碼將會效率很低，難以讀取for循環。

 N維數組 ndarray

Numpy 中最重要的一個對象就是 ndarray。
ndarray 結構圖

ndarray中的每一個元素在內存中使用相同大小的塊。 ndarray中的每一個元素是數據類型對象的對象(稱爲 dtype)。
從ndarray對象提取的任何元素(經過切片)由一個數組標量類型的 Python 對象表示。 下圖顯示了ndarray，數據類型對象(dtype)和數組標量類型之間的關係。

1、構建ndarray

import numpy as np
#一維數組
a = np.array([0,1,2,3])
a
Out[39]: array([0, 1, 2, 3])
#二維數組
b = np.array([[0,1,2],[4,5,6]])
b
Out[40]: 
array([[0, 1, 2],
       [4, 5, 6]])
#建立一個0-9的數組
a = np.arange(10)
a
Out[41]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#建立一個1-6，步長爲2的數組
b = np.arange(1,6,2)
b
Out[42]: array([1, 3, 5])

2、經常使用的數組

# 全一矩陣
np.ones((3,3))
Out[43]: 
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])
# 零矩陣
np.zeros((2,2))
Out[44]: 
array([[0., 0.],
       [0., 0.]])
# 單位矩陣
np.eye(3)
Out[45]: 
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
# 對角矩陣
np.diag(np.array([1,2,3,4]))
Out[46]: 
array([[1, 0, 0, 0],
       [0, 2, 0, 0],
       [0, 0, 3, 0],
       [0, 0, 0, 4]])

 3、生成等差數列

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None):

• endpoint: 結束點若是如今爲True，那麼輸入的第二個參數將會成爲數列的最後一個元素，反之則不必定。
• restep: 而retstep會改變計算的輸出，輸出一個元組，而元組的兩個元素分別是須要生成的數列和數列的步進差值。

# 默認生成50個元素的等差序列，需設定起始值和終止值
np.linspace(1,10)
Out[47]: 
array([ 1.        ,  1.18367347,  1.36734694,  1.55102041,  1.73469388,
        1.91836735,  2.10204082,  2.28571429,  2.46938776,  2.65306122,
        2.83673469,  3.02040816,  3.20408163,  3.3877551 ,  3.57142857,
        3.75510204,  3.93877551,  4.12244898,  4.30612245,  4.48979592,
        4.67346939,  4.85714286,  5.04081633,  5.2244898 ,  5.40816327,
        5.59183673,  5.7755102 ,  5.95918367,  6.14285714,  6.32653061,
        6.51020408,  6.69387755,  6.87755102,  7.06122449,  7.24489796,
        7.42857143,  7.6122449 ,  7.79591837,  7.97959184,  8.16326531,
        8.34693878,  8.53061224,  8.71428571,  8.89795918,  9.08163265,
        9.26530612,  9.44897959,  9.63265306,  9.81632653, 10.        ])
# 生成指定個數的等差序列
np.linspace(1,10,10)
Out[48]: array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

4、生成等比數列

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

• base:等比基數 默認爲10

# 建立10個1-1的等比數列， 由於默認基數是10  
np.logspace(0, 0, 10)
Out[55]: array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])
# 建立10個1-2的10次方之間的等比數列， 改變等比基數
np.logspace(0, 9, 10, base=2)
Out[59]: array([  1.,   2.,   4.,   8.,  16.,  32.,  64., 128., 256., 512.])
# 建立10個1-2的10次方之間的等比數列， 改變等比基數
np.logspace(0, 9, 10, base=2, dtype=int)
Out[60]: array([  1,   2,   4,   8,  16,  32,  64, 128, 256, 512])

5、生成meshgrid網格矩陣

    meshgrid函數一般在數據的矢量化上使用，可是使用的方法我暫時還不是很明確。而meshgrid的做用適用於生成網格型數據，能夠接受兩個一維數組生成兩個二維矩陣，對應兩個數組中全部的(x,y)對。接下來經過簡單的shell交互來演示一下這個功能的使用，並作一下小結。

meshgrid(*xi, **kwargs)

功能：從一個座標向量中返回一個座標矩陣

參數：

x1,x2...,xn：數組,一維的數組表明網格的座標。

indexing：{'xy','ij'}，笛卡爾座標'xy'或矩陣'ij'下標做爲輸出，默認的是笛卡爾座標。

sparse：bool類型，若是爲True，返回一個稀疏矩陣保存在內存中，默認是False。

copy：bool類型，若是是False，返回一個原始數組的視圖保存在內存中，默認是True。若是，sparse和copy都爲False，將有可能返回一個不連續的數組。並且，若是廣播數組的元素超過一個，可使用一個獨立的內存。若是想要對這個數組進行寫操做，請先拷貝這個數組。

返回值：x1,x2,....,xn：ndarray(numpy數組)

參數

例子

x = np.linspace(1, 3, 3)
x
Out[69]: array([1., 2., 3.])
y = np.linspace(4, 7, 4)
y
Out[71]: array([4., 5., 6., 7.])
xv, yv = np.meshgrid(x, y)
xv
Out[73]: 
array([[1., 2., 3.],
       [1., 2., 3.],
       [1., 2., 3.],
       [1., 2., 3.]])
yv
Out[74]: 
array([[4., 4., 4.],
       [5., 5., 5.],
       [6., 6., 6.],
       [7., 7., 7.]])

經過上面的例子，其實能夠發現meshgrid函數將兩個輸入的數組x和y進行擴展，前一個的擴展與後一個有關，後一個的擴展與前一個有關，前一個是豎向擴展，後一個是橫向擴展。由於，y的大小爲4，因此x豎向擴展爲原來的四倍，而x的大小爲3，因此y橫向擴展爲原來的3倍。經過meshgrid函數以後，輸入由原來的數組變成了一個矩陣。經過使用meshgrid函數，能夠產生一個表格矩陣，下面用一個例子來展現產生一個2*2網格的座標，每一個網格的大小爲1。

# 生成一個2*2的網格的座標
#從0開始到1結束，返回一個numpy數組,nx表明數組中元素的個數
x = np.linspace(0,2,3)
x
Out[77]: array([0., 1., 2.])
y = np.linspace(0,2,3)
y
Out[79]: array([0., 1., 2.])
xv,yv = np.meshgrid(x,y)
print(xv.ravel())
print(yv.ravel())
[0. 1. 2. 0. 1. 2. 0. 1. 2.]
[0. 0. 0. 1. 1. 1. 2. 2. 2.]

　ravel函數是將矩陣變爲一個一維的數組，其中xv.ravel()就表示x軸的座標，yv.ravel()就表示了y軸的座標，咱們將x軸的座標和y軸的座標進行一一對應，就產生了一個2*2大小爲1的網格中的9個點的座標。

若是，將sparse參數設置爲True，就不會向上面同樣進行擴展了，也就是說它產生的網格座標不是全部的網格座標，而是網格對角線上的座標點。

nx,ny = (3,3)
#從0開始到1結束，返回一個numpy數組,nx表明數組中元素的個數
x = np.linspace(0,2,nx)
# [0. 1. 2.]
y = np.linspace(0,2,ny)
# [0. 1. 2.]
xv,yv = np.meshgrid(x,y,sparse=True)
print(xv)
[[0. 1. 2.]]

6、建立行列向量

np.r_[0:50:5]
Out[84]: array([ 0,  5, 10, 15, 20, 25, 30, 35, 40, 45])
np.c_[0:50:5]
Out[85]: 
array([[ 0],
       [ 5],
       [10],
       [15],
       [20],
       [25],
       [30],
       [35],
       [40],
       [45]])

　7、生成隨機數組

• np.random.seed(1234) #設置隨機種子爲1234
• np.random.rand(2,3) #2行3列均勻分佈
• np.random.randn(2,3) #Gaussian
• np.random.randn(3,3) #三行三列正態分佈隨機數據
• np.random.randint(1,3,5) #min max size 產生min-max中size個整數
• np.random.randint(1,100,[5,5]) #(1,100）之內的5行5列隨機整數
• np.random.random(10) #(0,1）之內10個隨機浮點數
• np.random.sample(10) #產生0，1內10個隨機數
• np.random.choice(10) #[0,10)內隨機選擇一個數

np.random.rand(2,3) #2行3列均勻分佈
Out[86]: 
array([[0.10437154, 0.25867737, 0.60777109],
       [0.21729078, 0.38925987, 0.69986437]])
np.random.randn(2,3) #Gaussian
Out[87]: 
array([[ 0.18813823,  0.21829928,  1.30977936],
       [-0.80801174, -0.2710817 ,  0.30614839]])
np.random.randn(3,3) #三行三列正態分佈隨機數據
Out[88]: 
array([[ 0.31102522,  0.24991538, -0.74242789],
       [-0.92471694,  0.09958997, -0.03147058],
       [-0.31209779,  0.94883746, -0.71359588]])
np.random.randint(1,3,5) #min max size 產生min-max中size個整數 
Out[89]: array([1, 2, 2, 1, 1])
np.random.randint(1,100,[5,5]) #(1,100）之內的5行5列隨機整數
Out[90]: 
array([[71, 80, 19, 13, 56],
       [40, 51, 42, 10, 65],
       [14, 87, 91, 36, 29],
       [27, 43, 24, 19, 31],
       [89, 79, 97, 21, 24]])
np.random.random(10) #(0,1）之內10個隨機浮點數
Out[91]: 
array([0.31589784, 0.04031992, 0.57425601, 0.57655811, 0.36513947,
       0.19312436, 0.22195245, 0.94515895, 0.85251243, 0.06609203])
np.random.sample(10) #產生0，1內10個隨機數
Out[92]: 
array([0.47695889, 0.75269019, 0.31765674, 0.53586716, 0.94818987,
       0.50960077, 0.32388153, 0.43584506, 0.00900502, 0.03402676])
np.random.choice(10) #[0,10)內隨機選擇一個數
Out[93]: 2

8、nddaray經常使用屬性

ndarray.flags	有關數組的內存佈局的信息。
ndarray.shape	數組維數組。
ndarray.strides	遍歷數組時，在每一個維度中步進的字節數組。
ndarray.ndim	數組維數，在Python世界中，維度的數量被稱爲rank。
ndarray.data	Python緩衝區對象指向數組的數據的開始。
ndarray.size	數組中的元素總個數。
ndarray.itemsize	一個數組元素的長度（以字節爲單位）。
ndarray.nbytes	數組的元素消耗的總字節數。
ndarray.base	若是內存是來自某個其餘對象的基本對象。
ndarray.dtype	數組元素的數據類型。
ndarray.T	數組的轉置。

a = np.array([(1,2,3),(4,5,6)])
a
Out[95]: 
array([[1, 2, 3],
       [4, 5, 6]])
a.flags
Out[96]: 
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False
a.shape
Out[97]: (2, 3)
a.ndim
Out[98]: 2
a.strides
Out[99]: (12, 4)
a.data
Out[100]: <memory at 0x0000004E715C8B40>
a.size
Out[101]: 6
a.itemsize
Out[102]: 4
a.nbytes
Out[103]: 24
a.base
a.dtype
Out[105]: dtype('int32')
a.T
Out[106]: 
array([[1, 4],
       [2, 5],
       [3, 6]])