Python之numpy模块基础知识及其简单应用案例

谁践踏了优雅 2021-09-07 06:17 443阅读 0赞

# Python之numpy模块基础知识及其简单应用案例 #

### 文章目录 ###

*  Python之numpy模块基础知识及其简单应用案例
 *   *  一、安装numpy
     *  二、numpy简介
     *  三、如何使用该模块
     *   *  1、数组(Arrays)
         *  2、数组的切片
         *  3、数组的索引取值
         *  4、布尔值也可以作为索引
         *  5、数组的数据类型
     *  四、numpy的应用举例
     *   *  1、实现矩阵的乘法
         *  2、实现矩阵的转置
         *  3、求所有的元素的和
         *  4、其他的生成数组的方法
         *  5、meshgrid方法生成网格

## 一、安装numpy ##

pip install numpy  
（我记得不太清这个是Python内置的还是外加的，但是反正安装一下肯定不会出错的。）

## 二、numpy简介 ##

Numpy是Python中科学计算的核心库。它提供了一个高性能的多维数组对象，以及用于处理这些数组的工具。

## 三、如何使用该模块 ##

### 1、数组(Arrays) ###

numpy数组是一个值网格，所有类型都相同，并由非负整数元组索引。  
维数是数组的排名; 数组的形状是一个整数元组，给出了每个维度的数组大小。  
举例1:  
（定义一个一维数组）

import numpy as np
    """ 通常将numpy以别名np的方式使用 """
    # 定义一个一维数组
    array_0 = np.array([0, 1, 2, 3, 4])
    # 查看类型
    print(type(array_0))
    # 查看数组
    print(array_0)
    # 查看数组的“形状”
    print(array_0.shape)
    
    
    
    # output>
    <class 'numpy.ndarray'>
    [0 1 2 3 4]
    (5,)

举例2：  
（定义一个多维数组）

# 此处代码含义与上一个相同
    import numpy as np
    array_1 = np.array([[0, 1, 2, 3, 4],[5, 6, 7, 8, 9]])
    print(type(array_1))
    print(array_1)
    print(array_1.shape)
    
    
    
    # output>
    <class 'numpy.ndarray'>
    [[0 1 2 3 4]
     [5 6 7 8 9]]
    (2, 5)

综合以上两个例子，我们可以看出来，如果是一维数组，那么shape返回的元组第一个值表示有几个相同类型的数据，第二个值为空；  
如果是多维数组，那么，元组的第一个值表示维数，第二个值表示一个维度里面有几个相同类型的数据。  
举例3：  
（其他产生数组的方法）  
（产生的是浮点数）

import numpy as np
    
    a = np.zeros((2,2))
    print(a)     
    b = np.ones((1,2))    
    print(b)             
    c = np.full((2,2), 7)  
    print(c)             
    d = np.eye(2)        
    print(d)             
    e = np.random.random((2,2))
    print(e)    
    
    
    
    # output>
    [[0. 0.]
     [0. 0.]]
     
     
    [[1. 1.]]
    
    
    [[7 7]
     [7 7]]
     
     
    [[1. 0.]
     [0. 1.]]
     
     
    [[0.69818173 0.09918071]
     [0.8520535  0.95435593]]

### 2、数组的切片 ###

一维数组切片

import numpy as np
    array_2 = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    print(array_2[0:2])
    print(array_2[0:6:2])
    # 参数为：开始：结束：步长
    
    
    # output>
    array([0, 1])
    array([0, 2, 4])

二维数组切片

import numpy as np
    array_3 = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
    # 打印array_3
    print(array_3)
    # 行切片
    print(array_3[0:2, :])
    # 列切片
    print(array_3[:, 0:2])
    # 行与列的切片
    print(array_3[0:2, 0:2])
    # 反转行
    print(array_3[::-1, :])
    # 反转列
    print(array_3[:,::-1])
    # 行列都反转
    print(array_3[::-1,::-1])
    
    
    # output>
    # 打印array_3
    array([[ 0,  1,  2,  3,  4],
           [ 5,  6,  7,  8,  9],
           [10, 11, 12, 13, 14]])
    
    # 行切片
    array([[0, 1, 2, 3, 4],
           [5, 6, 7, 8, 9]])
    
    # 列切片
    array([[ 0,  1],
           [ 5,  6],
           [10, 11]])
    
    # 行与列的切片
    array([[0, 1],
           [5, 6]])
    
    # 反转行
    array([[10, 11, 12, 13, 14],
           [ 5,  6,  7,  8,  9],
           [ 0,  1,  2,  3,  4]])
    
    # 反转列
    array([[ 4,  3,  2,  1,  0],
           [ 9,  8,  7,  6,  5],
           [14, 13, 12, 11, 10]])
    
    # 行列都反转
    array([[14, 13, 12, 11, 10],
           [ 9,  8,  7,  6,  5],
           [ 4,  3,  2,  1,  0]])

