python Numpy-数组

目录

Numpy：

一、Ndarray

 1 定义

2 数组的属性方法

    2.1 数组的维度：np.ndarray.shape

    2.2 元素的类型：np.ndarray.dtype

    2.3 数组元素的个数：np.ndarray.size 

    2.4 转置

    3 ndarray 所存储元素的数据类型     

    4 数组创建

    4.1 arrange函数

4.2 np.zeros函数 

4.3 np.ones函数

5 数组操作

5.1 numpy.reshape 

5.2 numpy.ndarray.flat 

5.3 numpy.ndarray.flatten    

5.4 numpy.ravel 

5.5 掩码操作

5.6 多维数组的切片

5.7 二维数组的组合、拆分     

5.7.1 垂直/水平方向组合拆分

5.7.2 对数组填充

5.7.3 对多维数组组合

    6 列表和数组互相转化

Numpy：

(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，
此外也针对数组运算提供大量的数学函数库,整合 C/C++/Fortran 代码的工具.
是一个运行速度非常快的数学库，主要用于数组计算,比python自带的列表运行要快. 
应用：
NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用，
这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。
SciPy 是一个开源的 Python 算法库和数学工具包。
SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）

一、Ndarray

 1 定义

    Narray：是一系列形同类型的数组的集合，以下标0开始索引，遍历集合中元素
    即同类型元素的多维数组
    语法：
    numpy.array(object, dtype=None, copy=True, order=None, subok=Flase, ndmin=0) 
    object：数组 
    dtype：数组元素的数据类型，可选 
    copy：对象是否需要复制，可选 
    order：创建数组的方式，c为行方向，F为列方向，A为任意方向(默认) 
    subok：默认返回一个与几类类型一致的数组
    ndmin：指定生成数组的最小维度 

2 数组的属性方法

    shape - 维度
    dtype - 元素类型
    size - 元素数量
    ndim - 维数，len(shape)
    itemsize - 元素字节数
    nbytes - 总字节数 = size x itemsize 
    real - 复数数组的实部数组
    imag - 复数数组的虚部数组
    T - 数组对象的转置视图
    flat - 扁平迭代器

    2.1 数组的维度：np.ndarray.shape

    a = np.array( 
    [
        # 第一页(第一个通道)
        [[1,2,3],   #第一页 第一行
         [4,5,6],   #第一页 第二行 
         [4,5,7]], 
        # 第二页(第二个通道) 
        [[5,6,7],  #第二页 第一行
         [7,8,9],  #第二页 第二行 
         [4,5,8]]     
    ])
    print(a.shape)  # (2,3,3)  2 多少页(几个通道)  3 每一页有多少行  3 每行有多少个元素(多少列) 

    2.2 元素的类型：np.ndarray.dtype

    print(a.dtype) #int64

    2.3 数组元素的个数：np.ndarray.size 

    返回数组总的元素个数

    print(a.size) # 18

    2.4 转置

    a = np.arange(1,7).reshape(2, 3)  # [[1,2,3],[4,5,6]]  2行3列
    a = a.T      # [[1,2],[3,4],[5,6]]  变为3行2列 
   

    3 ndarray 所存储元素的数据类型     

    类型名                       类型表示符                                        字符码  
    布尔类型                       bool_                                                 ? 
    有符号整型      int8(-128~127)/int16/int32/int64                 i1/i2/i4/i8    
    无符号整数型  uint8(0~255)/uint16/uint32/uint64              u1/u2/u4/u8
    浮点型             float16/float32/float64                                f2/f4/f8 
    复数型             complex64/complex128                             c8/c16
    字串型             str_，每个字符用32位Unicode编码表示    U<字符数>
    日期类型          np.datetime64                       M8[Y] M8[M] M8[D] M8[h] M8[m] M8[s]
    bool_有效值：True, False  逻辑表达式的结果也是布尔类型，结果为真为True，结果为假，为False
   

    4 数组创建

    4.1 arrange函数

    语法：   
    numpy.arange(start, stop, step, dtype=None) # 创建等差数组
    start：起始值，默认为 0 
    stop：结束值（不包含）
    step：步长，默认为 1 
    dtype：数组的数据类型
    例：
    a = np.arange(0,5,2) 数组内容[0, 2, 4] 

4.2 np.zeros函数 

    语法：
    np.zeros(数组元素个数, dtype='类型')
    # 创建值全为0的数组
    例：
    import numpy as np
    # 创建值全为0的 并包含10个元素的数组
    a = np.zeros(10) 
    print(a)   #输出： [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 
    print(type(a))    #  <class 'numpy.ndarray'> 
    print(type(a[0])) #  <class 'numpy.float64'>

4.3 np.ones函数

语法： 
    np.ones(数组元素个数, dtype='类型')   创建值全为1的数组
    例：
    import numpy as np
    # 创建值全为1的、包含10个元素的数组
    a = np.ones(10)
    print(a)   #输出： [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.] 
    print(type(a))      # <class 'numpy.ndarray'>
    print(type(a[0]))   # <class 'numpy.float64'>

5 数组操作

5.1 numpy.reshape 

定义：不改变数据的条件下修改形状 
        语法：
        numpy.reshape(arr, newshape, order='C')
        注意：修改后得到的数组和原数组共享存储区
        arr：要修改形状的数组 
        newshape：整数或者整数数组，新的形状应当兼容原有形状 
        order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序
        例：  
        import numpy as np 
        a = np.arange(8) 
        print (a)    
        b = a.reshape(4,2) 
        print (b) 
        # 输出 a  [0 1 2 3 4 5 6 7] 
        # b [[0 1] 
        #    [2 3] 
        #    [4 5] 
        #    [6 7]] 

5.2 numpy.ndarray.flat 

       定义：是一个数组元素迭代器，可以通过flat访问数组中的每个元素
        例：
        import numpy as np 
        a = np.arange(8) 
        print (a) 
        b = a.reshape(4,2) 
        for row in b: 
            print (row, end = " ")  # end = " "  表示打印以空格结束，默认是换行符
        print() 
        #对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
        for element in b.flat: 
            print (element,end = " ") 
        # 输出 
        [0 1] [2 3] [4 5] [6 7]
        0 1 2 3 4 5 6 7

5.3 numpy.ndarray.flatten    

        定义：返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
        语法：ndarray.flatten(order='C') 
        注意：修改后得到的数组和原数组独立存储区，单一修改，对另一方没有影响
        例：
        import numpy as np
        a = np.arange(8)
        c = a.reshape(2,2,2)  # c = [[[0,1],[2,3]],[[4,5],[6,7]]] 
        e = c.flatten()
        print(e) 
        a += 10
        print(a, e, sep='\n') # sep 表示a和e中间用换行符间隔打印 
        # 输出：
        #[11 32 13 14 15 16 17 18] 
        #[ 1 22  3  4  5  6  7  8]
   

5.4 numpy.ravel 

定义：直接修改原数组维度，改成一维(又叫扁平化操作)    
        语法：numpy.ravel(a, order='C')           
        注意：修改后得到的数组和原数组共享存储区
        例：    
        import numpy as np 
        a = np.arange(8)
        c = a.reshape(2,2,2)  # c = [[[0,1],[2,3]],[[4,5],[6,7]]] 
        c += 10
        e = c.ravel() 
        print(c, e, sep='\n') # sep 表示a和e中间用换行符间隔打印
        # 输出：         
        [[[10 11]
          [12 13]]
                                                                                                                           
         [[14 15]
          [16 17]]]
        [10 11 12 13 14 15 16 17]

5.5 掩码操作

定义：快速过滤数据的方法，掩码数组为True，对应位置的数据保留，为False则丢弃
        掩码数组通常是通过比较条件比较出来的 
        例：
        import numpy as np
        a = np.arange(1,6,1)
        print(a)
        mask = [True, False, True, False, False]
        print(a[mask]) # 执行掩码操作，并打印
        mask2 = (a >= 3)
        print(mask2) 
        print(a[mask2])
        # 输出
        [1 2 3 4 5]
        [1 3]
        [False False  True  True  True]
        [3 4 5]

5.6 多维数组的切片

例:
        import numpy as np
        a = np.arange(1, 28) # 产生1~28(不包含28)范围内的数字
        print(a)          # a = [1,2,3,....27]
        a.resize(3, 3, 3)    # 直接修改原数组的形状
        print(a) 
        # a = [[[1,2,3],[4,5,6],[7,8,9]],[[10,11,12],[13,14,15],[16,17,18]],[[19,20,21],[22,23,24],[25,26,27]]]
        print("***********************")
        # 切出第2页
        print(a[1, :, :]) 
        print("***********************")
        # 切出所有页的第2行          
        print(a[:, 1, :]) 
        print("***********************")
        # 切出第1页所有行的第2列
        print(a[0, :, 1]) 
        # 切出第1页所有行的第1列和第2列 
        # 页、行、列的下标索引都从0开始，第一列索引下标为0，第二列索引下标为1，第三列索引下标为2 
        print(a[0, :, 0:2])
   

5.7 二维数组的组合、拆分     

5.7.1 垂直/水平方向组合拆分

             垂直组合拆分：
              vstack(tup)   # 垂直方向组合 tup是两个二维数组组合成的元祖
              vsplit(ary,            # 待拆分的数组
              indices_or_sections)   # 拆成几个片段 
            水平组合拆分：
              hstack(tup)   # 水平方向组合 tup是两个二维数组组合成的元祖
              hsplit(ary,            # 待拆分的数组
              indices_or_sections)   # 拆成几个片段 
              例：
              import numpy as np
              # 先创建1~6的6个元素的一维数组，变为2行3列的二维数组
              a = np.arange(1,7).reshape(2, 3) 
              b = np.arange(2,8).reshape(2, 3) 
              print(a)
              print(b)
              print("--------------------")
              # (a,b) 元祖/tuple
              c = np.vstack((a,b))   # 垂直组合
              print(c)   # [[1,2,3],[4,5,6],[2,3,4],[5,6,7]]    4行3列
              print("--------------------")
              d, e = np.vsplit(c, # 待拆分的数组
                               2) # 拆分成2个片段 
              print(d) 
              print(e)

5.7.2 对数组填充

np.pad函数
        例：
        import numpy as np
        a = np.array([1,2,3,4,5]) 
        b = np.array([1,2,3,4]) 
        print(a)
        print(b)
        print("-------------------") 
        # 填充b数组使其长度与a相同
        b = np.pad(b, pad_width=(0, 1), # 对b进行填充，前面填充0个，后面填充1个
                      mode='constant', # 填充常数值 
                      constant_values=-1) # 填充常数值为-1 
        c = np.vstack((a, b))
        print(c)

5.7.3 对多维数组组合

np.split(c, 2, axis=0)
        通过给出的数组与要拆分的份数，按照某个方向进行拆分，axis的取值同上
        concatenate(tup,axis=0(default)) 
        指定要组合的元祖按照指定的方向组合
        axis = 0 垂直方向组合  改变的页/通道 
        axis = 1 水平方向组合  改变的是行
        axis = 2 深度方向组合  改变的是列  
        例：
        import numpy as np
        a = np.arange(1,9).reshape(2,2,2) 
        b = np.arange(11,19).reshape(2,2,2) 
        print(a)
        print(b) 
        print("-----------------------") 
        c = np.concatenate((a,b), # 元祖，指定要组合的数组
                           axis=0) # 轴的方向 0 垂直, 1 水平, 2 深度方向
        print(c)    
        print(c.shape)   # (4,2,2)
        print("---------------------")
        c = np.concatenate((a,b), # 元祖，指定要组合的数组
                           axis=1) # 轴的方向 0 垂直, 1 水平, 2 深度方向 
        print(c) 
        print(c.shape)  # (2,4,2)
        print("---------------------") 
        c = np.concatenate((a,b), # 元祖，指定要组合的数组
                           axis=2) # 轴的方向 0 垂直, 1 水平, 2 深度方向 
        print(c) 
        print(c.shape)  # (2,2,4)

    6 列表和数组互相转化

     数组转列表：np.array，np.asarray 
      列表转数组：列表推导式，tolist   
      import numpy as np
      #列表转数组     
      #方式1 np.array根据列表创建数组  
      L = [1, 2, 3, 4, 5] # 列表 
      print(L)
      arr1 = np.array(L) 
      print(type(L))   # list 
      print(type(arr1))  # numpy.ndarray
      #方式2 np.asarray
      arr2 = np.asarray(L)
      print(type(arr2))  # numpy.ndarray
      print(arr2)
      # 数组转列表 
      # 方式一：tolist 
      L2 = arr1.tolist()
      print(type(L2))     # list
      print(L2) 
      # 方式二：flat 列表推导式
      L3 = [elem for elem in arr1.flat] 
      print(type(L3))   # list
      print(L3)