Python机器学习基础之Numpy库的使用

小咪咪 2021-09-15 09:36 455阅读 0赞

声明：代码的运行环境为Python3。Python3与Python2在一些细节上会有所不同，希望广大读者注意。本博客以代码为主，代码中会有详细的注释。相关文章将会发布在我的个人博客专栏[《Python从入门到深度学习》][Python]，欢迎大家关注。

[一、Python机器学习基础之Python的基本语法（一）][Python_Python]

[二、Python机器学习基础之Python的基本语法（二）][Python_Python 1]

三、Python机器学习基础之Numpy库的使用

[四、Python机器学习基础之Pandas库的使用][Python_Pandas]

[五、Python机器学习基础之Matplotlib库的使用][Python_Matplotlib]

[六、Sklearn库和TensorFlow框架][Sklearn_TensorFlow]

[七、Python两种方式加载文件内容][Python 1]

Scipy库是基于Python生态的一款开源数值计算、科学与工程应用的开源软件，包括常用的Numpy、Pandas、Matplotlib等库。下面开始我们的第三讲：Python机器学习基础之Numpy库的使用。

Numpy（Numerical Python），即数值Python包，是Python进行科学计算的一个基础包，因此要更好理解和掌握Python科学计算包，尤其是Pandas，需要先掌握Numpy库的用法。

Numpy系统是Python的一种开源的数值计算扩展，是一个用Python实现的科学计算包。包括：

（1）一个具有矢量算数运算和复杂广播能力的快速且节省空间的多维数组，称为ndarray(N-dimensional array object);

（2）用于对整组数据进行快速计算的标准数学函数，ufunc（universal function object）；

（3）用于整合C/C++和Fortran代码的工具包；

（4）实用的线性代数、傅里叶变换和随机数生成函数。Numpy和稀疏矩阵运算包scipy配合使用更加方便。

【代码】