### 3、数组的索引取值 ###

一维数组索引

import numpy as np
    # 类似于列表的索引
    array_4 = np.array([0, 1, 2, 3, 4, 5, 6, 7])
    print(array_4[0])
    print(array_4[4])
    
    
    # output>
    0
    4

二维数组的索引

import numpy as np
    array_5 = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
    # 首先先取出一行
    # 然后再取出这一行的某一列
    print(array_5[0][2])
    print(array_5[1][3])
    print(array_5[2][3])
    
    
    # output>
    2
    8
    13

更高维的数组的索引

import numpy as np
    array_6 = np.array([[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]], [[18, 19, 20], [21, 22, 23]]])
    print(array_6[0][1][2])
    print(array_6[1][0][0])
    print(array_6[3][1][1])
    # 与二维数组类似
    # 首先取出第一个维度的列表
    # 再取出更低维度的列表
    # 直至去除最小的一个元素为止
    
    
    # output>
    5
    6
    22

### 4、布尔值也可以作为索引 ###

import numpy as np
    array_7 = np.array([[2, 1, 4, 5, 9, 11, 13], [0, 14, 8, 7, 20, 23, 123], [77, 6, 34, 22, 102, 56, 64]])
    bool_0 = array_7 > 15
    print(array_7)
    print(bool_0)
    print(array_7[bool_0])
    # True 则展示数值
    # Faulse 则不展示数值
    
    
    # output>
    [[  2   1   4   5   9  11  13]
     [  0  14   8   7  20  23 123]
     [ 77   6  34  22 102  56  64]]
    
    [[False False False False False False False]
     [False False False False  True  True  True]
     [ True False  True  True  True  True  True]]
    
    
    [ 20  23 123  77  34  22 102  56  64]

### 5、数组的数据类型 ###

每个numpy数组都是相同类型元素的网格。Numpy提供了一组可用于构造数组的大量数值数据类型。Numpy在创建数组时尝试猜测数据类型，但构造数组的函数通常还包含一个可选参数来显式指定数据类型。  
例如：

import numpy as np
    
    x1 = np.array([0, 1, 2, 3])   
    print(x1, x1.dtype)         
    
    x2 = np.array([0.0,1.0, 2.0, 3.0])  
    print(x2, x2.dtype)            
    
    x3 = np.array([0,1, 2, 3], dtype=np.int64)   
    print(x3, x3.dtype)       
    
    
    # output>
    [0 1 2 3] int32
    
    [0. 1. 2. 3.] float64
    
    [0 1 2 3] int64

## 四、numpy的应用举例 ##

### 1、实现矩阵的乘法 ###

矩阵乘法注意事项：  
1、当矩阵A的列数（column）等于矩阵B的行数（row）时，A与B可以相乘。  
2、矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。  
3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。

import numpy as np
    array_x = np.array([[1, 2], [5, 6]])
    array_y = np.array([[4, 8], [7, 9]])
    # x 乘 y
    print(array_x.dot(array_y))
    # x 乘 y
    print(np.dot(array_x, array_y))
    # y 乘 x
    print(array_y.dot(array_x))
    # y 乘 x
    print(np.dot(array_y, array_x))
    
    
    # output>
    
    [[18 26]
     [62 94]] 
     
    [[18 26]
     [62 94]]
     
    [[44 56]
     [52 68]]
     
    [[44 56]
     [52 68]]

由此我们也可以看出来矩阵的乘法具有不可对易性的  
再举一个矩阵乘法的例子：

import numpy as np
    X = np.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
    Y = np.array([[4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]])
    print(np.dot(X, Y))
    print(np.dot(Y, X))
    
    
    # output>
    [[ 66  72  78]
     [202 224 246]
     [338 376 414]]
     
    [[ 68  83  98 113]
     [104 128 152 176]
     [140 173 206 239]
     [176 218 260 302]]

### 2、实现矩阵的转置 ###

矩阵的转置必须是一个方阵才可以进行的

import numpy as np
    # 设置目标矩阵
    X = np.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]])
    # 设置一个空矩阵
    X_t = np.zeros((len(X),len(X)), dtype=X.dtype)
    # 实现矩阵的转置：
    for i in range(4):
        for j in range(4):
            X_t[i][j] = X[j][i]
    print(X)
    print(X_t)
    
    
    # output>
    [[ 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]]

