numpy的基本使用2

阳光穿透心脏的1/2处 2023-01-10 14:40 119阅读 0赞

### numpy的基本使用2 ###

官网：http://www.numpy.org

import numpy as np
    ##数组（矩阵）间操作：
    x = np.array([1,2,3])
    y = np.array([3,2,1])
    z = np.array([6,6,6])
    #拼接合并：
    np.concatenate([x,y,z])
    array([1, 2, 3, 3, 2, 1, 6, 6, 6])
    A = np.array([])
    A = np.array([[1,2,3],
                  [3,2,1]])
    np.concatenate([A,A])
    array([[1, 2, 3],
           [3, 2, 1],
           [1, 2, 3],
           [3, 2, 1]])
    #第三个参数为轴向，默认0（x轴行） 1（y轴列） 支持更多维度
    np.concatenate([A,A],axis=1)
    array([[1, 2, 3, 1, 2, 3],
           [3, 2, 1, 3, 2, 1]])
    #注意：z为数组（向量），需转化为和A相同维度后才能合并
    z
    array([6, 6, 6])
    z.reshape(1,-1)
    array([[6, 6, 6]])
    #注意：新版本不能直接这样子写：np.concatenate(A,z.reshape(1,-1))
    np.concatenate((A,z.reshape(1,-1)),axis=0)
    array([[1, 2, 3],
           [3, 2, 1],
           [6, 6, 6]])
    #复习：Numpy中原矩阵并不会改变
    #其他方法 垂直方向堆叠：
    np.vstack([A,z])
    array([[1, 2, 3],
           [3, 2, 1],
           [6, 6, 6]])
    
    #构建2乘2矩阵 水平方向堆叠：
    B = np.full(shape=(2,2),fill_value=1)
    B
    array([[1, 1],
           [1, 1]])
    np.hstack([A,B])
    array([[1, 2, 3, 1, 1],
           [3, 2, 1, 1, 1]])

#分割：
    x = np.arange(10)
    x
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    #分割点：3和8，将数组x分割为3段：
    x1,x2,x3 = np.split(x,[3,8])
    x1
    array([0, 1, 2])
    x2
    array([3, 4, 5, 6, 7])
    x3
    array([8, 9])
    #注意：分隔两段也需要传入数组：
    x1,x2 = np.split(x,[5])
    x1
    array([0, 1, 2, 3, 4])
    x2
    array([5, 6, 7, 8, 9])
    
    #创建一个4乘4的矩阵：
    A = np.arange(16).reshape((4,4))
    A
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15]])
    #默认水平（行）拆分
    A1,A2 = np.split(A,[2])
    A1
    array([[0, 1, 2, 3],
           [4, 5, 6, 7]])
    A2
    array([[ 8,  9, 10, 11],
           [12, 13, 14, 15]])
    #指定垂直（列）方向分割，axis=1 默认0
    A1,A2 = np.split(A,[2],axis=1)
    A1
    array([[ 0,  1],
           [ 4,  5],
           [ 8,  9],
           [12, 13]])
    A2
    array([[ 2,  3],
           [ 6,  7],
           [10, 11],
           [14, 15]])
    #其他方法：
    A1,A2 = np.vsplit(A,[2])
    A1
    array([[0, 1, 2, 3],
           [4, 5, 6, 7]])
    A1,A2 = np.hsplit(A,[2])
    A1
    array([[ 0,  1],
           [ 4,  5],
           [ 8,  9],
           [12, 13]])

#前面提到数据集矩阵一般最后一列为标记，前面为特征：
    data = np.arange(16).reshape((4,4))
    data
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15]])
    #从倒数第一列进行分割：
    X,y=np.hsplit(data,[-1])
    X
    array([[ 0,  1,  2],
           [ 4,  5,  6],
           [ 8,  9, 10],
           [12, 13, 14]])
    y
    array([[ 3],
           [ 7],
           [11],
           [15]])
    #转为向量：
    y[:,0]
    array([ 3,  7, 11, 15])

