簡介

NumPy是Python語言的一個擴展包。支持多維數組與矩陣運算，此外也針對數組運算提供大量的數學函數庫。NumPy提供了與Matlab相似的功能與操作方式，因為兩者皆為直譯語言。

NumPy通常與SciPy(Scientific Python)和Matplotlib(繪圖庫)一起使用，這種組合廣泛用於替代Matlab，是一個流行的技術平台。

使用舉例

import numpy as np
from matplotlib import pyplot as plt
# 一維
a = np.array([1, 2, 3]); print(a) # [1 2 3]
# 等間隔數字的數組
b = np.arange(10); print(b) # [0 1 2 3 4 5 6 7 8 9]
# 二維
c = np.array([[1, 2], [3, 4]]); print(c) # [[1 2]
# [3 4]]
# ndmin指定返回數組的最小維數
d = np.array([1, 2, 3, 4, 5]); print(d) # [1 2 3 4 5]
e = np.array([1, 2, 3, 4, 5], ndmin=2); print(e) # [[1 2 3 4 5]]
# dtype:數組的所需數據類型
f = np.array([1, 2, 3], dtype=complex); print(f) # [1.+0.j 2.+0.j 3.+0.j]
# 使用數組標量類型
dt = np.dtype(np.int32); print(dt) # int32
# int8,int16,int32,int64可替換為等價的字符串'i1', 'i2', 'i4', 'i8'
dt = np.dtype('i8'); print(dt) # int64
# 調整數組shape
a = np.array([[1, 2, 3], [4, 5, 6]]); print(a); # [[1 2 3]
# [4 5 6]]
a.shape = (3, 2); print(a) # [[1 2]
# [3 4]
# [5 6]]
a = np.array([[1, 2, 3], [4, 5, 6]]); b = a.reshape(3, 2); print(b) # [[1 2]
# [3 4]
# [5 6]]
# ndim:返回數組的維數
a = np.arange(24); print(a.ndim) # 1
# numpy.reshape: 在不改變數據的條件下修改形狀
b = a.reshape(2, 4, 3); print(b.ndim) # 3
# itemsize:返回數組中每個元素的字節單位長度
a = np.array([1, 2, 3, 4], dtype=np.int8); print(a.itemsize) # 1
a = np.array([1, 2, 3, 4], dtype=np.float32); print(a.itemsize) # 4
# 空數組
x = np.empty([3, 2], dtype='i1'); print(x) # 數組x的元素為隨機值，因為它們未初始化
# 含有5個0的數組，若不指定類型，則默認為float
x = np.zeros(5, dtype=np.int); print(x) # [0 0 0 0 0]
# 含有6個1的二維數組，若不指定類型，則默認為float
x = np.ones([2, 3], dtype=int); print(x) # [[1 1 1]
# [1 1 1]]
# 將列表轉換為ndarray
x = [1, 2, 3]
a = np.asarray(x, dtype=float); print(a) # [1. 2. 3.]
# 將元組轉換為ndarray
x = (1, 2, 3)
a = np.asarray(x, dtype=complex); print(a) # [1.+0.j 2.+0.j 3.+0.j]
# 使用內置的range()函數創建列表對象
x = range(5); print(x) # range(0, 5)
# 從列表中獲得迭代器
it = iter(x); print(it) # <range_iterator object at 0x000000000330BFD0>
# 使用迭代器創建ndarray, fromiter函數從任何可迭代對象構建一個ndarray對象,返回一個新的一維數組
y = np.fromiter(it, dtype=float); print(y) # [0. 1. 2. 3. 4.]
# arange函數返回ndarray對象，包含給定范圍內的等間隔值
# numpy.arange(start, stop, step, dtype), start起始值，默認為0;stop終止值，不包含; step間隔，默認為1
x = np.arange(4, dtype=float); print(x) # [0. 1. 2. 3.]
x = np.arange(10, 20, 2); print(x) # [10 12 14 16 18]
# numpy.linspace，此函數類似於arange，在此函數中，指定了范圍之間的均勻間隔數量，而不是步長
# numpy.linspace(start, stop, num, endpoint, retstep, dtype)
# start,起始值;stop,終止值,如果endpoint為true,該值包含於序列中;num,要生成的等間隔樣例數量,默認為50;
# endpoint,序列中是否包含stop值,默認為true;retstep,如果為true,返回樣例,以及連續數字之間的步長
x = np.linspace(10, 20, 5); print(x) # [10. 12.5 15. 17.5 20.]
x = np.linspace(10, 20, 5, endpoint=False); print(x) # [10. 12. 14. 16. 18.]
x = np.linspace(1,2,5, retstep=True); print(x) # (array([ 1. , 1.25, 1.5 , 1.75, 2. ]), 0.25)
# numpy.logspace,此函數返回ndarray對象,包含在對數刻度上均勻分布的數字.刻度的開始和結束端點是某個底數的冪,通常為10
# numpy.logscale(start, stop, num, endpoint, base, dtype)
# base,對數空間的底數，默認為10;其它參數同numpy.linspace
a = np.logspace(1.0, 2.0, num=5); print(a) # [10. 17.7827941 31.6227766 56.23413252 100.]
a = np.logspace(1, 10, num=5, base=2); print(a) # [2. 9.51365692 45.254834 215.2694823 1024.]
# ndarray對象的內容可以通過索引或切片來訪問和修改，就像Python的內置容器對象一樣;
# 基本切片：通過將start、stop和step參數提供給內置的slice函數來構造一個Python slice對象，用來提前數組的一部分
a = np.arange(10); s = slice(2,7,2); print(a[s]) # [2 4 6]
# 通過將由冒號分隔的切片參數(start:stop:step)直接提供給ndarray對象,也可以獲得相同的結果
a = np.arange(10); b = a[2:7:2]; print(b) # [2 4 6]
a = np.arange(10); b = a[2:]; print(b) # [2 3 4 5 6 7 8 9]
a = np.arange(10); b = a[2:5]; print(b) # [2 3 4]
# 切片還可以包括省略號(...),來使選擇元組的長度與數組的維度相同
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
b = a[..., 1]; print(b) # [2 4 5]
c = a[1, ...]; print(c) # [3 4 5]
# 高級索引：如果一個ndarray是非元組序列，數據類型為整數或布爾值的ndarray，或者至少一個元素為
# 序列對象的元組，我們就能夠用它來索引ndarray，高級索引始終返回數據的副本
# 高級索引:整數：基於N維索引來獲取數組中任意元素
x = np.array([[1, 2], [3, 4], [5, 6]])
# y中包括數組x中(0,0), (1,1), (2,0)位置處的元素
y = x[[0,1,2], [0,1,0]]; print(y) # [1 4 5]
# 高級索引：布爾值：當結果對象是布爾運算的結果時，將使用此類型的高級索引
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
y = x[x > 5]; print(y) # [6 7 8 9 10 11]
# ~(取補運算符)來過濾NaN
x = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])
y = x[~np.isnan(x)]; print(y) # [1. 2. 3. 4. 5.]
# 從數組中過濾掉非復數元素
x = np.array([1, 2+6j, 5, 3.5+5j])
y = x[np.iscomplex(x)]; print(y) # [2.0+6.j 3.5+5.j]
# 廣播：是指NumPy在算術運算期間處理不同形狀的數組的能力, 對數組的算術運算通常在相應的元素上運行
# 如果兩個數組的維數不相同，則元素到元素的操作是不可能的。然而，在NumPy中仍然可以對形狀不相似的數組進行操作，因為它擁有廣播功能。
# 較小的數組會廣播到較大數組的大小，以便使它們的形狀可兼容
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
c = a * b; print(c) # [10 40 90 160]
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0]])
b = np.array([1.0,2.0,3.0])
c = a + b; print(c) # [[1.0 2.0 3.0]
# [11. 12. 13.]]
# 數組上的迭代：NumPy包包含一個迭代器對象numpy.nditer。它是一個有效的多維迭代器對象，可以用於在數組上進行迭代。
# 數組的每個元素可使用Python的標准Iterator接口來訪問
a = np.arange(0, 60, 5)
a = a.reshape(3,4)
for x in np.nditer(a):
print(x, end=' ') # 0 5 10 15 20 25 30 35 40 45 50 55
print('\n')
# 修改數組的值: nditer對象的一個可選參數op_flags,其默認值為只讀,但可以設置為讀寫或只寫模式.這將允許使用此迭代器修改數組元素
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x; print(x, end=' ') # 0 10 20 30 40 50 60 70 80 90 100 110
print('\n')
# numpy.raval:返回展開的一維數組，並且按需生成副本。返回的數組和輸入數組擁有相同數據類型
a = np.arange(8).reshape(2,4)
b = a.ravel(); print(b) # [0 1 2 3 4 5 6 7]
# numpy.unique: 返回輸入數組中的去重元素數組
a = np.array([5, 2, 6, 2, 7, 5, 6, 8, 2, 9])
u = np.unique(a); print(u) # [2 5 6 7 8 9]
# 位操作:bitwise_and, bitwise_or, invert, left_shift, right_shift
a,b = 13,17; print(bin(a), bin(b)) # 0b1101 0b10001
c = np.bitwise_and(13, 17); print(c) # 1
c = np.bitwise_or(13, 17); print(c) # 29
# 字符串函數：add, multiply, center, capitalize, title, lower, upper, split, splitlines, strip, join, replace, decode, encode
print(np.char.add(['hello'],[' Spring'])) # ['hell Spring']
print(np.char.multiply('Hello ',3)) # Hello Hello Hello
# numpy.char.center: 此函數返回所需寬度的數組,以便輸入字符串位於中心,並使用fillchar在左側和右側進行填充
print(np.char.center('hello', 20, fillchar = '*')) # *******hello********
a = np.char.encode('hello', 'cp500'); print(a) # b'\x88\x85\x93\x93\x96'
b = np.char.decode(a, 'cp500'); print(b) # hello
# 三角函數：sin, cos, tan, arcsin, arccos, arctan
a = np.array([0, 30, 45, 60, 90])
b = np.sin(a*np.pi/180); print(b) # [ 0. 0.5 0.70710678 0.8660254 1.]
# 捨入函數: around, floor, ceil
a = np.array([1.0, 5.55, 123, 0.567, 25.532])
b = np.around(a); print(b) # [1. 6. 123. 1. 26.]
# 算數運算：add, subtract, multiply, divide, reciprocal, power, mod 輸入數組必須具有相同的形狀或符合數組廣播規則
a, b = [5, 6], [7, 10]
c = np.subtract(a, b); print(c) # [-2 -4]
# 統計函數：用於從數組中給定的元素中查找最小，最大，百分標准差和方差等, amin, amax, ptp, percentile, median, mean, average, std
a = np.array([1, 2, 3, 4, 5])
print(np.amin(a)) # 1
print(np.median(a)) # 3.0
print(np.mean(a)) # 3.0
# 副本和視圖: 在執行函數時，其中一些返回輸入數組的副本，而另一些返回視圖。 當內容物理存儲在另一個位置時，稱為副本。
# 另一方面，如果提供了相同內存內容的不同視圖，我們將其稱為視圖
a = np.arange(6); print(a) # [0 1 2 3 4 5]
print(id(a)) # 54667664
b = a
print(id(b)) # 54667664
b.shape = 2,3
print(a); # [[0 1 2]
# [3 4 5]]
# IO: ndarray對象可以保存到磁盤文件並從磁盤文件加載
# load()和save()函數處理NumPy二進制文件(帶npy擴展名)
# loadtxt()和savetxt()函數處理正常的文本文件
a = np.array([1, 2, 3, 4, 5])
np.save('E:/GitCode/Python_Test/test_data/outfile.npy', a)
b = np.load('E:/GitCode/Python_Test/test_data/outfile.npy')
print(b) # [1 2 3 4 5]
np.savetxt('E:/GitCode/Python_Test/test_data/outfile.txt', a)
b = np.loadtxt('E:/GitCode/Python_Test/test_data/outfile.txt')
print(b) # [1. 2. 3. 4. 5.]
# Matplotlib是Python的繪圖庫，在http://matplotlib.org/examples/ 中含有大量的matplotlib使用用例
x = np.arange(1,11)
y = 2 * x + 5
plt.title("Matplotlib demo")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x,y, 'ob')
plt.show()