一、矩阵的操作

1、numpy 创建矩阵的方法

import numpy as np
#1.直接使用分号隔开的字符串
mat = np.mat('1 2 3;4 5 6;7 8 9')
print(mat)

# 2.使用numpy数组创建矩阵
arr = np.arange(1, 10).reshape(3, 3)
mat2 = np.mat(arr)
print(mat2)

# 3.从已有的矩阵中通过bmat函数复合创建矩阵
A = np.eye(2)
B = A * 2

mat3 = np.bmat('A B;B A')
print(A)
print(B)
print(mat3)

2、创建随机矩阵

# 创建一个服从正太分布的随机矩阵
normal = np.random.normal(size=3000)
print(normal)

#生成图
# plt.hist(normal)
# plt.show()

#创建一个服从beta分布的随机样本
beta = np.random.beta(a=.9,b=.9,size=500)
plt.hist(beta)
plt.show()

#产生4x4的随机正太样本
normal2 = np.random.normal(size=(200,200))
print("normal=4x4: \n",normal2)
plt.hist(normal2)
plt.show()

#产生在某个范围内的随机整数数组或者是矩阵
numbers = np.mat(np.random.randint(1,100,[5,5]))
print(numbers)

#产生0-1之间的随机浮点数
floatnum = np.mat(np.random.random(10))
print(floatnum)

#在某个范围之内的所有数中随机抽取一个
#0-5之间取10个
rand = np.random.choice(5,10)

#0-5之间取一个2行3列的矩阵
rand1 = np.random.choice(5,(2,3))
print(rand)
print(rand1)

3、矩阵的运算

mat1 = np.mat(np.array([2,6,5]))
mat2 = np.mat(np.array([1,4,7]))

#矩阵的加法
result = np.add(mat1,mat2)
print(result)
print(mat1+mat2)

#数组乘法
multi = np.multiply(mat1,mat2)
print(multi)

#矩阵乘法
mat3 = np.mat(np.arange(6).reshape(2,3))
mat4 = np.mat(np.arange(6).reshape(3,2))
print(mat3*mat4)

a = np.mat(np.array([4, 5, 8]))
b = np.mat(np.array([2, 3, 5]))

# 数组除法  a 除以 b
result = np.divide(a, b)
print(result)

# 数组除法并结果向下取整
result2 = np.floor_divide(a, b)
print(result2)

