zoukankan      html  css  js  c++  java
  • 1,Python常用库之一:Numpy

    Numpy支持大量的维度数组和矩阵运算,对数组运算提供了大量的数学函数库!

    Numpy比Python列表更具优势,其中一个优势便是速度。在对大型数组执行操作时,Numpy的速度比Python列表的速度快了好几百。因为Numpy数组本身能节省内存,并且Numpy在执行算术、统计和线性代数运算时采用了优化算法。

    Numpy的另一个强大功能是具有可以表示向量和矩阵的多维数组数据结构。Numpy对矩阵运算进行了优化,使我们能够高效地执行线性代数运算,使其非常适合解决机器学习问题。

    与Python列表相比,Numpy具有的另一个强大优势是具有大量优化的内置数学函数。这些函数使你能够非常快速地进行各种复杂的数学计算,并且用到很少代码(无需使用复杂的循环),使程序更容易读懂和理解。

    Numpy简单创建数组

    1 a = [1, 2, 3]
    2 b = np.array(a)
    3 c = np.array([[0, 1, 2, 10],
    4               [12, 13, 100, 101],
    5               [102, 110, 112, 113]], int)
    6 print(c)
    7 print(b)

    创建数值为1的数组

    Numpy.ones(参数 1:shape,数组的形状;参数 2:dtype, 数值类型)

    1 array_one = np.ones([10, 10], dtype=np.int)
    2 print(array_one)

    创建数值为0的数组

    Numpy.zeros(参数 1:shape,数组的形状;参数 2:dtype, 数值类型)

    1 array_zero = np.zeros([10, 9], dtype=np.float)
    2 print(array_zero)

    创建指定数值的数组

    Numpy.full(参数 1:shape,数组的形状; 参数 2:constant value,数组填充的常数值;参数 3:dtype, 数值类型)

    1 array_full = np.full((2, 3), 5)
    2 print(array_full)

    创建单位矩阵

    Numpy.eye(参数 1:N,方阵的维度)

    1 array_eye = np.eye(5)
    2 print(array_eye)

    创建对角矩阵

    Numpy.diag(参数1:v,主对角线数值,参数 2:k,对角线元素):K = 0表示主对角线,k>0的值选择在主对角线之上的对角线中的元素,k<0的值选择在主对角线之下的对角线中的元素

    1 array_diag = np.diag([10, 20, 30, 40])
    2 print(array_diag)

    Numpy查看数组属性

    数组元素个数:b.size

    数组形状:b.shape

    数组维度:b.ndim

    数组元素类型:b.dtype

    # 数组元素个数:3
    print(b.size)
    # 数组形状:(3,)
    print(b.shape)
    # 数组维度:1
    print(b.ndim)
    # 数组元素类型:int32
    print(b.dtype)

    矩阵第一维的长度:shape[0]  # 行

    矩阵第二维的长度:shape[1]  # 列

    .......

    1 array_rand = np.random.rand(10, 10, 4)
    2 print(array_rand)
    3 print(array_rand.ndim)
    4 print(array_rand.shape[0])
    5 print(array_rand.shape[1])
    6 print(array_rand.shape[2])

    Numpy创建随机数组(np.random)

    均匀分布

    创建指定形状的数组,数值范围在0~1之间

    1 array_rand = np.random.rand(10, 10, 4)
    2 print(array_rand)
    3 print(array_rand.ndim)

    创建指定范围内的一个数:Numpy.random.uniform(low, high, size=None)

    1 array_uniform = np.random.uniform(0, 100, size=5)
    2 print(array_uniform)

    创建指定范围的一个整数:Numpy.random.randint(low, high, size=None)

    1 array_int = np.random.randint(0, 100, size=3)
    2 print(array_int)
    3 print(array_int.size)

    Numpy.arange()和Numpy.linspace()函数也可以均匀分布

    Numpy.arange(start, stop, step):创建一个秩为1的array,其中包含位于半开区间[start, stop)内并均匀分布的值,step表示两个相邻值之间的差。

    Numpy.linspace(start, stop, N):创建N个在闭区间[start, stop]内均匀分布的值。

    1 X = np.arange(1, 5, 2, dtype=np.int)
    2 print(X)
    3 y = np.linspace(1, 5, 3)
    4 print(y)

    正态分布

    创建给定均值、标准差、维度的正态分布:Numpy.random.normal(loc, scale, size)

    1 # 正态生成4行5列的二位数组
    2 array_normal = np.random.normal(loc=1.75, scale=0.1, size=[4, 5])
    3 print(array_normal)
    4 print(array_normal.ndim)

    Numpy数组操作

    数组的索引

    array[start : end]

    array[start:]

    array[:end]

    布尔型索引:array[array>10 & array<20]

    np.random.seed(10)
    arr = np.random.randint(0,100,size=(5,6))
    arr
    array([[ 9, 15, 64, 28, 89, 93],
           [29,  8, 73,  0, 40, 36],
           [16, 11, 54, 88, 62, 33],
           [72, 78, 49, 51, 54, 77],
           [69, 13, 25, 13, 92, 86]])
    arr[[1,2]]
    array([[29,  8, 73,  0, 40, 36],
           [16, 11, 54, 88, 62, 33]])

    数组的切片

    arr[0:2]
    array([[ 9, 15, 64, 28, 89, 93],
           [29,  8, 73,  0, 40, 36]])
    #获取二维数组前两列
    arr[:,0:2]
    array([[ 9, 15],
           [29,  8],
           [16, 11],
           [72, 78],
           [69, 13]])
    #获取二维数组前两行和前两列数据
    arr[0:2,0:2]
    array([[ 9, 15],
           [29,  8]])
    #将数组的行倒序
    arr[::-1]
    array([[69, 13, 25, 13, 92, 86],
           [72, 78, 49, 51, 54, 77],
           [16, 11, 54, 88, 62, 33],
           [29,  8, 73,  0, 40, 36],
           [ 9, 15, 64, 28, 89, 93]])
    #列倒序
    arr[:,::-1]
    array([[93, 89, 28, 64, 15,  9],
           [36, 40,  0, 73,  8, 29],
           [33, 62, 88, 54, 11, 16],
           [77, 54, 51, 49, 78, 72],
           [86, 92, 13, 25, 13, 69]])
    #全部倒序
    arr[::-1,::-1]
    array([[86, 92, 13, 25, 13, 69],
           [77, 54, 51, 49, 78, 72],
           [33, 62, 88, 54, 11, 16],
           [36, 40,  0, 73,  8, 29],
           [93, 89, 28, 64, 15,  9]])

    数组的复制

    Numpy.copy(参数 1:数组):创建给定array的一个副本,还可当做方法用。

    1 after_array = array_normal[:3, 2:4].copy()
    2 copy_array = np.copy(array_normal[:, 2:4])

    数组排序

    Numpy.sort(参数 1:a,数组;参数 2:axis=0/1,0表示行1表示列):np.sort()作为函数使用时,不更改被排序的原始array;array.sort()作为方法使用时,会对原始array修改为排序后数组array

    1 # 整体排序
    2 np.sort(array_normal)
    3 # 仅行排序
    4 np.sort(array_normal, axis=0)
    5 # 仅列排序
    6 np.sort(array_normal, axis=1)

    数组唯一元素

    Numpy.unique(参数 1:a,数组;参数 2:return_index=True/False,新列表元素在旧列表中的位置;参数 3:return_inverse=True/False,旧列表元素在新列表中的位置;参数 4:return_counts,元素的数量;参数 5:axis=0/1,0表示行1表示列):查找array中的唯一元素。

    1 print("提取唯一元素", np.unique(array_normal))
    2 print("提取唯一元素", np.unique(array_normal, return_index=True))
    3 print("提取唯一元素", np.unique(array_normal, return_counts=True))
    4 print("提取唯一元素", np.unique(array_normal, return_index=True, return_inverse=True, axis=0))

    数组的改变

    数组转置

    1 array_normal.T

    reshape():把指定的数组改变形状,但是元素个数不变;有返回值,即不对原始多维数组进行修改

     1 c = np.array([[[0, 1, 2],
     2                [10, 12, 13]],
     3               [[100, 101, 102],
     4                [110, 112, 113]]])
     5 """
     6 [[[  0   1]
     7   [  2  10]] 
     9  [[ 12  13]
    10   [100 101]]
    12  [[102 110]
    13   [112 113]]]
    14 """
    15 print(c.reshape(3, 2, 2))
    16 """
    17 [[  0   1   2  10]
    18  [ 12  13 100 101]
    19  [102 110 112 113]]
    20 """
    21 # 某一维指定为-1时,自动计算维度
    22 print(c.reshape(3, -1))
    23 """[[[  0   1]
    24     [  2  10]
    25     [ 12  13]]
    26     
    27     [[100 101]
    28     [102 110]
    29     [112 113]]]"""
    30 print(c.reshape(2, -1, 2))

    resize():把指定的数组改变形状,但是元素个数可变,不足补0;无返回值,即对原始多维数组进行修改

     1 a = np.array([[[0, 1, 2],
     2                [10, 12, 13]],
     3               [[100, 101, 102],
     4                [110, 112, 113]]])
     5 b = np.array([[[0, 1, 2],
     6                [10, 12, 13]],
     7               [[100, 101, 102],
     8                [110, 112, 113]]])
     9 '''[[0]
    10     [1]
    11     [2]]'''
    12 a.resize((3, 1))
    13 '''[[  0   1   2  10  12]
    14     [ 13 100 101 102 110]
    15     [112 113   0   0   0]]'''
    16 b.resize((3, 5))
    17 print(a)
    18 print(b)

    数组的级联

    np.concatenate((arr,arr),axis=1)
    array([[ 9, 15, 64, 28, 89, 93,  9, 15, 64, 28, 89, 93],
           [29,  8, 73,  0, 40, 36, 29,  8, 73,  0, 40, 36],
           [16, 11, 54, 88, 62, 33, 16, 11, 54, 88, 62, 33],
           [72, 78, 49, 51, 54, 77, 72, 78, 49, 51, 54, 77],
           [69, 13, 25, 13, 92, 86, 69, 13, 25, 13, 92, 86]])

    级联需要注意的点:

    • 级联的参数是列表:一定要加中括号或小括号
    • 维度必须相同
    • 形状相符:在维度保持一致的前提下,如果进行横向(axis=1)级联,必须保证进行级联的数组行数保持一致。如果进行纵向(axis=0)级联,必须保证进行级联的数组列数保持一致。
    • 可通过axis参数改变级联的方向

    *Numpy计算

    条件运算

    Numpy.where(condition, x, y):三目运算满足condition,为x;不满足condition,则为y

    1 score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
    2 # 如果数值小于80,替换为0,如果大于等于80,替换为90
    3 re_score = np.where(score < 80, 0, 90)
    4 print(re_score)

    统计运算

    指定轴最大值:amax(参数1:数组;参数2:axis=0/1,0表示行1表示列)

    1 # 求整个矩阵的最大值
    2 result = np.amax(score)
    3 print(result)
    4 # 求每一列的最大值(0表示行)
    5 result = np.amax(score, axis=0)
    6 print(result)
    7 # 求每一行的最大值(1表示列)
    8 result = np.amax(score, axis=1)
    9 print(result)

    指定轴最小值:amin(参数1:数组;参数2:axis=0/1,0表示行1表示列)

    1 # 求整个矩阵的最小值
    2 result = np.amin(score)
    3 print(result)
    4 # 求每一列的最小值(0表示行)
    5 result = np.amin(score, axis=0)
    6 print(result)
    7 # 求每一行的最小值(1表示列)
    8 result = np.amin(score, axis=1)
    9 print(result)

    指定轴平均值:mean(参数1:数组;参数2:axis=0/1,0表示行1表示列;参数3:dtype,输出数据类型)

    1 # 求整个矩阵的平均值
    2 result = np.mean(score, dtype=np.int)
    3 print(result)
    4 # 求每一列的平均值(0表示行)
    5 result = np.mean(score, axis=0)
    6 print(result)
    7 # 求每一行的平均值(1表示列)
    8 result = np.mean(score, axis=1)
    9 print(result)

    指定轴方差:std(参数1:数组;参数2:axis=0/1,0表示行1表示列;参数3:dtype,输出数据类型)

    1 # 求整个矩阵的方差
    2 result = np.std(score)
    3 print(result)
    4 # 求每一列的方差(0表示列)
    5 result = np.std(score, axis=0)
    6 print(result)
    7 # 求每一行的方差(1表示行)
    8 result = np.std(score, axis=1)
    9 print(result)

    类似的,求和:Numpy.sum(),求中值:Numpy.median

    数组运算

    数组与数的运算(加、减、乘、除、取整、取模)

     1 # 循环数组行和列,每一个数值都加5
     2 score[:, :] = score[:, :]+5
     3 print(score)
     4 # 循环数组行和列,每一个数值都减5
     5 score[:, :] = score[:, :]-5
     6 print(score)
     7 # 循环数组行和列,每一个数值都乘以5
     8 score[:, :] = score[:, :]*5
     9 print(score)
    10 # 循环数组行和列,每一个数值都除以5
    11 score[:, :] = score[:, :]/5
    12 print(score)
    13 # 循环数组行和列,每一个数值除以5取整
    14 score[:, :] = score[:, :] // 5
    15 print(score)
    16 # 循环数组行和列,每一个数值除以5取模
    17 score[:, :] = score[:, :] % 5
    18 print(score)

    数组间运算(加、减、乘、除),前提是两个数组的shape一样

    加:“+”或者np.add(a, b)  减:“-”或者np.subtract(a, b)  

    乘:“*”或者np.multiply(a, b)  除:“/”或者np.divide(a, b)

    1 c = score + score
    2 d = score - score
    3 e = score * score
    4 # 分母数组保证每个数值不能为0
    5 b = score / score

    Numpy.intersect1d(参数 1:数组a;参数 2:数组b):查找两个数组中的相同元素

    Numpy.setdiff1d(参数 1:数组a;参数 2:数组b):查找在数组a中不在数组b中的元素

    Numpy.union1d(参数 1:数组a;参数 2:数组b):查找两个数组的并集元素

    矩阵运算(一种特殊的二维数组)

    计算规则

    (M行,N列)*(N行,Z列)=(M行,Z列)

    1 st_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
    2 # 平时成绩占40% 期末成绩占60%, 计算结果
    3 q = np.array([[0.4], [0.6]])
    4 result = np.dot(st_score, q)
    5 print(result)

    矩阵拼接

    矩阵垂直拼接(前提两个两个矩阵列数相同,行数随意):vstack(参数:tuple)

    1 v1 = [[0, 1, 2, 3, 4, 5],
    2       [6, 7, 8, 9, 10, 11]]
    3 v2 = [[12, 13, 14, 15, 16, 17],
    4       [18, 19, 20, 21, 22, 23],
    5       [18, 19, 20, 21, 22, 23]]
    6 result = np.vstack((v1, v2))
    7 print(result)

    矩阵水平拼接(前提两个两个矩阵行数相同,列数随意):hstack(参数:tuple)

    1 v1 = [[0, 1, 2, 3, 4, 5],
    2       [6, 7, 8, 9, 10, 11]]
    3 v2 = [[12, 13, 14, 15, 16, 17],
    4       [18, 19, 20, 21, 22, 23]]
    5 result = np.hstack((v1, v2))
    6 print(result)

     矩阵删除:Numpy.delete(参数 1:a,数组;参数 2:elements,删除的对象;参数 3:axis=0/1)

    1 OriginalY = np.array([[1, 2, 3],
    2                      [4, 5, 6],
    3                      [7, 8, 9]])
    4 print(np.delete(OriginalY, [0, 2]))
    5 print(np.delete(OriginalY, [0, 2], axis=0))
    6 print(np.delete(OriginalY, [0, 2], axis=1))

    矩阵添加:Numpy.append(参数 1:array,数组;参数 2: elements,添加元素;参数 3: axis=0/1)

    1 OriginalY = np.array([[1, 2, 3],
    2                      [4, 5, 6],
    3                      [7, 8, 9]])
    4 # 末尾添加元素
    5 print(np.append(OriginalY, [0, 2]))
    6 # 最后一行添加一行
    7 print(np.append(OriginalY, [[0, 2, 11]], axis=0))
    8 # 最后一列添加一列(注意添加元素格式)
    9 print(np.append(OriginalY, [[0], [2], [11]], axis=1))

    矩阵插入:Numpy.insert(参数 1:array,数组;参数 2:index,插入位置索引;参数 3: elements,添加元素;参数 4: axis=0/1)

    1 OriginalY = np.array([[1, 2, 3],
    2                      [4, 5, 6],
    3                      [7, 8, 9]])
    4 print(np.insert(OriginalY, 1, [11, 12, 10]))
    5 print(np.insert(OriginalY, 1, [[11, 12, 10]], axis=0))
    6 # 在列索引1的位置插入(注意元素格式,跟添加格式不同)
    7 print(np.insert(OriginalY, 1, [[11, 12, 10]], axis=1))

     文件加载

    np.loadtxt(fname,dtype,comments='#',delimiter=None,skiprows=0,usecols=None)

    fname:读取的文件、文件名

    dtype:数据类型

    comments:注释

    delimiter:分隔符,默认是空格

    skiprows:跳过前几行读取,默认是0

    usecols:读取哪些列,usecols=(1, 2, 5)读取第1,2,5列,默认所有列

     
     
     
  • 相关阅读:
    十、Compose命令
    九、compose入门
    JS数组中,两两比较的算法,为了获取重复的值,并在php数组中,使用这种倒三角算法
    题目重复度检测---四种相似度检测的方案+PHP改进计算字符串相似度的函数similar_text()、levenshtein()
    js让文字一个个出现
    客户总想让页面炫酷起来-----怎么炫酷呢?---使用css3的东西或者其animate.css
    关于git的总结:git知识大全,命令行操作,vscode操作
    defer和async的区别
    dom和bom的区别,以及三类偏移属性(JS运动方法中,经常会涉及到这些位置信息)
    认真的对待flex,Flex模型和Flex属性思维导图,以及自己的记忆方法--jaf和aof
  • 原文地址:https://www.cnblogs.com/feifeifeisir/p/10495923.html
Copyright © 2011-2022 走看看