Numpy

Numpy 高效的运算工具

1. 学习任务：数值运算库

   1. 优势

   2. ndarray（n-任意，d-维度，array数组，任意维度数组）属性

      ​ 描述相同类型的‘item’的集合

   3. 基本操作

      1. ndarray，方法()

      2. numpy.函数名()

      3. ndarray运算

   4. 合并，分割，IO操作，数据处理（了解）

2. Numpy介绍

   1. Numpy（Numerical Python）是一个开源的Python科学计算库，用于快速处理任意维度的数组。Numpy支持常见的数组和矩阵操作，对于同样的数值计算任务，使用Numpy比直接使用Python要简洁的多。

   2. 使用

      import numpy as np
      score = np.array([[2,3,4,5,6],
               [233,455,322,342,54],
               [44,324,432,32,42],
               [32,43,43,5,47],
               [54,65,76,87,98],
               [65,76,42,345,32]])
      

   3. adarray与Python原生list运算效率对比(使用一亿个数据做求和做时间对比)

    ```python
    import random
    import time
    x = range(100000000)
    python_list = [random.randint(100,120) for i in x]
    ndarray_list = np.array(python_list)
    #原生pythonlist求和
    t1 = time.time()
    a = sum(python_list)
    t2 = time.time()
    d1 = t2 - t1
    
    #ndarray求和
    t3 = time.time()
    b = np.sum(ndarray_list)
    t4 = time.time()
    d2 = t4 - t3
    ```
     计算得出，adarray的运算时间是原生list的六倍左右
   

   4. ndarray的优势

      1. 因为ndarray存储的都是相同数据类型，所以存储类似于数组，查找比较快

      2. ndarray支持并行运算，向量化运算

      3. Numpy底层使用C语言编写，内部解除GIL（全局解释锁），其对数组的操作速度不受Python解释器的限制，效率远高于纯python代码

   5. ndarray的属性

      1. shape 形状np.shape(8,5),二维
      2. ndim 维度
      3. size 数量
      4. dtype 类型
      5. itemsize 一个元素占几个字节

   6. ndarray的使用

      1. 形状（一维，二维，三维）
      2. 类型（int64，int32， float64，float32）

3. 基本操作

   1. 生成数组

      #1.生成0和1的数组
      np.zeros(shape=(3,4),dtype = "float32")
      np.ones(shape=[2,3],dtype=np.int32)
      #2.从现有数组生成
      np.array(数组名) 深拷贝
      np.asarray(数组名) 浅拷贝
      np.copy(数组名)  深拷贝
      拷贝后修改远数组，array和copy没有变化，asarray会变化
      #3.生成固定范围的数组
      np.linespace(0,10,100) 
      #[0, 10]范围,100个元素
      np.arange(a, b, c)
      #[a, b)范围，步长为c
      

   2. 生成随机数组

      1. 均匀分布(uniform distribution)

         np.random.uniform(low=0.0,high=1.0,size=None)
         

      2. 正态分布

         1. σ 幅度，集中程度，稳定性

            np.random.normal(loc = 1.75,scale = 0.1, size = 1000000)
            

   3. 类型修改

      ndarray.astype(type)
      #如何需要将ndarray序列化到本地，需要转化bytes类型
      np.tostring()
      

   4. 数组去重

      1. 可以用set方法，但是只能作用于一维的数据

         #flatten,转化为一维数据
         set(temp.flatten())
         

      2. unique方法

         np.unique(temp)
         

4. 运算

   1. 逻辑运算

      直接使用比较符号

      stock_change = np.random.normal(loc=0,scale=1,size=(8,10))
      stock_change > 5
      #布尔索引
      stock_change[stock_change > 0.5]
      

      通用判断函数

      # all 只有全是true才返回true
      np.all(布尔值)
      #any 只要有一个true就返回true
      np.any()
      #判断前5只股票这段期间是否有上涨的
      np.any(stock_change[:5,:] > 0)
      

      三元运算符

      np.where(布尔值，True的位置的值，False的位置的值)
      #判断前四个股票前四天的涨幅是否大于0
      temp = stock_change[:4,:4]
      np.where(temp > 0, 1, 0)
      #复合逻辑需要结合np.logical_and和np.logical_or使用
      np.logical_and(temp > 0.5,temp < 1)
      #结合where
      np.where(np.logical_and(temp > 0.5,temp < 1), 1, 0)
      

   2. 统计运算

      1. 统计指标函数

         min,max,mean,median,var(方差),std（标准差）

         使用

         ​ np.函数名 或者

         ​ ndarray.方法名

      2. 进行统计的时候，axis轴的取值并不一定，Numpy中不同的api轴的值都不一样，在这里，axis=0代表列，axis=1代表行去进行统计

         np.max(axis=1)
         

      3. 返回位置argmax

         np.argmax(temp,axis=0)
         

   3. 数组间的运算

      1. 数组与数的运算

         #直接写即可
         arr = np.array([1,2,3,4],[5,6,7,8])
         arr / 10
         

      2. 数组与数组的运算

         1. 判断两个数组是否可以进行运算的机制------广播机制
         
              ​	维度相等
         
              ​	shape（其中相对应的一个地方为1）
         

         #例如,每个数字代表维度
         Image（3d array）:256 * 256 * 3
         scale (1d array):            3
         result(3d array):256 * 256 * 3
         
         A(3d array):     9 * 1 * 7 * 1
         B(3d array):         8 * 1 * 5
         result(3d array) 9 * 8 * 7 * 5
         
         A(3d array):              15 * 3 * 5
         B(3d array):              15 * 1 * 1
         result(3d array):         15 * 3 * 5
         
         #下面的则不能进行运算
         A(1d array): 10
         B(1d array): 12   #维度不相同
         
         A（2d array）:      2 * 1
         B（3d array）:  8 * 4 * 3 
         

   4. 矩阵运算（matrix）

      1. 存储

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

      2. 形状，运算要求

         1. 形状 (m*n) ,(n * m)

         2. 运算

            np.matmul(矩阵1，矩阵2)
            np.dot(矩阵1，矩阵2)
            #如果两个矩阵要直接相乘，要看是否满足广播机制
            

         3. 合并与分割

            1. 合并

               1. 水平拼接，np.concatenate((A,B),axis=1)
               2. 竖直拼接，np.concatenate((A,B),axis=0),默认

            2. 分割（split)

                   np.split(矩阵，[下标/索引])
                   ```
               
               

   5. IO操作和数据处理

      1. Numpy读取

         #读取csv文件,不支持读取字符串，Numpy擅长的是数值计算，字符串会显示nan（not a number）
         np.genfromtxt("test.csv",delimiter=",")
         #处理缺失值，后面学了pandas可以一行搞定
         #1.直接删除
         #2.插补法(将nan替换为列平均值)
         def fill_nan_by_column_mean(t):
             for i in range(t.shape[1]):
                 #计算nan的个数
                 nan_num = np.count_nonzero(t[:,i][t[:,i]!= t[:,i]])
                 if nan_num > 0
                 	now_col = t[:, i]
                     #求和
                     now_col_not_nan = now_col[np.isnan(now_col) == False].sum()
                     #和个数
                     now_col_mean = now_col_not_nan / (t.shape[0] - nan_num)
                     #赋值给now_col
                     now_col[np.isnan(now_col)] = now_col_mean
                     #赋值给t，即更新t的当前列
                     t[:,i] = now_col
               return t