# 矩阵相除
print(a / b)
print(a // b)
print(a % b)

# 取模运算
mat1 = np.mat(np.array([5, -7, 9]))
mat2 = np.mat(np.array([2, -4, 3]))

# remainder函数：逐个返回两个数组中元素相除后的余数
result = np.remainder(mat1, mat2)
print(result)

result2 = np.mod(mat1, mat2)
print(result2)

result3 = mat1 % mat2
print(result3)

# fmod函数所得余数的正负由被除数决定，与除数的正负无关
result4 = np.fmod(mat1, mat2)
print(result4)

4、通用函数

1、一元通用函数
    mat = np.mat(np.array([-10,5,-4,3,9,12]))
    print(np.abs(mat))
    print(np.fabs(mat))
    
    #获取mat矩阵中各元素的正负号
    sign = np.sign(mat)
    print(sign)
    
    # 将数组中元素的小数和整数部分抽取出来
    arr = np.array([[1.2, 3.14],
                    [-2.6, 6.8]])
    arr1, arr2 = np.modf(arr)
    print("小数部分：\n", arr1)
    print("整数部分：\n", arr2)
    
    # 取平方
    print(np.square(arr))
    # 取整
    print(np.ceil(arr))
    # 向下取整
    print(np.floor(arr))
    # 四舍五入（不包括5）
    print(np.rint(arr))

2、二元通用函数
    # 求mat2的mat1次方
    mat1 = np.mat(np.array([1,2,3,4,5]))
    mat2 = np.mat(np.array([2,3,2,1,3]))
    print("power:",np.power(mat1,mat2))
    
    # # 获取两个数组对应元素的最大值和最小值，返回一个新的数组
    d2 = np.array([[22,15],
                   [5.4,4.0]])
    d3 = np.array([[15,28],
                   [7.9,4.0]])
    maximun = np.maximum(d2,d3)
    print("maximun:\n",maximun)
    minimum = np.minimum(d2,d3)
    print("minimum:\n",minimum)
    
    # 数组比较函数
    result = np.greater(d2,d3)
    print(result)
    
    result2 = d2.compress(result)
    print(result2)
    
    #python转换为bool为False
    
    bool1 = np.array([[1,0],
                      [3,5]])
    bool2 = np.array([[0,1],
                      [12,0]])
    
    bool3 = np.logical_and(bool1,bool2)
    print(bool3)

3、创建通用函数
    a = np.arange(24).reshape(2,4,3)
    print("a:\n",a)
    like_a = np.zeros_like(a)
    print("like_a \n",like_a)
    
    like_a.flat = 42
    print(like_a)
    
    # #创建一个numpy通用函数
    def likeA(ndarray):
        result = np.zeros_like(ndarray)
        result = 42
        return result
    
    #调用numpy创建通用函数的方法
    #创建通用函数， 1个输入， 1个输出
    func = np.frompyfunc(likeA,1,1)
    test =func(np.arange(9).reshape(3,3))
    print(test)
    
    b = np.arange(9)
    print(b)
    # 等价于对矩阵元素求和
    print("reduce求和：", np.add.reduce(b))
    print("sum求和：", np.sum(b))
    
    # accumulate 依次将数组元素相加的每一步结果保存到一个新数组(加累加的结果保存到新的数组中)
    print("accumulate:",np.add.accumulate(b))
    
    
    # reduceat 根据给定的区间分段进行reduce求和操作
    result = np.add.reduceat(b, [0, 5, 2, 7])
    print(result)
    
    # outer 将第一个数组中的每个元素分别和第二个数组中的所有元素相加求和
    arr1 = np.array([1,6])
    arr2 = np.array([3,4,7,4,5,8])
    result = np.add.outer(arr1,arr2)
    print(result)

二、线性代数的应用

1、矩阵的应用

1、矩阵求逆
    A = np.mat(np.array([[0, 1, 2],
                         [1, 0, 3],
                         [4, -3, 8]]))
    print(A)
    # 求A的逆矩阵
    A_ = np.linalg.inv(A)
    print(A_)
    # 验证A*A_的结果是否是一个单位矩阵
    print("A*A_:\n",A*A_)

2、矩阵求解方程式
    #用numpy求解三元一次方程组
    A = np.mat("1 -2 1;0 2 -8;-4 5 9")
    print(A)
    b = np.array([0,8,-9])
    print(b)
    
    # 调用numpy的solve方法求解
    C = np.linalg.solve(A,b)
    print("x = {},y={},z={}".format(C[0],C[1],C[2]))
    
3、特征向量和特征值
    vector = np.mat("3 -2;1 0")
    print(vector)
    
    #求向量的特征值
    eigenvalues = np.linalg.eigvals(vector)
    
    #同时求向量的特征值和特征向量
    eigenavalues,eigvector = np.linalg.eig(vector)
    print("向量的特征值:",eigenavalues)
    print("特征向量:\n",eigvector)

4、奇异值分解
    vector = np.mat("4 11 14;8 7 -2")
    print(vector)
    
    # 调用numpy中的svd方法对矩阵进行奇异值分解
    U, sigma, V = np.linalg.svd(vector, full_matrices=False)
    print("U: \n", U)
    print("sigma: \n", sigma)
    print("V: \n", V)
    
    # 将svd分解出的值相乘
    print("vector: \n", U * np.diag(sigma) * V)

2、专用函数

1、求矩阵的行列式
    vector = np.mat("3 4;5 6")
    print(vector)
    # 矩阵的行列式
    result = np.linalg.det(vector)
    print("result: ",result)
    
2、数组的排序方法
    # a、对数组元素进行排序,修改本身
    arr = np.array([4, 6, 44, 22, 1])
    # arr.sort()
    print(arr)
    
    # b、返回排序后的数组元素的索引
    argsort = np.argsort(arr)
    print(argsort)
    
    d2 = np.array([[12, 8, 35],
                   [22, 55, 9],
                   [10, 30, 20]])
    # axis = 0 按列排序，axis=1 按行排序
    d2.sort(axis=0)
    print(d2)
    
    # 二维数组argsort,返回列索引
    argsort2 = np.argsort(d2, axis=0)
    print(argsort2)
    # 二维数组argsort,返回行索引,-d2指的是降序
    argsort3 = np.argsort(-d2, axis=1)
    print(argsort3)
    
3、搜索函数
    a = np.array([[12, 50, -34],
                  [18, 56, 6]])
    b = np.array([33, 22, 44, 56, 11, 7])
    # 获取最大值的索引
    argmax1 = np.argmax(a)
    print(argmax1)
    # 获取最小值的索引
    argmin = np.argmin(a)
    print(argmin)
    # np.nan作为数组的None值
    a1 = np.array([[12, np.nan, -34],
                  [18, 56, 6]])
    nanmax = np.nanargmax(a1)
    print(nanmax)
    
    # 根据条件在数组中搜索非零元素，并分组返回对应的索引
    print("b>22:\n", np.argwhere(b > 22))
    print("b>44:\n", np.argwhere(b > 44))
    
    # searchsort 为需要添加到数组中的元素寻找合适的下标，使得元数组的排序顺序不变
    sorted = np.arange(5)
    print("添加新元素之前：",sorted)
    indices = np.searchsorted(sorted, [-2, 7])
    print("寻找到的插入位置下标：",np.searchsorted(sorted, [-2, 7, 3]))
    # 根据寻找到的下标，将元素添加到数组中,返回新的数组
    reuslt = np.insert(sorted,indices,[-2,7])
    print("添加新元素之后：",reuslt)
    
4、元素抽取
    a = np.arange(10)
    
    # 生成一个抽取数组元素的花式索引
    condition = a %2 ==0    #赋值运算符，算术运算符，逻辑运算符优先级
    print("花式索引：",condition)
    
    # np.extract()根据给点的条件提取数组元素
    even = np.extract(condition,a)
    print("数组中的偶数项：",even)
    
    #用数组的compress方法提取元素
    even2 = a.compress(condition)
    print(even2)
    
    # 用numpy的take函数实现提取偶函数项 np.where
    indices = np.where(a % 2 ==0)
    print("偶数项元素的索引：",indices)
    print("even3:",np.take(a,indices))
    
    
    # 提取数组中的非0元素 np.nonzero()
    arr = np.array([[0,1,2],
                    [0,3,4],
                    [0,5,6]])
    
    rows,cols = np.nonzero(arr)
    print("rows：",rows)
    print("cols：",cols)
    
    result = np.dstack((rows,cols))
    print(result)