python中NumPy的常見用法

import numpy as np

#python array
a = [1,2,3,4,5,6,7,8,9]

#numpy array
A = np.array([1,2,3,4,5,6,7,8,9])

#Numpy數組遠比标準數組緊密，在使用同樣單精度變量下，Numpy數組所需記憶體較小
#此外，Numpy數組是執行更快數值計算的優秀容器
# print(a)                # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# print(A)                # [1 2 3 4 5 6 7 8 9]
# print(type(a))          # <class 'list'>
# print(type(A))          # <class 'numpy.ndarray'>


#另一種定義數組的方式
np.arange(0,10,2)       #arangge([start],stop,[step])   數組取值左閉右開[0 2 4 6 8]
np.arange(2,29,5)       #[ 2  7 12 17 22 27]


A.shape                 #(9,)   矩陣的次元，秩為1
B = A.reshape(3,3)
#[[1 2 3]
#[4 5 6]
#[7 8 9]]
B.shape                 #(3, 3)


#給定需要生成矩陣的形狀後，自動填充零值
np.zeros((4,3))
# [[ 0.  0.  0.]
#  [ 0.  0.  0.]
#  [ 0.  0.  0.]
#  [ 0.  0.  0.]]


#eye()方法将生成一個機關矩陣
np.eye(5)
# [[ 1.  0.  0.  0.  0.]
#  [ 0.  1.  0.  0.  0.]
#  [ 0.  0.  1.  0.  0.]
#  [ 0.  0.  0.  1.  0.]
#  [ 0.  0.  0.  0.  1.]]


#np.dot()矩陣點積。執行該乘法的前提是左邊矩陣的列數（每行的元素）必須等于右邊矩陣的行數，
# 否則就會報錯。此外，根據矩陣乘法的定義，左乘和右乘也不一樣
I = np.eye(3)
D = np.arange(1,10).reshape(3,3)
M = np.dot(D,I)
# [[ 1.  2.  3.]
#  [ 4.  5.  6.]
#  [ 7.  8.  9.]]

# np.sum()将整個矩陣的所有元素加和為一個标量值
sum_val = np.sum(M)        #45.0
#還可以提供參數以确定到底是沿矩陣的行累加還是沿矩陣的列累加。
# 如下我們給定參數 axis=1，其代表将每一行的元素累加為一個标量值,axis=0按列累加。
np.sum(M,axis=1)      #[  6.  15.  24.]
np.sum(M,axis=0)      #[ 12.  15.  18.]

#使用 np.random.rand() 随機生成矩陣，即給定矩陣的形狀，其中每個元素都是随機生成的
np.random.rand(2,3)
# [[ 0.15847386  0.22171854  0.04861573]
#  [ 0.15796091  0.06620758  0.73754384]]
np.random.rand(12,13)

# 如果我們需要手動地給一個數組添加一個或多個元素，那麼我們可以使用 np.append()。
A = np.arange(5,15,2)   #[ 5  7  9 11 13]
A = np.append(A,19)     #[ 5  7  9 11 13 19]
A = np.append(A,[3,55,34,553])   #[  5   7   9  11  13  19   3  55  34 553]

#NumPy 提供了 np.diff() 方法以求 A[n+1]-A[n] 的值，該方法将輸出一個由所有差分組成的數組
A = np.array([5,7,9,11,13,19,3,5,34,553])
B = np.diff(A, n = 1)     #[  2   2   2   2   6 -16   2  29 519]
# n = 1代表執行一次求差分，并傳回差分的數組。而n = 2代表執行兩次差分，
# 并傳回第二次求差分後的數組。第二次求差分是在第一次差分結果數組上進行的
B = np.diff(A,n = 2)      #[  0   0   0   4 -22  18  27 490]

# np.vstack()和np.column_stack()方法将多個向量或矩陣按一定的方法(行、列)堆疊成新的矩陣
a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
A = np.vstack((a,b,c))
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
B = np.column_stack(((a,b,c)))
# [[1 4 7]
#  [2 5 8]
#  [3 6 9]]


# NumPy 數組的索引方式和 Python 清單的索引方式是一樣的,我們可以通過序号索引數組的所有元素。
# 例如 A[i] 索引數組 A 中的第 i+1 個元素。此外，我們還能索引一串元素
A = np.array([5,7,9,11,13,19,3,5,34,553])
B = A[2:5]                #[ 9 11 13]   A[lowerbound(inclusive): upperbound(exclusive)]


# 廣播操作是 NumPy 非常重要的一個特點，它允許 NumPy 擴充矩陣間的運算。
# 例如它會隐式地把一個數組的異常次元調整到與另一個算子相比對的次元以實作次元相容。
# 是以将一個次元為 [3,2] 的矩陣與一個次元為 [3,1] 的矩陣相加是合法的，
# NumPy 會自動将第二個矩陣擴充到等同的次元。
# 為了定義兩個形狀是否是可相容的，NumPy 從最後開始往前逐個比較它們的次元大小。
# 在這個過程中，如果兩者的對應次元相同，或者其一（或者全是）等于 1，
# 則繼續進行比較，直到最前面的次元。若不滿足這兩個條件，程式就會報錯。
a = np.array([1.0,2.0,3.0,4.0,5.0,6.0]).reshape(3,2)
b = np.array([3.0])
c = a * b
# [[  3.   6.]     嚴格數學意義上，a 和 b 是不能執行矩陣乘法的，因為它們的次元不符合要求。
#  [  9.  12.]     但在 NumPy 的廣播機制下，次元為 1 的項何以擴充到相應的次元，是以它們就能夠執行運算。
#  [ 15.  18.]]


#矩陣轉置
a = np.array([[1,0],[2,3]])
# [[1 0]
#  [2 3]]
b = a.transpose()
# [[1 2]
#  [0 3]]

#運算矩陣的迹 線上性代數中，一個n×n矩陣A的主對角線（從左上方至右下方的對角線）
# 上各個元素的總和被稱為矩陣A的迹（或迹數），一般記作tr(A)。
print(np.trace(a))         #  4

# numpy.linalg 子產品中有很多關于矩陣運算的方法，如下計算矩陣的特征值與特征向量
import numpy.linalg as nplg
print(nplg.eig(a))
c,d = nplg.eig(a)
print(c)              #特征值
# [ 3.  1.]
print(d)              #特征向量
# [[ 0.          0.70710678]
#  [ 1.         -0.70710678]]