Python学习笔记之numpy库的使用——超详细

文章目录

    • NumPy介绍
    • 一.如何创建
        • 1.导入Numpy库,并命名为np:
        • 2.查看版本
        • 3.通过列表创建一维数组:
        • 4.通过列表创建二维数组:
        • 5.创建全为0的二维数组
        • 6.创建全为1的三维数组
        • 7.创建一维等差数组
        • 8. 创建二维等差数组:
        • 9. 创建单位矩阵(二维数组):
        • 10. 创建二维随机数组:
        • 11.创建二维随机整数数组(数值小于 5):
    • 二.数组运算
        • 12.一维数组加法运算:
        • 13.一维数组减法运算:
        • 14. 一维数组乘法运算:
        • 15.一维数组除法运算:
        • 16.二维数组的运算,相应位置上进行+-*/
        • 17 矩阵乘法运算(注意与上题的区别):
        • 18.如果使用 np.mat 将二维数组准确定义为矩阵,就可以直接使用 * 完成矩阵乘法计算:
        • 19.转置矩阵:
        • 20. 矩阵求逆:
      • 广播
    • 三.索引的使用
    • 四.元素数据类型
    • python基础知识:
        • python数据结构之列表(list)——超详细
        • python数据结构之元组(tuple)——超详细
        • python数据结构之字典(dict)——超详细
        • python数据结构之集合(set)——超详细
    • NumPy进阶教程——超详细

NumPy介绍

NumPy 是 Python 语言的一个第三方库,其支持大量高维度数组与矩阵运算。此外,NumPy 也针对数组运算提供大量的数学函数。机器学习涉及到大量对数组的变换和运算,NumPy 就成了必不可少的工具之一。

一.如何创建

1.导入Numpy库,并命名为np:

import numpy as np

2.查看版本

np.__version__

   '1.15.1'

创建数组

NumPy 的主要对象是多维数组 Ndarray。在 NumPy 中维度 Dimensions 叫做轴 Axes,轴的个数叫做秩 Rank。注意,numpy.array 和 Python 标准库 array.array 并不相同,前者更为强大,这也就是我们学习 NumPy 的重要原因之一。

3.通过列表创建一维数组:

np.array([1, 2, 3])

   array([1, 2, 3])

上方数组是一个秩为 1 的数组,因为它只有一个轴,而轴的长度为 3。

4.通过列表创建二维数组:

np.array([(1, 2, 3), (4, 5, 6)])

   array([[1, 2, 3], [4, 5, 6]])

5.创建全为0的二维数组

np.zeros((3, 4))

array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])

6.创建全为1的三维数组

np.ones((2, 3, 4))

array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])

full函数,创建任意大小的数组并填充任意数字

np.full((3, 4), 2)

array([[2, 2, 2, 2],
   [2, 2, 2, 2],
   [2, 2, 2, 2]])

7.创建一维等差数组

np.arange(5)

   array([0, 1, 2, 3, 4])

8. 创建二维等差数组:

np.arange(6).reshape(2, 3)

array([[0, 1, 2],
   [3, 4, 5]])

9. 创建单位矩阵(二维数组):

np.eye(3)

array([[1., 0., 0.],
   [0., 1., 0.],
   [0., 0., 1.]])

10. 创建二维随机数组:

np.random.rand(2, 3)

array([[0.38257919, 0.63590106, 0.64884528],
   [0.09064574, 0.32850939, 0.94661844]])

11.创建二维随机整数数组(数值小于 5):

np.random.randint(5, size = (2, 3))

array([[2, 3, 4],
   [3, 2, 4]])

二.数组运算

a = np.array([10, 20, 30, 40, 50])
b = np.arange(1, 6)
a, b

   (array([10, 20, 30, 40, 50]), array([1, 2, 3, 4, 5]))

sum

a = np.array([[1, 2],
              [3, 4]])
np.sum(a)

   10