'''
    机器学习基础之Numpy模块的简单使用
    '''
    
    # 导入需要的包
    import numpy as np
    
    # ndarray介绍：ndarray指的是N维数组。一种由相同类型的元素组成的多维数组，元素数量是事先指定好的。元素的数据类型由dtype（data-type）
    # 对象来指定，每个ndarray只有一种dtype类型。它的大小是固定的，创建好数组时一旦指定好大小，就不会再发生改变。
    
    # ndarry属性
    a = np.array([
        [
            [1, 2, 3],
            [2, 3, 4]
        ],
        [
            [3, 4, 5],
            [4, 5, 6]
        ]
    ])
    print("数组a的维度：", a.ndim)
    print("数组a的数组元素数据类型：", a.dtype)
    print("数组a的形状：", a.shape)
    print("数组a的元素总个数：", a.size)
    
    # ndarry的shape属性巧算：以数组a为例。去掉最外围的[]，得到几个元素，表示第一维元素为几，这里是2
    print("数组a的第一维：", a[0], '\n', a[1])
    # 再去掉一个[]，以此类推。这里第二维为2，第三维为3
    print("数组a的第二维：", a[0][0])
    print("数组a的第三维：", a[0][0][0])
    
    # ndarray的常见创建方式：
    # array函数：接收一个普通的Python序列，转成ndarray
    # zeros函数：创建指定长度或形状的全零数组
    # ones函数：创建指定长度或形状的全1数组
    # empty函数：创建一个没有任何具体值的数组（准确地说是一些未初始化的垃圾值）
    print("zero", '\n', np.zeros((3, 4)))
    print("ones", '\n', np.ones((3, 4)))
    print("empty", '\n', np.empty((3, 4, 5)))
    
    # ndarry的其他创建方式：
    # arange函数：类似于python的range函数，通过指定开始值、终值和步长来创建一维数组，注意数组不包括终值
    # linspace函数：通过指定开始值、终值和元素个数来创建一维数组，可以通过endpoint关键字指定是否包括终值，缺省设置是包括终值
    # logspace函数：和linspace类似，不过它创建等比数列
    # 使用随机数填充数组，即使用numpy.random模块的random()函数，数组所包含的的元素数量由参数决定
    print("arange", '\n', np.arange(20))
    print("arange", '\n', np.arange(0, 20, 1))
    print("arange", '\n', np.arange(0, 20, 2))
    # reshape()函数可以改变数组的形状，但是值得注意的是元素的总个数不能改变
    print("reshape", '\n', np.arange(0, 12).reshape(3, 4))
    print("linspace", '\n', np.linspace(0, 10, 5, endpoint=True))
    print("linspace", '\n', np.linspace(0, 10, 5, endpoint=False))
    # 通过help命令可以查看该方法的使用方法
    help(np.linspace)
    # 0表示10的零次方，2表示10的二次方，5表示生成的数组元素总数
    print("logspace", '\n', np.logspace(0, 2, 5))
    # 指定随机数生成的数的形状
    print("random", '\n', np.random.random((2, 2, 4)))
    
    # Numpy中的数据类型：数值型dtype的命名方式——一个类型名后面接一个用于表示各元素位长的数字。
    # 每种类型有一个相应的类型代码，即简写方式，参照下表：
    ##################################################################################################
    # 数据类型    #   类型代码    #                         说明                                        #
    # int_      #              # 默认整型（与C中long相同，通常为int64或者int32）                           #
    # intc      #              # 完全等同于C中的long（通常为int64或者int32）                              #
    # intp      #              # 表示索引的整型，与C中的size_t相同，通常为int64或者int32                    #
    # int8      # i1           # 字节（-128~127），1个字节                                              #
    # int16     # i2           # 整型（-32768~32767），2个字节                                          #
    # int32     # i4           # 整型（-2147483648~2147483647），4个字节                                #
    # int64     # i8           # 整型（-9223372036854775808~9223372036854775807），8字节                #
    # uint8     # u1           # 无符号整型（0~255）                                                    #
    # uint16    # u2           # 无符号整型（0~65535）                                                  #
    # uint32    # u4           # 无符号整型（0~4294967295）                                             #
    # uint64    # u8           # 无符号整型                                                            #
    # float_    #              # float64的简写形式                                                     #
    # float16   # f2           # 半精度浮点型：符号位，5位指数，10位小数部分                                #
    # float32   # f4或者f       # 半精度浮点型：符号位，8位指数，23位小数部分                                #
    # float64   # f8或者d       # 半精度浮点型：符号位，11位指数，52位小数部分                               #
    # float128  # f16或者g      # 扩展精度浮点数                                                        #
    # complex_  # c16          # complex128的简写形式                                                  #
    # complex64 # c8           # 复数，由两个32位的浮点数来表示（市属部分和虚数部分）                         #
    # complex128# c16          # 复数，由两个32位的浮点数来表示（市属部分和虚数部分）                         #
    # bool_     #              # 以一个字节形式存储布尔值（True或False）                                  #
    # bool      # ?            # 存储True和False值的布尔类型                                            #
    # object    # O            # Python对象类型                                                       #
    # String_   # S            # 固定长度的字符串类型（每个字符一个字节）。例如要创建一个长度为8的字符串，应使用S8 #
    # Unicode_  # U            # 固定长度的Unicode类型（字节数由平台决定），跟字符串的定义方式一样，比如U20      #
    ##################################################################################################
    # 创建Numpy数组时可以通过dtype属性显示指定数据类型，如果不指定，Numpy会自己推断出合适的数据类型，所以一般无需显示指定
    # astype方法，可以转换数组的元素数据类型，得到一个新数组
    b = np.array([1, 2, 3, 4])
    print("数组b的类型：", b.dtype)
    b = b.astype(float)
    print("更改后数组b的类型：", b.dtype)
    
    # 改变ndarray的形状
    # 直接修改ndarray的shape值
    # 使用reshape函数，可以创建一个改变了尺寸的新数组，原数组的shape保持不变，但注意他们共享内存空间，因此修改任何一个也对另一个产生影响，因此注意新数组的元素个数必须与原数组一样
    # 当指定新数组某个轴元素为-1时，根据数组元素的个数自动计算此轴的长度
    c = np.arange(0, 20, 2)
    print("原数组c:", c)
    print("改变形状后的数组c:", c.reshape(2, 5))
    print("改变形状后的数组c:", c.reshape(-1, 5))
    c = c.reshape(2, -1)
    print("数组c的形状：", c.shape)
    c.shape = 5, -1
    print("改变后数组c的形状：", c.shape)
    print("改变后数组c的值：", c)
    
    # Numpy中数组与标量、数组之间的运算
    # 数组不用循环即可对每个元素执行批量运算，这通常就叫做矢量化，即用数组表达式代替循环的做法
    # 矢量化数组运算性能要比纯Python方式快上一两个数量级
    # 大小相等的数组之间的任何算术运算都会将运算应用到元素级
    array = np.array([1, 2, 3, 4, 5])
    print("数组加法运算：", array + 2)
    print("数组减法运算：", array - 2)
    print("数组乘法运算：", array * 2)
    print("数组除法运算：", 1/array)  # python2中此操作显示的是模的值，要想得到结果需要导入以下的包：from __future__ import division
    print("数组乘方运算：", array ** 2)
    # 大小相等的数组之间的运算
    arr1 = np.array([
        [1, 2.0],
        [2.0, 3.0]
    ])
    arr2 = np.array([
        [2, 3.0],
        [6.0, 8.0]
    ])
    print("相等数组之间的加法运算：", arr1 + arr2)
    print("相等数组之间的减法运算：", arr1 - arr2)
    print("相等数组之间的乘法运算：", arr1 * arr2)
    print("相等数组之间的除法运算：", arr1 / arr2)
    # 元素级运算：像上面例子展现出来的，加、减、乘、除、幂运算等，可以用于数组与标量、大小相等数组之间。在Numpy中，大小相等的数组之间运算，为元素级运算，即只用于位置相同的元
    # 素之间，所得到的运算结果组成一个新的数组，运算结果的位置跟操作数位置相同
    
    # 数组的矩阵积：两个二维矩阵（多维数组即矩阵）满足第一个矩阵的列数与第二个矩阵的行数相同，那么可以进行矩阵乘法，即矩阵积，矩阵积不是元素级的运算
    # 两个矩阵相乘结果所得到的的数组中每个元素为，第一个矩阵中与该元素行号相同的元素与第二个矩阵中与该元素列号相同的元素，两两相乘后求和
    print("数组的矩阵积（点积）：", arr1.dot(arr2))
    print("数组的矩阵积（点积）：", np.dot(arr1, arr2))
    
    # 数组中的索引和切片
    # 多维数组的索引
    print("数组a的值：", '\n', a, '\n', "数组a的形状：", '\n', a.shape)
    print("a[1]:", a[1])
    print("a[1][1]:", a[1][1])
    print("a[1][1][2]:", a[1][1][2])
    
    # Numpy中数组的切片：在各个维度上单独切片，如果某维度都保留，则直接使用：冒号，不指定起始值和终止值
    print("a[1]:", a[1])
    print("a[1][0]:", a[1][0])
    print("a[1][0][1:2]:", a[1][0][1:2])
    print("a[1][1][1:2]:", a[1][1][1:2])
    print("a[1, :, 1:2]:", a[1, :, 1:2])
    
    # 布尔型索引
    array2 = np.random.random((4, 4))
    print("array2 < 0.5：", array2 < 0.5)
    # True的位置上的元素取出组成一个新的数组
    print("array2[array2 < 0.5]：", array2[array2 < 0.5])
    
    names = np.array(['xzw', 'Eric', 'Josie'])
    print("names == 'xzw':", names == 'xzw')
    scores = np.array([
        [89, 98],
        [99, 97],
        [100, 65]
    ])
    print("scores[names == 'xzw']:", scores[names == 'xzw'])
    print("scores[names == 'xzw', 1]:", scores[names == 'xzw', 1])
    # 逻辑非~；逻辑与|；逻辑或&。注意：在Numpy中不能使用Python基础中的and、or和not
    print("scores[~((names == 'xzw') | (names == 'Eric'))]:", scores[~((names == 'xzw') | (names == 'Eric'))])
    print("scores[(names != 'xzw') & (names != 'Eric')]:", scores[(names != 'xzw') & (names != 'Eric')])
    
    # 花式索引：花式索引指的是利用整数数组进行索引
    array3 = np.arange(32).reshape(8, 4)
    print("array3[[0, 3, 5]]:", array3[[0, 3, 5]])
    print("array3[[0, 3, 5], [0, 3, 2]]:", array3[[0, 3, 5], [0, 3, 2]])
    print("array3[np.ix_([0, 3, 5], [0, 3, 2])]:", array3[np.ix_([0, 3, 5], [0, 3, 2])])
    
    # 数组转置与轴对换：transpose函数用于数组转置，对于二维数组来说就是行列互换；数组的T属性，也是转置
    print("array3.transpose():", array3.transpose())
    print("array3.T:", array3.T)
    
    # 通用函数：快速的元素级数组函数
    # ufunc：一种对ndarray中的数据执行元素级运算的函数，也可以看做是简单函数（接受一个或多个标量值，并产生一个或多个标量值）的矢量化包装器
    # 常见的一元通用函数：
    ###################################################################################################################
    #          一元通用函数                      #                  说明                                                 #
    # abs, fabs                                # 计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的发的fabs             #
    # sqrt                                     # 计算各元素的平方根，相当于arr ** 0.5                                      #
    # square                                   # 计算各元素的平方，相当于arr ** 2                                         #
    # exp                                      # 计算各元素的指数e的x次方                                                 #
    # log, log10, log2, log1p                  # 分别对自然对数、底数是10的log，底数是2的log，log(1+x)                       #
    # sign                                     # 计算各元素的正负号：1正数，0零，-1负数                                      #
    # cell                                     # 计算各元素的ceiling值，即大于等于该值的最小整数                              #
    # floor                                    # 计算各元素的floor值，即大于等于该值的最大整数                                #
    # rint                                     # 将各元素值四舍五入到最近的整数，保留dtype                                   #
    # modf                                     # 将数组的小数位和整数部分以两个独立数组的形式返回                              #
    # isnan                                    # 返回一个表示“哪些值是NaN（不是一个数字）”的布尔类型数组                        #
    # isfinite, isinf                          # 分别返回一个表示“哪些元素是有穷的（非inf，非NaN）”或“哪些元素是无穷的”的布尔型数组 #
    # cos, cosh, sin, sinh, tan, tanh          # 普通型和双曲型三角函数                                                    #
    # arccos, arccosh, arcsin, arctan, arctanh # 反三角函数                                                              #
    # logical_not                              # 计算各元素not x的真值，相当于~和-arr                                       #
    ####################################################################################################################
    # 常见的二元通用函数：
    ########################################################################################################################
    # 二元通用函数                                                 #               说明                                       #
    # add                                                        # 将数组中相同位置对应的元素相加                               #
    # substract                                                  # 从第一个数组中减去第二个数组中的元素                          #
    # multiply                                                   # 数组元素相乘                                              #
    # divide, floor_divide                                       # 除法或者向下圆整除法（丢弃余数）                              #
    # pow                                                        # 对第一个数组的元素A，根据第二个数组中的相应元素B，计算A的B次方     #
    # maximum, fmax                                              # 元素级别的最大值，fmax会忽略NaN                              #
    # minimum, fmin                                              # 元素级别的最小值，fmin会忽略NaN                              #
    # mod                                                        # 元素级的求模（除法的余数）                                   #
    # copysign                                                   # 将第二个数组中的值的符号复制给第一个数组中对应位置的值            #
    # greater, greater_equal, less, less_equal, equal, not_equal # 执行元素级别的比较运算，最终产生布尔型数组                      #
    # logical_and, logical_or, logical_xor                       # 执行元素级别的布尔逻辑运算，相当于中缀运算符&，|，^              #
    ########################################################################################################################
    
    # 聚合函数：聚合函数是对一组值（比如一个数组）进行操作，返回一个单一值作为结果的函数。因此求数组所有元素之和、求所有元素的最大最小值以及标准差的函数就是聚合函数
    arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
    print("arr.max():", arr.max())
    print("arr.min():", arr.min())
    print("arr.mean():", arr.mean())
    print("arr.std():", arr.std())
    print("np.sqrt(np.power(arr - arr.mean(), 2).sum()/arr.size):", np.sqrt(np.power(arr - arr.mean(), 2).sum()/arr.size))
    # 聚合函数可以指定对数值的某个轴元素进行操作
    arr = arr.reshape((2, 4))
    print("对同一列上的元素进行聚合：", arr.mean(axis=0))
    print("对同一行上的元素进行聚合：", arr.mean(axis=1))
    
    # np.where函数：三元表达式x if condition else y的矢量化版本
    xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
    yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
    condition = np.array([True, False, True, True, False])
    result = [(x if c else y) for x, y, c in zip(xarr, yarr, condition)]
    print("result:", result)
    result = np.where(condition, xarr, yarr)
    print("result:", result)
    # 案例：将数组中所有NaN缺失值替换为0
    arr = np.array([
        [1, 2, np.nan, 4],
        [3, 4, 5, np.nan]
    ])
    print("arr:", arr)
    print("np.isnan(arr):", np.isnan(arr))
    print("np.where(np.isnan(arr), 0, arr):", np.where(np.isnan(arr), 0, arr))
    
    # np.unique函数：求数组中不重复的元素
    data = np.array(['数学', '图论', '数学', '几何', '代数', '数学'])
    print("np.unique(data):", np.unique(data))
    for elements in np.unique(data):
        print(elements)
    
    # 数组数据文件读写
    # 将数组以二进制格式保存到磁盘
    # np.save('data', data)
    # 读取存储的二进制文件
    print("读取存储的二进制文件:", np.load('data.npy'))
    
    # 存取为文本文件
    d = np.array([
        [1, 2, 3, 4],
        [2, 3, 4, 5],
        [3, 4, 5, 6],
        [4, 5, 6, 7]
    ])
    # np.savetxt('d.csv', d, delimiter=',')
    # 读取存储的文本文件
    print("读取存储的文本文件:", np.loadtxt('d.csv', delimiter=','))
    print("读取存储的文本文件:", np.genfromtxt('d.csv', delimiter=','))

你们在此过程中遇到了什么问题，欢迎留言，让我看看你们都遇到了哪些问题。

[Python]: https://blog.csdn.net/column/details/22367.html
[Python_Python]: https://blog.csdn.net/gdkyxy2013/article/details/80230248
[Python_Python 1]: https://blog.csdn.net/gdkyxy2013/article/details/80230492
[Python_Pandas]: https://blog.csdn.net/gdkyxy2013/article/details/80290755
[Python_Matplotlib]: https://blog.csdn.net/gdkyxy2013/article/details/80294021
[Sklearn_TensorFlow]: https://blog.csdn.net/gdkyxy2013/article/details/81157254
[Python 1]: https://blog.csdn.net/gdkyxy2013/article/details/81979214