本教程介紹了Python Numpy庫從安裝到創建數組的過程：Numpy的數據類型，數組屬性
，如何創建Numpy數組等。
Numpy 安裝
Python 官網上的發行版是不包含 NumPy 模塊的。
我們可以使用以下幾種方法來安裝。
1、使用已有的發行版本
對於許多用戶，尤其是在 Windows 上，最簡單的方法是下載以下的 Python 發行版，它們包含了所有的關鍵包（包括 NumPy，SciPy，matplotlib，IPython，SymPy 以及 Python 核心自帶的其它包）：
- Anaconda: 免費 Python 發行版，用於進行大規模數據處理、預測分析，和科學計算，致力於簡化包的管理和部署。支持 Linux, Windows 和 Mac 系統。
- Enthought Canopy: 提供了免費和商業發行版。持 Linux, Windows 和 Mac 系統。
- Python(x,y): 免費的 Python 發行版，包含了完整的 Python 語言開發包 及 Spyder IDE。支持 Windows，僅限 Python 2 版本。
- WinPython: 另一個免費的 Python 發行版，包含科學計算包與 Spyder IDE。支持 Windows。
- Pyzo: 基於 Anaconda 的免費發行版本及 IEP 的交互開發環境，超輕量級。 支持 Linux, Windows 和 Mac 系統。
2、使用 pip 安裝
安裝 NumPy 最簡單的方法就是使用 pip 工具：
python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose
–user 選項可以設置只安裝在當前的用戶下，而不是寫入到系統目錄。
Linux （Ubuntu & Debian)下安裝
sudo apt-get install python-numpy python-scipy python-matplotlib ipython ipython-notebook python-pandas python-sympy python-nose
安裝驗證
測試是否安裝成功：
>>> from numpy import *
>>> eye(4)
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
from numpy import * 爲導入 numpy 庫。
eye(4) 生成對角矩陣。
NumPy Ndarray 對象
NumPy 最重要的一個特點是其 N 維數組對象 ndarray，它是一系列同類型數據的集合，以 0 下標爲開始進行集合中元素的索引。
ndarray 對象是用於存放同類型元素的多維數組。
ndarray 中的每個元素在內存中都有相同存儲大小的區域。
ndarray 內部由以下內容組成：
- 一個指向數據（內存或內存映射文件中的一塊數據）的指針。
- 數據類型或 dtype，描述在數組中的固定大小值的格子。
- 一個表示數組形狀（shape）的元組，表示各維度大小的元組。
- 一個跨度元組（stride），其中的整數指的是爲了前進到當前維度下一個元素需要"跨過"的字節數。
ndarray 的內部結構:
跨度可以是負數，這樣會使數組在內存中後向移動，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。
創建一個 ndarray 只需調用 NumPy 的 array 函數即可：
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
參數說明：
| 名稱 | 描述 |
|---|---|
| object | 數組或嵌套的數列 |
| dtype | 數組元素的數據類型，可選 |
| copy | 對象是否需要複製，可選 |
| order | 創建數組的樣式，C爲行方向，F爲列方向，A爲任意方向（默認） |
| subok | 默認返回一個與基類類型一致的數組 |
| ndmin | 指定生成數組的最小維度 |
實例
接下來可以通過以下實例幫助我們更好的理解。
實例 1
import numpy as np
a = np.array([1,2,3])
print (a)
輸出結果如下：
[1, 2, 3]
實例 2
# 多於一個維度
import numpy as np
a = np.array([[1, 2], [3, 4]])
print (a)
輸出結果如下：
[[1, 2]
[3, 4]]
實例 3
# 最小維度
import numpy as np
a = np.array([1, 2, 3,4,5], ndmin = 2)
print (a)
實例 4
# dtype 參數
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print (a)
輸出結果如下：
[ 1.+0.j, 2.+0.j, 3.+0.j]
ndarray 對象由計算機內存的連續一維部分組成，並結合索引模式，將每個元素映射到內存塊中的一個位置。內存塊以行順序(C樣式)或列順序(FORTRAN或MatLab風格，即前述的F樣式)來保存元素。
NumPy 數據類型
numpy 支持的數據類型比 Python 內置的類型要多很多，基本上可以和 C 語言的數據類型對應上，其中部分類型對應爲 Python 內置的類型。下表列舉了常用 NumPy 基本類型。
| 名稱 | 描述 |
|---|---|
| bool_ | 布爾型數據類型（True 或者 False） |
| int_ | 默認的整數類型（類似於 C 語言中的 long，int32 或 int64） |
| intc | 與 C 的 int 類型一樣，一般是 int32 或 int 64 |
| intp | 用於索引的整數類型（類似於 C 的 ssize_t，一般情況下仍然是 int32 或 int64） |
| int8 | 字節（-128 to 127） |
| int16 | 整數（-32768 to 32767） |
| int32 | 整數（-2147483648 to 2147483647） |
| int64 | 整數（-9223372036854775808 to 9223372036854775807） |
| uint8 | 無符號整數（0 to 255） |
| uint16 | 無符號整數（0 to 65535） |
| uint32 | 無符號整數（0 to 4294967295） |
| uint64 | 無符號整數（0 to 18446744073709551615） |
| float_ | float64 類型的簡寫 |
| float16 | 半精度浮點數，包括：1 個符號位，5 個指數位，10 個尾數位 |
| float32 | 單精度浮點數，包括：1 個符號位，8 個指數位，23 個尾數位 |
| float64 | 雙精度浮點數，包括：1 個符號位，11 個指數位，52 個尾數位 |
| complex_ | complex128 類型的簡寫，即 128 位複數 |
| complex64 | 複數，表示雙 32 位浮點數（實數部分和虛數部分） |
| complex128 | 複數，表示雙 64 位浮點數（實數部分和虛數部分） |
numpy 的數值類型實際上是 dtype 對象的實例，並對應唯一的字符，包括 np.bool_，np.int32，np.float32，等等。
數據類型對象 (dtype)
數據類型對象是用來描述與數組對應的內存區域如何使用，這依賴如下幾個方面：
- 數據的類型（整數，浮點數或者 Python 對象）
- 數據的大小（例如， 整數使用多少個字節存儲）
- 數據的字節順序（小端法或大端法）
- 在結構化類型的情況下，字段的名稱、每個字段的數據類型和每個字段所取的內存塊的部分
- 如果數據類型是子數組，它的形狀和數據類型
字節順序是通過對數據類型預先設定"<“或”>“來決定的。”<“意味着小端法(最小值存儲在最小的地址，即低位組放在最前面)。”>"意味着大端法(最重要的字節存儲在最小的地址，即高位組放在最前面)。
dtype 對象是使用以下語法構造的：
numpy.dtype(object, align, copy)
- object - 要轉換爲的數據類型對象
- align - 如果爲 true，填充字段使其類似 C 的結構體。
- copy - 複製 dtype 對象 ，如果爲 false，則是對內置數據類型對象的引用
實例
接下來我們可以通過實例來理解。
實例 1
import numpy as np
# 使用標量類型
dt = np.dtype(np.int32)
print(dt)
輸出結果爲：
int32
實例 2
import numpy as np
# int8, int16, int32, int64 四種數據類型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt = np.dtype('i4')
print(dt)
輸出結果爲：
int32
實例 3
import numpy as np
# 字節順序標註
dt = np.dtype('<i4')
print(dt)
輸出結果爲：
int32
下面實例展示結構化數據類型的使用，類型字段和對應的實際類型將被創建。
實例 4
# 首先創建結構化數據類型
import numpy as np
dt = np.dtype([('age',np.int8)])
print(dt)
輸出結果爲：
[('age', 'i1')]
實例 5
# 將數據類型應用於 ndarray 對象
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print(a)
輸出結果爲：
[(10,) (20,) (30,)]
實例 6
# 類型字段名可以用於存取實際的 age 列
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print(a['age'])
輸出結果爲：
[10 20 30]
下面的示例定義一個結構化數據類型 student，包含字符串字段 name，整數字段 age，及浮點字段 marks，並將這個 dtype 應用到 ndarray 對象。
實例 7
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print(student)
輸出結果爲：
[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')]
實例 8
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print(a)
輸出結果爲：
[('abc', 21, 50.0), ('xyz', 18, 75.0)]
每個內建類型都有一個唯一定義它的字符代碼，如下：
| 字符 | 對應類型 |
|---|---|
| b | 布爾型 |
| i | (有符號) 整型 |
| u | 無符號整型 integer |
| f | 浮點型 |
| c | 複數浮點型 |
| m | timedelta（時間間隔） |
| M | datetime（日期時間） |
| O | (Python) 對象 |
| S, a | (byte-)字符串 |
| U | Unicode |
| V | 原始數據 (void) |
NumPy 數組屬性
本章節我們將來了解 NumPy 數組的一些基本屬性。
NumPy 數組的維數稱爲秩（rank），一維數組的秩爲 1，二維數組的秩爲 2，以此類推。
在 NumPy中，每一個線性的數組稱爲是一個軸（axis），也就是維度（dimensions）。比如說，二維數組相當於是兩個一維數組，其中第一個一維數組中每個元素又是一個一維數組。所以一維數組就是 NumPy 中的軸（axis），第一個軸相當於是底層數組，第二個軸是底層數組裏的數組。而軸的數量——秩，就是數組的維數。
很多時候可以聲明 axis。axis=0，表示沿着第 0 軸進行操作，即對每一列進行操作；axis=1，表示沿着第1軸進行操作，即對每一行進行操作。
NumPy 的數組中比較重要 ndarray 對象屬性有：
| 屬性 | 說明 |
|---|---|
| ndarray.ndim | 秩，即軸的數量或維度的數量 |
| ndarray.shape | 數組的維度，對於矩陣，n 行 m 列 |
| ndarray.size | 數組元素的總個數，相當於 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 對象的元素類型 |
| ndarray.itemsize | ndarray 對象中每個元素的大小，以字節爲單位 |
| ndarray.flags | ndarray 對象的內存信息 |
| ndarray.real | ndarray元素的實部 |
| ndarray.imag | ndarray 元素的虛部 |
| ndarray.data | 包含實際數組元素的緩衝區，由於一般通過數組的索引獲取元素，所以通常不需要使用這個屬性。 |
ndarray.ndim
ndarray.ndim 用於返回數組的維數，等於秩。
實例
import numpy as np
a = np.arange(24)
print (a.ndim) # a 現只有一個維度
# 現在調整其大小
b = a.reshape(2,4,3) # b 現在擁有三個維度
print (b.ndim)
輸出結果爲：
1
3
ndarray.shape
ndarray.shape 表示數組的維度，返回一個元組，這個元組的長度就是維度的數目，即 ndim 屬性(秩)。比如，一個二維數組，其維度表示"行數"和"列數"。
ndarray.shape 也可以用於調整數組大小。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print (a.shape)
輸出結果爲：
(2, 3)
調整數組大小。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print (a)
輸出結果爲：
[[1 2]
[3 4]
[5 6]]
NumPy 也提供了 reshape 函數來調整數組大小。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print (b)
輸出結果爲：
[[1, 2]
[3, 4]
[5, 6]]
ndarray.itemsize
ndarray.itemsize 以字節的形式返回數組中每一個元素的大小
例如，一個元素類型爲 float64 的數組 itemsiz 屬性值爲 8(float64 佔用 64 個 bits，每個字節長度爲 8，所以 64/8，佔用 8 個字節），又如，一個元素類型爲 complex32 的數組 item 屬性爲 4（32/8）。
實例
import numpy as np
# 數組的 dtype 爲 int8（一個字節）
x = np.array([1,2,3,4,5], dtype = np.int8)
print (x.itemsize)
# 數組的 dtype 現在爲 float64（八個字節）
y = np.array([1,2,3,4,5], dtype = np.float64)
print (y.itemsize)
輸出結果爲
1
8
ndarray.flags
ndarray.flags 返回 ndarray 對象的內存信息，包含以下屬性：
| 屬性 | 描述 |
|---|---|
| C_CONTIGUOUS © | 數據是在一個單一的C風格的連續段中 |
| F_CONTIGUOUS (F) | 數據是在一個單一的Fortran風格的連續段中 |
| OWNDATA (O) | 數組擁有它所使用的內存或從另一個對象中借用它 |
| WRITEABLE (W) | 數據區域可以被寫入，將該值設置爲 False，則數據爲只讀 |
| ALIGNED (A) | 數據和所有元素都適當地對齊到硬件上 |
| UPDATEIFCOPY (U) | 這個數組是其它數組的一個副本，當這個數組被釋放時，原數組的內容將被更新 |
實例
import numpy as np
x = np.array([1,2,3,4,5])
print (x.flags)
輸出結果爲：
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
NumPy 創建數組
ndarray 數組除了可以使用底層 ndarray 構造器來創建外，也可以通過以下幾種方式來創建。
numpy.empty
numpy.empty 方法用來創建一個指定形狀（shape）、數據類型（dtype）且未初始化的數組：
numpy.empty(shape, dtype = float, order = 'C')
參數說明：
| 參數 | 描述 |
|---|---|
| shape | 數組形狀 |
| dtype | 數據類型，可選 |
| order | 有"C"和"F"兩個選項,分別代表，行優先和列優先，在計算機內存中的存儲元素的順序。 |
下面是一個創建空數組的實例：
import numpy as np
x = np.empty([3,2], dtype = int)
print (x)
輸出結果爲：
[[ 6917529027641081856 5764616291768666155]
[ 6917529027641081859 -5764598754299804209]
[ 4497473538 844429428932120]]
注意 − 數組元素爲隨機值，因爲它們未初始化。
numpy.zeros
創建指定大小的數組，數組元素以 0 來填充：
numpy.zeros(shape, dtype = float, order = 'C')
參數說明：
| 參數 | 描述 |
|---|---|
| shape | 數組形狀 |
| dtype | 數據類型，可選 |
| order | ‘C’ 用於 C 的行數組，或者 ‘F’ 用於 FORTRAN 的列數組 |
實例
import numpy as np
# 默認爲浮點數
x = np.zeros(5)
print(x)
# 設置類型爲整數
y = np.zeros((5,), dtype = np.int)
print(y)
# 自定義類型
z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
print(z)
輸出結果爲：
[0. 0. 0. 0. 0.]
[0 0 0 0 0]
[[(0, 0) (0, 0)]
[(0, 0) (0, 0)]]
numpy.ones
創建指定形狀的數組，數組元素以 1 來填充：
numpy.ones(shape, dtype = None, order = 'C')
參數說明：
| 參數 | 描述 |
|---|---|
| shape | 數組形狀 |
| dtype | 數據類型，可選 |
| order | ‘C’ 用於 C 的行數組，或者 ‘F’ 用於 FORTRAN 的列數組 |
實例
import numpy as np
# 默認爲浮點數
x = np.ones(5)
print(x)
# 自定義類型
x = np.ones([2,2], dtype = int)
print(x)
輸出結果爲：
[1. 1. 1. 1. 1.]
[[1 1]
[1 1]]
NumPy 從已有的數組創建數組
本章節我們將學習如何從已有的數組創建數組。
numpy.asarray
numpy.asarray 類似 numpy.array，但 numpy.asarray 只有三個，比 numpy.array 少兩個。
numpy.asarray(a, dtype = None, order = None)
參數說明：
| 參數 | 描述 |
|---|---|
| a | 任意形式的輸入參數，可以是，列表, 列表的元組, 元組, 元組的元組, 元組的列表，多維數組 |
| dtype | 數據類型，可選 |
| order | 可選，有"C"和"F"兩個選項,分別代表，行優先和列優先，在計算機內存中的存儲元素的順序。 |
實例
將列表轉換爲 ndarray:
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print (a)
輸出結果爲：
[1 2 3]
將元組轉換爲 ndarray:
實例
import numpy as np
x = (1,2,3)
a = np.asarray(x)
print (a)
輸出結果爲：
[1 2 3]
將元組列表轉換爲 ndarray:
實例
import numpy as np
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print (a)
輸出結果爲：
[(1, 2, 3) (4, 5)]
設置了 dtype 參數：
實例
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print (a)
輸出結果爲：
[ 1. 2. 3.]
numpy.frombuffer
numpy.frombuffer 用於實現動態數組。
numpy.frombuffer 接受 buffer 輸入參數，以流的形式讀入轉化成 ndarray 對象。
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
**注意：**buffer 是字符串的時候，Python3 默認 str 是 Unicode 類型，所以要轉成 bytestring 在原 str 前加上 b。
參數說明：
| 參數 | 描述 |
|---|---|
| buffer | 可以是任意對象，會以流的形式讀入。 |
| dtype | 返回數組的數據類型，可選 |
| count | 讀取的數據數量，默認爲-1，讀取所有數據。 |
| offset | 讀取的起始位置，默認爲0。 |
Python3.x 實例
import numpy as np
s = b'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print (a)
輸出結果爲：
[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
Python2.x 實例
import numpy as np
s = 'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print (a)
輸出結果爲：
['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']
numpy.fromiter
numpy.fromiter 方法從可迭代對象中建立 ndarray 對象，返回一維數組。
numpy.fromiter(iterable, dtype, count=-1)
| 參數 | 描述 |
|---|---|
| iterable | 可迭代對象 |
| dtype | 返回數組的數據類型 |
| count | 讀取的數據數量，默認爲-1，讀取所有數據 |
實例
import numpy as np
# 使用 range 函數創建列表對象
list=range(5)
it=iter(list)
# 使用迭代器創建 ndarray
x=np.fromiter(it, dtype=float)
print(x)
輸出結果爲：
[0. 1. 2. 3. 4.]
NumPy 從數值範圍創建數組
這一章節我們將學習如何從數值範圍創建數組。
numpy.arange
numpy 包中的使用 arange 函數創建數值範圍並返回 ndarray 對象，函數格式如下：
numpy.arange(start, stop, step, dtype)
根據 start 與 stop 指定的範圍以及 step 設定的步長，生成一個 ndarray。
參數說明：
| 參數 | 描述 |
|---|---|
start |
起始值，默認爲0 |
stop |
終止值（不包含） |
step |
步長，默認爲1 |
dtype |
返回ndarray的數據類型，如果沒有提供，則會使用輸入數據的類型。 |
實例
生成 0 到 5 的數組:
import numpy as np
x = np.arange(5)
print (x)
輸出結果如下：
[0 1 2 3 4]
設置返回類型位 float:
import numpy as np
# 設置了 dtype
x = np.arange(5, dtype = float)
print (x)
輸出結果如下：
[0. 1. 2. 3. 4.]
設置了起始值、終止值及步長：
import numpy as np
x = np.arange(10,20,2)
print (x)
輸出結果如下：
[10 12 14 16 18]
numpy.linspace
numpy.linspace 函數用於創建一個一維數組，數組是一個等差數列構成的，格式如下：
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
參數說明：
| 參數 | 描述 |
|---|---|
start |
序列的起始值 |
stop |
序列的終止值，如果endpoint爲true，該值包含於數列中 |
num |
要生成的等步長的樣本數量，默認爲50 |
endpoint |
該值爲 ture 時，數列中中包含stop值，反之不包含，默認是True。 |
retstep |
如果爲 True 時，生成的數組中會顯示間距，反之不顯示。 |
dtype |
ndarray 的數據類型 |
以下實例用到三個參數，設置起始點爲 1 ，終止點爲 10，數列個數爲 10。
import numpy as np
a = np.linspace(1,10,10)
print(a)
輸出結果爲：
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
設置元素全部是1的等差數列：
import numpy as np
a = np.linspace(1,1,10)
print(a)
輸出結果爲：
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
將 endpoint 設爲 false，不包含終止值：
import numpy as np
a = np.linspace(10, 20, 5, endpoint = False)
print(a)
輸出結果爲：
[10. 12. 14. 16. 18.]
如果將 endpoint 設爲 true，則會包含 20。
以下實例設置間距。
import numpy as np
a =np.linspace(1,10,10,retstep= True)
print(a)
# 拓展例子
b =np.linspace(1,10,10).reshape([10,1])
print(b)
輸出結果爲：
(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
[[ 1.]
[ 2.]
[ 3.]
[ 4.]
[ 5.]
[ 6.]
[ 7.]
[ 8.]
[ 9.]
[10.]]
numpy.logspace
numpy.logspace 函數用於創建一個於等比數列。格式如下：
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
base 參數意思是取對數的時候 log 的下標。
| 參數 | 描述 |
|---|---|
start |
序列的起始值爲：base ** start |
stop |
序列的終止值爲：base ** stop。如果endpoint爲true，該值包含於數列中 |
num |
要生成的等步長的樣本數量，默認爲50 |
endpoint |
該值爲 ture 時，數列中中包含stop值，反之不包含，默認是True。 |
base |
對數 log 的底數。 |
dtype |
ndarray 的數據類型 |
import numpy as np
# 默認底數是 10
a = np.logspace(1.0, 2.0, num = 10)
print (a)
輸出結果爲：
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
將對數的底數設置爲 2 :
import numpy as np
a = np.logspace(0,9,10,base=2)
print (a)
輸出如下：
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]