或者：

import numpy as np
    # 设置目标矩阵
    x = np.array([[1, 2,5,6], [3, 4, 8, 9], [10, 11, 12, 13], [14, 22, 34, 57]])
    print(x)   
    # 实现矩阵的转置：
    print(x.T)  
    
    
    v = np.array([1, 2, 3, 4, 5])
    print(v)  
    # 实现矩阵的转置： 
    print(v.T)  
    
    
    # output>
    
    import numpy as np
    # 设置目标矩阵
    x = np.array([[1, 2,5,6], [3, 4, 8, 9], [10, 11, 12, 13], [14, 22, 34, 57]])
    print(x)   
    # 实现矩阵的转置：
    print(x.T)  
    
    
    v = np.array([1, 2, 3, 4, 5])
    print(v)  
    # 实现矩阵的转置： 
    print(v.T)  
    [[ 1  2  5  6]
     [ 3  4  8  9]
     [10 11 12 13]
     [14 22 34 57]]
     
    [[ 1  3 10 14]
     [ 2  4 11 22]
     [ 5  8 12 34]
     [ 6  9 13 57]]
     
    [1 2 3 4 5]
    
    [1 2 3 4 5]

### 3、求所有的元素的和 ###

import numpy as np
    
    x = np.array([[1, 2, 7, 8],[3, 4, 9, 10], [6, 22, 45, 57]])
    print(x.sum())
    print(np.sum(x))  
    # 对每一列都求和，返回一个列表
    print(np.sum(x, axis=0)) 
    # 对每一行都求和，返回一个列表
    print(np.sum(x, axis=1)) 
    
    
    # output>
    174
    174
    [10 28 61 75]
    [ 18  26 130]

### 4、其他的生成数组的方法 ###

方法1：arange方法

import numpy as np
    # 从 -10 到 10
    # 每隔 0.5 生成一个数
    # 为一个等差数列
    arr_0 = np.arange(-10, 10, 0.5)
    print(arr_0)
    
    
    # output。
    [-10.   -9.5  -9.   -8.5  -8.   -7.5  -7.   -6.5  -6.   -5.5  -5.   -4.5
      -4.   -3.5  -3.   -2.5  -2.   -1.5  -1.   -0.5   0.    0.5   1.    1.5
       2.    2.5   3.    3.5   4.    4.5   5.    5.5   6.    6.5   7.    7.5
       8.    8.5   9.    9.5]

方法2：linspace方法

import numpy as np
    # 从 -10 到 10
    # 一共生成 40 个数
    # 为一个等差数列
    arr_1 = np.linspace(-10, 10, 40)
    print(arr_1)
    
    
    # output>
    
    [-10.          -9.48717949  -8.97435897  -8.46153846  -7.94871795
      -7.43589744  -6.92307692  -6.41025641  -5.8974359   -5.38461538
      -4.87179487  -4.35897436  -3.84615385  -3.33333333  -2.82051282
      -2.30769231  -1.79487179  -1.28205128  -0.76923077  -0.25641026
       0.25641026   0.76923077   1.28205128   1.79487179   2.30769231
       2.82051282   3.33333333   3.84615385   4.35897436   4.87179487
       5.38461538   5.8974359    6.41025641   6.92307692   7.43589744
       7.94871795   8.46153846   8.97435897   9.48717949  10.        ]

### 5、meshgrid方法生成网格 ###

meshgrid方法可以用来生成一个二维的网格：

import numpy as np
    # 生成一个一维数组
    x = np.arange(0, 3, 0.5)
    # 生成一个一维数组
    y = np.arange(0, 3, 0.5)
    # 调用 meshgrid 方法
    X, Y = np.meshgrid(x, y)
    print(X)
    print(Y)
    
    
    # output>
    
    [[0.  0.5 1.  1.5 2.  2.5]
     [0.  0.5 1.  1.5 2.  2.5]
     [0.  0.5 1.  1.5 2.  2.5]
     [0.  0.5 1.  1.5 2.  2.5]
     [0.  0.5 1.  1.5 2.  2.5]
     [0.  0.5 1.  1.5 2.  2.5]]
     
    [[0.  0.  0.  0.  0.  0. ]
     [0.5 0.5 0.5 0.5 0.5 0.5]
     [1.  1.  1.  1.  1.  1. ]
     [1.5 1.5 1.5 1.5 1.5 1.5]
     [2.  2.  2.  2.  2.  2. ]
     [2.5 2.5 2.5 2.5 2.5 2.5]]

总之，以上内容就是对numpy模块的一个简单介绍以及简单的应用举例，希望对大家有所帮助啦~~