np.sum(a, axis=0) # axis=0 表示对每一列求和

   array([4, 6])

np.sum(a, axis=1) # axis=0 表示对每一行求和

   array([3, 7])

mean

np.mean(a) # 求取平均值
2.5

 
   
   
   
   
  • tile

    a
    
       
          
          
          
          
    • array([[1, 2],
         [3, 4]])

      np.tile(a, (1, 2)) # 将数组a变成一行俩列
      
           
               
               
               
               
      • array([[1, 2, 1, 2],
           [3, 4, 3, 4]])

        np.tile(a, (2, 1))
        
               
                    
                    
                    
                    
        • array([[1, 2],
             [3, 4],
             [1, 2],
             [3, 4]])

          argsort

          a = np.array([[3, 6, 4, 11],
                        [5, 10, 1, 3]])
          a.argsort() # 将元素按照行从小到大排序,返回对应位置元素的下标
          
                   
                         
                         
                         
                         
          • array([[0, 2, 1, 3],
               [2, 3, 0, 1]], dtype=int64)

            # 按照列排序
            a.argsort(axis=0)
            
                       
                              
                              
                              
                              
            • array([[0, 0, 1, 1],
                 [1, 1, 0, 0]], dtype=int64)

              12.一维数组加法运算:

              a + b
              
                           
                                   
                                   
                                   
                                   
              •    array([11, 22, 33, 44, 55])

                13.一维数组减法运算:

                a - b
                
                               
                                        
                                        
                                        
                                        
                •    array([ 9, 18, 27, 36, 45])

                  14. 一维数组乘法运算:

                  a * b
                  
                                   
                                             
                                             
                                             
                                             
                  •    array([ 10, 40, 90, 160, 250])

                    15.一维数组除法运算:

                    a / b
                    
                                       
                                                  
                                                  
                                                  
                                                  
                    •    array([10., 10., 10., 10., 10.])

                      16.二维数组的运算,相应位置上进行±*/

                      A = np.array([[1, 2],
                                    [3, 4]])
                      B = np.array([[5, 6],
                                    [7, 8]])
                      A * B
                      
                                           
                                                    
                                                    
                                                    
                                                    
                      • array([[ 5, 12],
                           [21, 32]])

                        17 矩阵乘法运算(注意与上题的区别):

                        np.dot(A, B)
                        
                                               
                                                      
                                                      
                                                      
                                                      
                        • array([[19, 22],
                             [43, 50]])

                          18.如果使用 np.mat 将二维数组准确定义为矩阵,就可以直接使用 * 完成矩阵乘法计算:

                          np.mat(A) * np.mat(B)
                          
                                                   
                                                        
                                                        
                                                        
                                                        
                          • matrix([[19, 22],
                               [43, 50]])

                            19.转置矩阵:

                            A.T
                            
                                                       
                                                          
                                                          
                                                          
                                                          
                            • array([[1, 3],
                                 [2, 4]])

                              20. 矩阵求逆:

                              np.linalg.inv(A)
                              
                                                           
                                                            
                                                            
                                                            
                                                            
                              • array([[-2. , 1. ],
                                   [ 1.5, -0.5]])

                                广播

                                a = np.array([[1, 2, 3],
                                             [4, 5, 6],
                                             [7, 8, 9]])
                                b = np.array([1, 2, 3])
                                
                                                               
                                                              
                                                              
                                                              
                                                              
                                • # 在a的每一行都加上b
                                  a + np.tile(b, (3, 1))
                                  
                                  
                                                                    
                                                                
                                                                
                                                                
                                                                
                                  • array([[ 2, 4, 6],
                                       [ 5, 7, 9],
                                       [ 8, 10, 12]])

                                     # 可直接简写为a+ b, numpy自动实现广播功能,当参与运算的操作数的维度不一样时
                                    a + b
                                    
                                    
                                                                        
                                                                  
                                                                  
                                                                  
                                                                  

                                    array([[ 2, 4, 6],
                                       [ 5, 7, 9],
                                       [ 8, 10, 12]])

                                    三.索引的使用

                                    a = np.array([[1, 2, 3, 4],
                                                 [5, 6, 7, 8],
                                                 [9, 10, 11, 12]])
                                    
                                    

                                    3.1 取出某个确定的值

                                    # 表示第二行,第三列的数, 逗号前表示一维,逗号后表示二维,以此类推
                                    a[1, 2]
                                    
                                    

                                       7

                                    3.2 取出某个范围的值

                                    # 冒号表示所取的范围,跟列表的索引用法一样,
                                    # 逗号用来区分每个维度,下面的代码表示[取倒数第二行到最后一行, 第二列到第三列
                                    a[-2:, 1:3]
                                    
                                    
                                                                           
                                                                  
                                                                  
                                                                  
                                                                  

                                    array([[ 6, 7],
                                       [10, 11]])

                                    3.3 给某个范围的数进行运算

                                    # 给a数组的第二列上的每个数加上10
                                    a[np.arange(3), 1] += 10
                                    a
                                    
                                    
                                                                            
                                                                  
                                                                  
                                                                  
                                                                  

                                    array([[ 1, 12, 3, 4],
                                       [ 5, 16, 7, 8],
                                       [ 9, 20, 11, 12]])

                                    np.arange(10) # 从0开始生成10个数
                                    
                                    

                                       array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

                                    np.arange(3, 7) # 还可以生成特定范围的数
                                    
                                    

                                       array([3, 4, 5, 6])

                                    # 还可以这样写, 相当于,一个行对应一个列
                                    a[[0, 1, 2], [1, 1, 1]] += 10
                                    a
                                    
                                    
                                                                               
                                                                  
                                                                  
                                                                  
                                                                  

                                    array([[ 1, 22, 3, 4],
                                       [ 5, 26, 7, 8],
                                       [ 9, 30, 11, 12]])

                                    3.4 获取数组中大于或小于某个确定值的数值

                                    result_index = a > 10
                                    result_index
                                    
                                    
                                                                                
                                                                  
                                                                  
                                                                  
                                                                  

                                    array([[False, False, False, False],
                                       [False, False, False, False],
                                       [False, False, True, True]])

                                    a[result_index]
                                    
                                    

                                       array([11, 12])

                                    # 这样写即可
                                    a[a > 10]
                                    
                                    

                                       array([11, 12])

                                    四.元素数据类型

                                    4.1 使用dtype函数查看数组的数据类型

                                    a = np.array([1, 2,  3])
                                    
                                    
                                    a.dtype
                                    
                                    

                                       dtype('int32')

                                    a = np.array([1.1, 2.2])
                                    a.dtype
                                    
                                    

                                       dtype('float64')

                                    a = np.array([1, 1.2])
                                    a.dtype
                                    
                                    

                                       dtype('float64')

                                    a = np.array([1.1, 2.2], dtype = np.int64) # 将数据类型转换为整数,直接去掉小数部分
                                    a
                                    
                                    

                                       array([1, 2], dtype=int64)

                                    a.dtype
                                    
                                    

                                       dtype('int64')

                                    4.2使用astype转换数据类型

                                    a = np.array(['1.2', '1.3', '1.4'], dtype = np.string_)
                                    a
                                    
                                    

                                       array([b'1.2', b'1.3', b'1.4'], dtype='|S3')

                                    a.astype(np.float)
                                    
                                    

                                       array([1.2, 1.3, 1.4])

                                    python基础知识:

                                    python数据结构之列表(list)——超详细

                                    python数据结构之元组(tuple)——超详细

                                    python数据结构之字典(dict)——超详细

                                    python数据结构之集合(set)——超详细

                                    NumPy进阶教程——超详细

你可能感兴趣的:(Python,python学习之路,numpy,python,学习)