您的位置:首页 > 编程语言 > Python开发

机器学习入门--Numpy基础

Mingw_ 2020-03-15 18:22 55 查看 https://blog.csdn.net/mingw_/a

文章目录

  • (二)numpy.array的基本操作
  • (三)numpy.array中的运算
  • (四)聚合操作
  • (五)索引


  • 一、前言

      本文基于liuyubobobo老师机器学习视频做成的个人总结博客,仅供分享,欢迎大家一起探讨与交流。
      建议大家在学习时,自己多敲代码去实践,在不断尝试中 掌握相应的方法。

    二、编译环境

     IDE:Jupyter Notebook
     库 : Numpy

    三、Numpy基础


    (一)创建numpy.array的方法

      1.np.array()

    import numpy as np
    np.arr1 = np.array([1,2,3,4])  #创建一维数组
    output:array([1,2,3,4])
    
    np.arr2 = np.array([[1,2,3],  	#创建二维数组,同理可创建多维数组
    [4,5,6]])
    output:array([[1, 2, 3],
    [4, 5, 6]])
    
    np.arr3 = np.array([i for i in range(10)]) #也可利用列表初始化
    output:array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

      说明:在numpy.array中,只能有一种数据类型,不能修改为其他类型,例如:整型数组内不能存入字符,这点不同于array.array方法;另外当我们在整型数组中存入浮点类型时,会自动隐式类型转换,具体细节可通过help(np.array)查看官方文档

      2.np.zeros()、np.ones()、np.full()

    arr1 = np.zeros(shape=(2,3),dtype='float64')
    output:array([[0., 0., 0.],
    [0., 0., 0.]])
    '''创建全0数组或矩阵
    第一个参数:大小/形状
    第二个参数:存入的参数类型(默认为浮点类型)'''
    
    arr2 = np.ones(shape=(2,3),dtype='float64')
    output:array([[1., 1., 1.],
    [1., 1., 1.]])
    '''创建全1数组或矩阵
    第一个参数:大小/形状
    第二个参数:存入的参数类型(默认为浮点类型)'''
    
    arr3 = np.full(shape=(2,3),fill_value=666;dtype='float64')
    output:array([[666., 666., 666.],
    [666., 666., 666.]])
    '''创建数值全为"fill_value"的数组或矩阵
    第一个参数:生成数组的大小/形状
    第二个参数:数值
    第三个参数:存入的参数类型(默认为整数类型)'''

      3.np.eye()

    arr1 = np.eye(N=3,M=2,k=1,dtype='float')
    output:array([[0., 1.],
    [0., 0.],
    [0., 0.]])
    
    arr2 = np.eye(N=3,M=3,k=0,dtype='float')
    output:array([[1., 0., 0.],
    [0., 1., 0.],
    [0., 0., 1.]])
    
    '''第一个参数:行数
    第二个参数:列数
    第三个参数:默认情况下输出的是对角线全“1”,其余全
    “0”的方阵,如果k为正整数,则在右上方第k条对角线全
    “1”其余全“0”,k为负整数则在左下方第k条对角线全“1”
    其余全“0”。
    第四个参数:参数类型,默认为浮点类型'''

      4.np.arange()、np.linspace()

    arr1 = np.arange(0,10,1)
    output:array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    '''在[0,10)生成一个步长为1的数组
    第一个参数:起始位置(默认为0)
    第二个参数:终结位置
    第三个参数:步长(默认为1)
    注意:范围是左闭右开区间
    '''
    
    arr2 = np.linspace(0,5,6)
    output:array([0., 1., 2., 3., 4., 5.])
    '''在[0,5]生成等步长的6个值
    第一个参数:起始位置
    第二个参数:终止位置
    第三个参数:生成值得数量
    说明:该函数内还有其他参数,在此不一一说明,如有兴趣
    可通过help()进行查看'''

      5.np.random()

    arr1 = np.random.randint(0,10,size=10) #生成含有10个在[0,10)内元素的向量
    output:array([0, 8, 0, 3, 5, 1, 9, 1, 7, 9])
    arr2 = np.random.randint(0,10,size=(2,3)) #size参数也可为元组,此时生成一个二维的矩阵
    output:array([[1, 4, 6],
    [2, 2, 3]])
    
    arr3 = np.random.random(size=(2,3)) #生成0——1之间的浮点数
    output:array([[0.70043712, 0.84418664, 0.67651434],
    [0.72785806, 0.95145796, 0.0127032 ]])
    
    arr4 = np.random.normal(loc=0,scale=1,size=(2,3))
    output:array([[-0.57172145, -0.10949727,  0.01902826],
    [-0.94376106,  0.64057315, -0.78644317]])
    '''生成符合均值为0方差为1分布的随机浮点数
    第一个参数:均值
    第二个参数:方差
    第三个参数:生成的数组大小/形状'''

      说明:可通过np.random.seed()的方式加入随机种子,保证每次生成的随机数相同

    (二)numpy.array的基本操作

      1.基本属性

    '''初始化数组/矩阵'''
    x1 = np.arange(0,20,2)
    output:array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
    x2 = np.arange(15).reshape(3,5)
    output:array([[ 0,  1,  2,  3,  4],
    [ 5,  6,  7,  8,  9],
    [10, 11, 12, 13, 14]])
    
    x1.ndim   #数组的维度
    output:1
    x2.ndim
    output:2
    
    x1.shape #返回数组形状
    output:(10,)
    x2.shape
    output:(3, 5)
    
    x1.size #返回数组元素个数
    output:10
    x2.size
    output:15

      2.数据访问

    '''初始化数组/矩阵'''
    x1 = np.arange(0,20,2)
    output:array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
    x2 = np.arange(15).reshape(3,5)
    output:array([[ 0,  1,  2,  3,  4],
    [ 5,  6,  7,  8,  9],
    [10, 11, 12, 13, 14]])
    
    x1[0:5]  #访问从[0,5)下标的数
    output:array([0, 2, 4, 6, 8])
    
    x1[:5]  #访问从头到第五个元素的数
    output:array([0, 2, 4, 6, 8])
    
    x1[5:]  #访问从第五个到最后一个元素的数
    output:array([10, 12, 14, 16, 18])
    
    x1[::2] #从头访问到尾,每次步长为2
    output:array([ 0,  4,  8, 12, 16])
    
    x1[::-2] #步长为负数则从尾开始访问
    output:array([18, 14, 10,  6,  2])
    
    x2[:2,:3]  #对于多维数组操作类似,此例表示取出前两行的前三列的数
    output:array([[0, 1, 2],
    [5, 6, 7]])
    
    x2[0,:]  #取出第0行的数据
    output:array([0, 1, 2, 3, 4])
    
    x2[:,0] #取出第0列的数据
    output:array([ 0,  5, 10])

      说明:如果通过此方式将访问的对象赋值给另一个数组时,改变其值,同样会造成原数组值的改变,反之亦然。要想使该数据和原来数组数据无关,则需要采用copy()方法,例:X2 = x2[0 , : ].copy()。

      3.reshape

    '''初始化数组/矩阵'''
    x1 = np.arange(0,20,2)
    output:array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
    
    x1.reshape(2,5)  #将其变成2维矩阵,但此时不会改变x1原来的形状
    output:array([[ 0,  2,  4,  6,  8],
    [10, 12, 14, 16, 18]])
    
    x1.reshape(1,10)  #此时将一维向量修改为二维的矩阵
    output:array([[ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18]])
    
    x1.reshape(5,-1)  #传入-1,系统会自动进行计算该维度有多少值
    output:array([[ 0,  2],
    [ 4,  6],
    [ 8, 10],
    [12, 14],
    [16, 18]])

      4.合并操作

    '''初始化数组/矩阵'''
    x = np.array([1,2,3])
    y = np.array([3,2,1])
    z = np.array([2,3,1])
    A = np.arange(1,7).reshape(2,3)
    outputA:array([[1, 2, 3],
    [4, 5, 6]])
    
    np.concatenate([x,y]) #拼接
    output:array([1, 2, 3, 3, 2, 1])
    
    np.concatenate([x,y,z])  #可以不仅仅只拼接两个向量
    output:array([1, 2, 3, 3, 2, 1, 2, 3, 1])
    
    np.concatenate([A,A],axis=1)  #沿着第1个维度方向拼接,默认axis=0(即第0个维度),且不能处理两个维度不相同的矩阵
    output:array([[1, 2, 3, 1, 2, 3],
    [4, 5, 6, 4, 5, 6]])
    
    np.vstack([A,x])   #同样也可以利用vstack处理不同维度拼接的问题,此时会自动在垂直方向进行拼接
    output:array([[1, 2, 3],
    [4, 5, 6],
    [1, 2, 3]])
    np.hstack([A,x[:2].reshape(2,1)])
    output:array([[1, 2, 3, 1],
    [4, 5, 6, 2]])
    '''注意:传入的数据不能非法
    例如:np.hstack([A,x[:2]]),此时传入的向量,在该维
    度下大小不一致,导致无法进行运算'''

      5.分割操作

    '''初始化数组/矩阵'''
    x = np.arange(10)
    output:array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    A = np.arange(16).reshape(4,4)
    output:array([[ 0,  1,  2,  3],
    [ 4,  5,  6,  7],
    [ 8,  9, 10, 11],
    [12, 13, 14, 15]])
    
    x1,x2,x3 = np.split(x,[3,7])
    '''第一个参数:要分割的对象
    第二个参数:分割点'''
    output1:[0 1 2]
    output2:[3 4 5 6]
    output3:[7 8 9]
    
    A1,A2 = np.split(A,[2],axis=1) #在第1个维度分割,默认在第0个维度分割
    output1:[[ 0  1]
    [ 4  5]
    [ 8  9]
    [12 13]]
    output2:[[ 2  3]
    [ 6  7]
    [10 11]
    [14 15]]
    upper,lower = np.vsplit(A,[2]) #在垂直方向分割
    output_upper:[[0 1 2 3]
    [4 5 6 7]]
    output_lower:[[ 8  9 10 11]
    [12 13 14 15]]
    left,right = np.hsplit(A,[2]) #在水平方向分割
    output_left:[[ 0  1]
    [ 4  5]
    [ 8  9]
    [12 13]]
    output_right:[[ 2  3]
    [ 6  7]
    [10 11]
    [14 15]]

    (三)numpy.array中的运算

      1.Universal Functions

    '''初始化数组/矩阵'''
    X = np.arange(1,16).reshape(3,5)
    output:array([[ 1,  2,  3,  4,  5],
    [ 6,  7,  8,  9, 10],
    [11, 12, 13, 14, 15]])
    
    X+1  #加法
    output:array([[ 2,  3,  4,  5,  6],
    [ 7,  8,  9, 10, 11],
    [12, 13, 14, 15, 16]])
    
    X-1  #减法
    output:array([[ 0,  1,  2,  3,  4],
    [ 5,  6,  7,  8,  9],
    [10, 11, 12, 13, 14]])
    
    X*2   #乘法
    output:array([[ 2,  4,  6,  8, 10],
    [12, 14, 16, 18, 20],
    [22, 24, 26, 28, 30]])
    
    X / 2  #除法
    output:array([[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 #整除
    output:array([[0, 1, 1, 2, 2],
    [3, 3, 4, 4, 5],
    [5, 6, 6, 7, 7]], dtype=int32)
    
    X % 2  #求余
    output:array([[1, 0, 1, 0, 1],
    [0, 1, 0, 1, 0],
    [1, 0, 1, 0, 1]], dtype=int32)
    
    1 / X #取倒数
    output:array([[1.        , 0.5       , 0.33333333, 0.25      , 0.2       ],
    [0.16666667, 0.14285714, 0.125     , 0.11111111, 0.1       ],
    [0.09090909, 0.08333333, 0.07692308, 0.07142857, 0.06666667]])
    
    np.abs(X)  #求绝对值
    output:array([[ 1,  2,  3,  4,  5],
    [ 6,  7,  8,  9, 10],
    [11, 12, 13, 14, 15]])
    
    np.sin(X)  #取正弦函数值,同样的有np.cos(),np.tan()
    output:array([[ 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]])
    
    np.exp(X)  #取e的X次方
    output:array([[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]])
    
    np.power(3,X) #取3的X次方
    output:array([[       3,        9,       27,       81,   243],
    [     729,     2187,     6561,    19683,    59049],
    [  177147,   531441,  1594323,  4782969, 14348907]], dtype=int32)
    
    np.log2(X)   #取以2为底X的log值,默认取以e为底的对数值
    output:array([[0.        , 1.        , 1.5849625 , 2.        , 2.32192809],
    [2.5849625 , 2.80735492, 3.        , 3.169925  , 3.32192809],
    [3.45943162, 3.5849625 , 3.70043972, 3.80735492, 3.9068906 ]])

      2.矩阵运算

    '''初始化数组/矩阵'''
    A = np.arange(4).reshape(2,2)
    B = np.full((2,2),1)
    outputA:[[0 1]
    [2 3]]
    outputB:[[1 1]
    [1 1]]
    
    A+B #矩阵之间的加法(对应元素相加) 同类型的还有A-B A*B等
    output:array([[1, 2],
    [3, 4]])
    
    A.dot(B)  #数学定义上的矩阵乘法
    output:array([[1, 1],
    [5, 5]])
    
    A.T   #求转置矩阵
    output:array([[0, 2],
    [1, 3]])

      3.矩阵的逆

    '''初始化数组/矩阵'''
    A = np.arange(4).reshape(2,2)
    outputA:[[0 1]
    [2 3]]
    A2 = np.arange(15).reshape(3,5)
    outputA2:array([[ 0,  1,  2,  3,  4],
    [ 5,  6,  7,  8,  9],
    [10, 11, 12, 13, 14]])
    
    np.linalg.inv(A)  #求A矩阵的逆矩阵
    output:array([[-1.5,  0.5],
    [ 1. ,  0. ]])
    
    pinvX = np.linalg.pinv(A2)  #对于非方阵,可以对其求伪逆矩阵
    output:array([[-2.26666667e-01, -6.66666667e-02,  9.33333333e-02],
    [-1.23333333e-01, -3.33333333e-02,  5.66666667e-02],
    [-2.00000000e-02, -1.02282287e-17,  2.00000000e-02],
    [ 8.33333333e-02,  3.33333333e-02, -1.66666667e-02],
    [ 1.86666667e-01,  6.66666667e-02, -5.33333333e-02]])

    (四)聚合操作

    '''为了便于理解,以例子的方式进行讲解'''
    L = np.arange(15).reshape(5,3)
    output:array([[ 0,  1,  2],
    [ 3,  4,  5],
    [ 6,  7,  8],
    [ 9, 10, 11],
    [12, 13, 14]])
    
    sum1 = np.sum(L)   #求和
    sum2 = np.sum(L,axis=0) #沿着第0个维度进行和运算
    output1:105
    output2:[30 35 40]
    
    min_L = np.min(L)   #求最小值
    max_L = np.max(L)   #求最大值
    output1:0
    output2:14
    
    np.prod(L)   #对L中每个元素进行相乘
    output:0
    
    np.mean(L)  #求平均值
    output:7.0
    
    np.median(L) #求中位数
    output:7.0
    
    for percent in [0,25,50,100]:
    print(np.percentile(L,q=percent))
    output:0.0
    3.5
    7.0
    14.0
    '''第一个参数:传入的数组,
    第二个参数:百分之多少的数小于等于该值'''
    
    np.val(L)	#求方差
    output:18.666666666666668
    
    np.std(L)	#求标准差
    output:4.320493798938574

    (五)索引

    '''为了便于理解,以例子的方式进行讲解'''
    L = np.random.randint(15,size=(10,))   #注意,若此时size为(10,1),则该数组为二维
    output:array([8, 1, 9, 5, 4, 9, 8, 8, 4, 8])
    
    max_X = np.max(L)
    max_argX = np.argmax(L)  #返回最大值的索引,对最小值同理
    output1:9
    output2:2
    
    L1 = np.sort(L)
    L2 = np.argsort(L)   #返回排序值的索引
    output1:[1 4 4 5 8 8 8 8 9 9]
    output2:[1 4 8 3 0 6 7 9 2 5]
    • 点赞 2
    • 收藏
    • 分享
    • 文章举报
    Mingw_ 发布了36 篇原创文章 · 获赞 64 · 访问量 2795 私信 关注
    标签: