numpy矩阵与通用函数

谁践踏了优雅 2022-01-15 02:49 222阅读 0赞

Numpy是用于数据科学计算的基础，不但能够完成科学计算任务，还能被  
用作高效地多维数据容器。用于存储和处理大型矩阵。  
Python提供了一个array模块，和list不同，它直接保存数值，但是由于  
Python 的array模块不支持多维，也没有各种运算函数。  
Numpy 弥补了这一遗憾。Numpy提供了一种存储单一数据类型的多维数  
组——ndarray

import numpy as n
    #创建一个数组
    #更改数组形状
    # arr=np.arange(16).reshape(4,4)
    # print(arr)
    # arr.shape=(4,4)
    # print(arr)
    """
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]]
    """
    
    
    #展评数组
    # arr=np.arange(16).reshape(4,4)
    # print(np.ravel(arr))
    #或
    # print(arr.ravel())
    """
    [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
    """
    
    
    #横向展平
    # arr=np.arange(16).reshape(4,4)
    # print(arr)
    # print(arr.flatten())  #默认参数C
    """
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]]
    [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
    """
    
    
    #纵向展平
    # arr=np.arange(16).reshape(4,4)
    # print(arr)
    # print(arr.flatten('F'))  #参数是F
    """
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]]
    [ 0  4  8 12  1  5  9 13  2  6 10 14  3  7 11 15]
    """
    
    
    #数组横向拼接
    # arr1=np.arange(6).reshape(2,3)
    # arr2=np.array([[1,2,3],[2,3,4]])
    # print(np.hstack((arr1,arr2)))#注意传递的是元组(arr1,arr2)
    """
    [[0 1 2 1 2 3]
     [3 4 5 2 3 4]]
    """
    #或
    # print(np.concatenate((arr1,arr2),axis=1))   1 代表横向
    """
    [[0 1 2 1 2 3]
     [3 4 5 2 3 4]]
    """
    
    
    #数组纵向拼接
    # arr1=np.arange(6).reshape(2,3)
    # arr2=np.array([[1,2,3],[2,3,4]])
    # print(np.vstack((arr1,arr2)))
    #或
    # print(np.concatenate((arr1,arr2),axis=0))   #0 代表纵向
    """
    [[0 1 2]
     [3 4 5]
     [1 2 3]
     [2 3 4]]
    
    """
    
    
    #拼接，转置
    # arr1=np.arange(6).reshape(2,3)
    # arr2=np.array([[1,2]])
    # print(arr2.ndim)
    # print(arr1)
    # print(arr2)
    # print(np.concatenate((arr1,arr2.T),axis=1))
    """
    [[0 1 2]
     [3 4 5]]
     
    [[1 2]]
    
    [[0 1 2 1]
     [3 4 5 2]]
    
    """
    """
    维度必须保持一致才可以进行拼接
    拼接过程中如果横向拼接必须保持行一致
    纵向拼接必须列一致
    """
    
    
    #数组横向拆分
    # arr=np.arange(16).reshape(4,4)
    # print(arr)
    # print(np.hsplit(arr,2))
    #或
    # print(np.split(arr,2,axis=1))
    """
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]]
    [array([[ 0,  1],
           [ 4,  5],
           [ 8,  9],
           [12, 13]]), array([[ 2,  3],
           [ 6,  7],
           [10, 11],
           [14, 15]])]
    
    """
    
    
    #数组纵向拆分
    # arr=np.arange(16).reshape(4,4)
    # print(arr)
    # print(np.vsplit(arr,2))
    # print(np.split(arr,2,axis=0))
    """
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]]
    [array([[0, 1, 2, 3],
           [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
           [12, 13, 14, 15]])]
    [array([[0, 1, 2, 3],
           [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
           [12, 13, 14, 15]])]
    """
    
    
    #创建矩阵2种方法
    # m1=np.mat('1 2 3;4 5 6;7 8 9')
    # print(m1)
    #或
    # m1=np.mat([[1,2,3],[4,5,6],[7,8,9]])
    # print(m1)
    """
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    """
    
    
    #创建矩阵 matrix
    # m1=np.matrix([[1,2,3],[2,3,4],[3,4,5]])
    # print(m1)
    # print(m1.ndim)
    # print(type(m1))
    """
    [[1 2 3]
     [2 3 4]
     [3 4 5]]
    2
    <class 'numpy.matrix'>
    
    """
    """
    mat比matrix  更节省内存 因为matrix  会拷贝一份
    """
    
    
    #组合矩阵
    # m1=np.mat('1 2 3;4 5 6;7 8 9')
    # m2=np.mat([[0,2,3],[4,0,6],[0,8,9]])
    # m3=np.bmat('m1,m2;m2,m1')
    #或
    # m3=np.bmat([[m1,m2],[m2,m1]])
    # print(m3)
    """
    [[1 2 3 0 2 3]
     [4 5 6 4 0 6]
     [7 8 9 0 8 9]
     [0 2 3 1 2 3]
     [4 0 6 4 5 6]
     [0 8 9 7 8 9]]
    """
    
    
    #矩阵的四则运算
    # m1=np.mat('1 2 3;2 3 4')
    #单独与数相乘  对应元素位置相乘
    # m=m1*5
    # print(m)
    """
    [[ 5 10 15]
     [10 15 20]]
    """
    
    
    #矩阵相加   对应元素位置相加
    # m1=np.mat('1 2 3;2 3 4')
    # m2=np.mat('1 1 1;1 1 1')
    # print(m1+m2)
    # print(m1-m2)
    """
    [[2 3 4]
     [3 4 5]]
     
     [[0 1 2]
     [1 2 3]]
    """
    
    
    #矩阵互乘
    # m1=np.mat('1 2 3;2 3 4')
    # m2=np.mat('3 1 1;2 2 1').reshape(3,2)
    # print(m1)
    # print(m2)
    # print(m1*m2)
    # print(np.matmul(m1,m2))
    # print(np.dot(m1,m2))
    """
    [[11  8]
     [17 12]]
    """
    """
    m n*n m   左矩阵列数必须与右矩阵行数相同才可以相乘
    
    """
    
    
    #矩阵对应元素相乘   区别于矩阵互乘
    # m1=np.mat('1 2 3;2 3 4')
    # m2=np.mat('1 2 3;2 3 4')
    # print(np.multiply(m1,m2))
    """
    [[ 1  4  9]
     [ 4  9 16]]
    
    """
    
    
    # m=np.mat('1 0 3;2 7 4;3 4 5')
    # print('m',m)
    # print('m转置',m.T)#行列转换
    # print('m共轭转置',m.H)#先共轭  在转置
    # print('m逆',m.I)#相乘等于E单位矩阵
    # print('m视图',m.A)#视图
    # print('m视图',type(m.A))#<class 'numpy.ndarray'>
    
    
    #数组的四则运算
    # arr1=np.arange(4).reshape(2,2)
    # print(arr1)
    # arr2=np.array([[1,2],[1,2]])
    # print(arr2)
    #加法  对应元素加减
    # arr=arr1+arr2
    # print(arr)
    
    #减法
    # arr=arr1-arr2
    # print(arr)
    
    #乘法   对应元素相乘（注意：不同于矩阵）
    # arr=arr1*arr2
    # print(arr)
    
    #除法   对应元素相除  分母不为0
    # arr=arr1/arr2
    # print(arr)
    
    #幂
    # arr=arr1**arr2
    # print(arr)
    """
    [[0 1]
     [2 3]]
    [[1 2]
     [1 2]]
    [[1 3]
     [3 5]]
    [[-1 -1]
     [ 1  1]]
    [[0 2]
     [2 6]]
    [[0.  0.5]
     [2.  1.5]]
    [[0 1]
     [2 9]]
    """
    
    
    #比较运算
    # arr1=np.arange(4).reshape(2,2)
    # print(arr1)
    # arr2=np.array([[1,2],[1,2]])
    # print(arr2)
    #
    # print('arr1>=arr2',arr1>=arr2)
    # print('arr1<=arr2',arr1<=arr2)
    # print('arr1==arr2',arr1==arr2)
    # print('arr1!=arr2',arr1!=arr2)
    #返回布尔数组
    """
    [[0 1]
     [2 3]]
    [[1 2]
     [1 2]]
    arr1>=arr2 [[False False]
     [ True  True]]
    arr1<=arr2 [[ True  True]
     [False False]]
    arr1==arr2 [[False False]
     [False False]]
    arr1!=arr2 [[ True  True]
     [ True  True]]
    """
    
    
    #逻辑运算 any  all   运算结果返回布尔值
    # arr1=np.arange(4).reshape(2,2)
    # print(arr1)
    # arr2=np.array([[0,1],[1,2]])
    # print(arr2)
    #
    # print(np.any(arr1==arr2)) #相当于or   其中一个为真  就成立True
    # print(np.all(arr1==arr2))  #相当于and
    """
    [[0 1]
     [2 3]]
    [[0 1]
     [1 2]]
    True
    False
    
    """
    
    
    #数组排序
    # arr=np.arange(16,0,-1)
    # print(arr)
    # arr.sort()#进行排序  从小到大
    # print(arr)
    """
    [16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1]
    [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
    """
    
    
    #二维数组排序
    # arr=np.arange(16,0,-1).reshape(4,4)
    # print(arr)
    # arr.sort(axis=1)#按照 横向进行排序
    # print(arr)
    # arr.sort(axis=0)#按照 纵向进行排序
    # print(arr)
    """
    [[16 15 14 13]
     [12 11 10  9]
     [ 8  7  6  5]
     [ 4  3  2  1]]
    [[13 14 15 16]
     [ 9 10 11 12]
     [ 5  6  7  8]
     [ 1  2  3  4]]
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]
     [13 14 15 16]]
    """
    
    
    #间接排序，下标排序
    # arr=np.arange(4,0,-1)
    # print(arr)
    # print(np.argsort(arr))
    #或
    # print(arr.argsort())
    """
    [4 3 2 1]
    [3 2 1 0]
    """
    
    
    # arr1=np.array([3,2,5,7,0])
    # arr2=np.array([90,67,87,24,54])
    # arr3=np.array([111,320,200,222,100])
    # arr=np.lexsort((arr1,arr2,arr3))#根据最后一个排序方式对前几个影响
    # print(arr)
    """
    [4 0 2 3 1]
    """
    
    
    # arr=np.array(['刘争1','刘争','刘争2','刘争3','刘争1','刘争','刘争3','刘争2'])
    # # print(arr)
    # arr_new=np.unique(arr)#去重   排序
    # print(arr_new)
    """
    ['刘争' '刘争1' '刘争2' '刘争3']
    """
    
    
    #重复数据 tile  对整个数组进行重复
    # arr=np.arange(4).reshape(2,2)
    # a=np.tile(arr,3)
    # print(a)
    """
    [[0 1 0 1 0 1]
     [2 3 2 3 2 3]]
    """
    
    
    #重复数据  repeat  对行列进行重复
    arr=np.arange(4).reshape(2,2)
    a=np.repeat(arr,3,axis=1)#横向重复
    # print(a)
    """
    [[0 0 0 1 1 1]
     [2 2 2 3 3 3]]
    """
    a=np.repeat(arr,3,axis=0)#纵向重复
    print(arr)
    print(a)
    """
    [[0 1]
     [2 3]]
    [[0 1]
     [0 1]
     [0 1]
     [2 3]
     [2 3]
     [2 3]]
    """
    
    
    #常用指标统计
    #创建数组
    #本题按照横向的方向进行求取
    arr=np.arange(9).reshape(3,3)
    print(arr)
    #sum,mean,std,var,min,max,argmax,argmin,cumsum,cumprod
    # print('arr的和',arr.sum())
    print('arr的和',np.sum(arr,axis=1))
    print('arr的均值',np.mean(arr,axis=1))
    print('arr的标准差',np.std(arr,axis=1))
    print('arr的方差',np.var(arr,axis=1))
    print('arr的最小值',np.min(arr,axis=1))
    print('arr的最大值',np.max(arr,axis=1))
    print('arr的最大值下标',np.argmax(arr,axis=1))
    print('arr的最小值下标',np.argmin(arr,axis=1))
    print('arr的累计和',np.cumsum(arr,axis=1))
    print('arr的累计积',np.cumprod(arr,axis=1))
    """
    [[0 1]
     [2 3]]
    [[0 1]
     [0 1]
     [0 1]
     [2 3]
     [2 3]
     [2 3]]
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    arr的和 [ 3 12 21]
    arr的均值 [1. 4. 7.]
    arr的标准差 [0.81649658 0.81649658 0.81649658]
    arr的方差 [0.66666667 0.66666667 0.66666667]
    arr的最小值 [0 3 6]
    arr的最大值 [2 5 8]
    arr的最大值下标 [2 2 2]
    arr的最小值下标 [0 0 0]
    arr的累计和 [[ 0  1  3]
     [ 3  7 12]
     [ 6 13 21]]
    arr的累计积 [[  0   0   0]
     [  3  12  60]
     [  6  42 336]]
    """