#数组（矩阵）运算
    #原list中操作：
    L = [i for i in range(10)]
    L
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    #Python中乘法为2个L拼接：
    L * 2
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    #矩阵乘法（每个元素乘以2）
    #法一：
    M = []
    for e in L:
    ... M.append(e*2);
    ...
    M
    [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
    #法二（更加高效）：
    M = [2 * e for e in L]
    M
    [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
    
    #Numpy中：直接相乘即可（效率更高）：
    L = np.arange(10)
    L
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    M = L * 2
    M
    array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
    #注：Numpy中直接视为向量或矩阵进行运算，且算法进行优化，与Python中的list运算完全不在统一级别

#Universal Functions：
    X = np.arange(16).reshape((4,4))
    X
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15]])
    X+1
    array([[ 1,  2,  3,  4],
           [ 5,  6,  7,  8],
           [ 9, 10, 11, 12],
           [13, 14, 15, 16]])
    X
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15]])
    #除 浮点/
    X/2
    array([[0. , 0.5, 1. , 1.5],
           [2. , 2.5, 3. , 3.5],
           [4. , 4.5, 5. , 5.5],
           [6. , 6.5, 7. , 7.5]])
    #整除 //
    X//2
    array([[0, 0, 1, 1],
           [2, 2, 3, 3],
           [4, 4, 5, 5],
           [6, 6, 7, 7]], dtype=int32)
    #n次方 **n
    X ** 2
    array([[  0,   1,   4,   9],
           [ 16,  25,  36,  49],
           [ 64,  81, 100, 121],
           [144, 169, 196, 225]], dtype=int32)
    #其他函数方法 abs sin cos ...
    np.sin(X)
    array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],
           [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],
           [ 0.98935825,  0.41211849, -0.54402111, -0.99999021],
           [-0.53657292,  0.42016704,  0.99060736,  0.65028784]])
    #e的x次方
    np.exp(X)
    array([[1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01],
           [5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03],
           [2.98095799e+03, 8.10308393e+03, 2.20264658e+04, 5.98741417e+04],
           [1.62754791e+05, 4.42413392e+05, 1.20260428e+06, 3.26901737e+06]])
    #power(n,x)x的n次方，等同于**n
    np.power(3,X)
    array([[       1,        3,        9,       27],
           [      81,      243,      729,     2187],
           [    6561,    19683,    59049,   177147],
           [  531441,  1594323,  4782969, 14348907]], dtype=int32)
    
    X = np.arange(1,17)
    X
    array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])
    np.log10(X)
    array([0.        , 0.30103   , 0.47712125, 0.60205999, 0.69897   ,
           0.77815125, 0.84509804, 0.90308999, 0.95424251, 1.        ,
           1.04139269, 1.07918125, 1.11394335, 1.14612804, 1.17609126,
           1.20411998])

#矩阵间运算：
    import numpy as np
    A = np.arange(4).reshape(2,2)
    A
    array([[0, 1],
           [2, 3]])
    B = np.full((2,2),6)
    B
    array([[6, 6],
           [6, 6]])
    A + B
    array([[6, 7],
           [8, 9]])
    #注意：Numpy中乘法也是对应元素相乘
    A * B
    array([[ 0,  6],
           [12, 18]])
    #标准矩阵乘法（线性代数知识）
    A.dot(B)
    array([[ 6,  6],
           [30, 30]])
    #转置
    A.T
    array([[0, 2],
           [1, 3]])
    
    #向量与矩阵的运算
    v = np.array([1,2])
    v
    array([1, 2])
    A
    array([[0, 1],
           [2, 3]])
    v + A
    array([[1, 3],
           [3, 5]])
    A.shape[0]
    2
    A.shape
    (2, 2)
    #堆叠相加
    #np.tile(v,(水平方向堆叠次数，垂直方向堆叠次数))
    np.tile(v,(2,1))
    array([[1, 2],
           [1, 2]])
    np.tile(v,(2,1)) + A
    array([[1, 3],
           [3, 5]])
    v * A
    array([[0, 2],
           [2, 6]])
    #标准矩阵间乘法
    v.dot(A)
    array([4, 7])
    #注意：numpy会自动判断 将[1,2]转化为列向量
    A.dot(v)
    array([2, 8])
    
    #矩阵的逆
    A
    array([[0, 1],
           [2, 3]])
    #linalg：linear algebra线性代数缩写inv：逆inverse缩写
    invA = np.linalg.inv(A)
    invA
    array([[-1.5,  0.5],
           [ 1. ,  0. ]])
    #线性代数基础：A*A-1=E（单位矩阵）A为n*n的方阵
    A.dot(invA)
    array([[1., 0.],
           [0., 1.]])
    #X不为方阵的情况下 numpy可以求伪逆阵
    X = np.arange(16).reshape((2,8))
    X
    array([[ 0,  1,  2,  3,  4,  5,  6,  7],
           [ 8,  9, 10, 11, 12, 13, 14, 15]])

跟着大佬梳理的流程走下来的，在这里注明一下出处：

[https://github.com/Exrick/Machine-Learning][https_github.com_Exrick_Machine-Learning]  
注：大佬的更直观详细

[https_github.com_Exrick_Machine-Learning]: https://github.com/Exrick/Machine-Learning