Numpy学习

下载numpy库：

在cmd中直接输入命令行即可

pip install numpy

在python命令行中输入import numpy测试是否安装成功，如图则成功

下面是练习：

首先导入模块和设置随机数种子

import numpy as np
import time

np.random.seed(np.int64(time.time()))

生成高斯随机项矩阵A和托普利兹矩阵B

def toeplitz(X, Y):
    res = np.zeros([len(X), len(Y)])
    for i in range(len(X)):
        for j in range(len(Y) - i):
            res[j][j+i] = Y[i]
        for j in range(i, len(X)):
            res[j][j-i] = X[i]
    return res
        
n = 2
m = 5
A = np.random.normal(loc = 0.0, scale = 1.0, size = [n, m])
X = np.random.normal(size = m)
Y = np.random.normal(size = m)
B = toeplitz(X, Y)

print(A + A)
print(np.matmul(A, A.T))
print(np.matmul(A.T, A))
print(np.matmul(A, B))
def matmul_A_B_L(A, B, constant):
    LAM = np.eye(len(B), len(B))
    # print(LAM)
    return np.matmul(A, B - constant*LAM)
print(matmul_A_B_L(A, B, 3))

def solveLinearSystem(B, b):
    '''solve Bx = b'''
    return np.matmul(b, B.T)
b = np.random.normal(size = m)
print(solveLinearSystem(B, b))

利用np.linalg.norm(x, ord=None, axis=None, keepdims=False)求范数

①x: 表示矩阵（也可以是一维）

②ord：范数类型

向量的范数：

矩阵的范数：

ord=1：列和的最大值

ord=2：|λE-ATA|=0，求特征值，然后求最大特征值得算术平方根

ord=∞：行和的最大值

③axis：处理类型

axis=1表示按行向量处理，求多个行向量的范数

axis=0表示按列向量处理，求多个列向量的范数

axis=None表示矩阵范数。

④keepding：是否保持矩阵的二维特性

True表示保持矩阵的二维特性，False相反

习题解：

frobenius_norm_A = np.linalg.norm(A, ord=2)
infinity_norm_B = np.linalg.norm(B, ord=np.inf)
u, s, sh = np.linalg.svd(B)
max_singular_B = max(s)
min_singular_B = min(s)
print(frobenius_norm_A)
print(infinity_norm_B)
print(max_singular_B)
print(min_singular_B)

def power_iteration(Z, stop):  
    u = np.random.normal(size=[len(Z)]).transpose()  
    u = u / np.max(u)  
    v = u.copy()  
    eigen_change = np.inf  
    eigen_val = np.max(v)  
  
    iteration = 0  
    s_time = time.clock()  
    while abs(eigen_change) > stop:  
        v = np.matmul(Z, u)  
        max_v = np.max(v)  
        eigen_change = eigen_val - max_v  
        eigen_val = max_v  
        u = v/max_v  
        iteration += 1  
    print("Total iteration: {}".format(iteration))  
    print("Total time: {}s".format(time.clock() - s_time))  
    return [eigen_val, u, iteration, time.clock() - s_time]  

Z = np.random.normal(size=[20, 20])  
stop = 1e-8  
print(power_iteration(Z, stop)) 

n = 1000
P = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
for p in P:
    C = np.random.random(size = [n, n])
    for i in range(n):
        for j in range(n):
            C[i][j] = 1 if C[i][j] > p else 0
    u, s, ch = np.linalg.svd(C)
    max_singular_C = np.max(s)
    print("n = {}, p = {}, max_singular_C = {}".format(n, p, max_singular_C))

输出如下：

由此可推测：n * (1 - p) = max_singular_C

def nearestNeighbor(array_A, value_z):
    index = np.argmin(np.abs(array_A - value_z))
    return array_A[index]
array_A = np.random.random(size = 100)
print(nearestNeighbor(array_A, 0.5))