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]]