Numpy的使用（二）

数组拼接

• np.vstack()

  • 垂直拼接

  • In [1]: import numpy as np
    
    In [2]: arr = np.arange(12).reshape(3,4)
    
    In [3]: arr
    Out[3]:
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    
    In [4]: arr.shape
    Out[4]: (3, 4)
    
    In [5]: # 垂直拼接需要对应的列数一样
    
    In [6]: arr1 = np.arange(8).reshape(2,4)
    
    In [7]: np.vstack([arr,arr1])
    Out[7]:
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [ 0,  1,  2,  3],
           [ 4,  5,  6,  7]])
    

• np.hstack()

  • 水平拼接

  • In [11]: # 垂直拼接的行数必须要一致
    
    In [12]: # 水平拼接的列数必须要一致
    
    In [13]: import numpy as np
    
    In [14]: arr = np.arange(12).reshape(3,4)
    
    In [15]: arr.shape
    Out[15]: (3, 4)
    
    In [16]: arr1 = np.arange(6).reshape(3,2)
    
    In [17]: arr1
    Out[17]:
    array([[0, 1],
           [2, 3],
           [4, 5]])
    
    In [18]: arr
    Out[18]:
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    
    In [19]: np.hstack([arr,arr1])
    Out[19]:
    array([[ 0,  1,  2,  3,  0,  1],
           [ 4,  5,  6,  7,  2,  3],
           [ 8,  9, 10, 11,  4,  5]])
    

• 注意：vstack的垂直拼接的列数要一致，hstack的水平拼接的行数要一致

索引与切片

一维数组

一维数组很简单，基本和列表一致。它们的区别在于数组切片是原始数组视图（意味着类似于深拷贝，如果任何的修改，原始都会跟着更改）。它也意味着，如果不想更改原始数组，我们需要进行显式的复制，从而得到它的副本。

• 索引从0开始
• 切片左闭右开
• 步长为整数

二维数组

• 二维数组递归方式获取

• 二维数组逗号分隔获取（行，列）

  • 取单行 arr[x1,:]

  • 取连续行 arr[x1:x2,:]

  • 取分开行 arr[[x1,x2],:]

  • 取子矩阵 arr[x1:x2,y1:y2]

  • 取点 arr[[x1,x2],[y1,y2]]

  • In [12]: import numpy as np
    
    In [13]: arr = np.arange(12).reshape(3,4)
    
    In [14]: # 取单行
    
    In [15]: arr
    Out[15]:
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    
    In [16]: arr[1]
    Out[16]: array([4, 5, 6, 7])
    
    In [17]: # 取连续行
    
    In [18]: arr[1:]
    Out[18]:
    array([[ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    
    In [19]: # 取分开行
    
    In [20]: arr[[0,1],:]
    Out[20]:
    array([[0, 1, 2, 3],
           [4, 5, 6, 7]])
    
    In [21]: arr[[0,2],:]
    Out[21]:
    array([[ 0,  1,  2,  3],
           [ 8,  9, 10, 11]])
    
    In [22]: # 取子矩阵
    
    In [23]: arr[1:2,0:1]
    Out[23]: array([[4]])
    
    In [24]: # 取点
    
    In [25]: arr[[0,2],[3,3]]
    Out[25]: array([ 3, 11])
    
    In [26]: # 取点位置相当于对应的（x1,y1）(x2,y2)
    

注意

• 当有需要修改数组当中的值时，我们可以直接取值进行赋值
• 当赋值后会直接影响原有的数组的值
• 当数组与标量进行比较时，数组当中每个元素与标量进行比较，返回bool值。与此同时，该比较也可以作为索引，被称为布尔索引。

修改数组当中的值

In [28]: arr
Out[28]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [29]: arr[0:,]
Out[29]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [30]: arr[[0,2],:]
Out[30]:
array([[ 0,  1,  2,  3],
       [ 8,  9, 10, 11]])

In [31]: arr[[0,2],:] = 10

In [32]: arr
Out[32]:
array([[10, 10, 10, 10],
       [ 4,  5,  6,  7],
       [10, 10, 10, 10]])

In [33]: # 采用直接赋值的方式来进行修改

将条件逻辑作为数组操作

• np.where(condition, [x, y])

  • 该函数为三元表达式x if condition else y的向量化版本

  • condition : 为条件

  • x ： 当条件满足的时候执行x

  • y ： 当条件不满足的时候执行y

  • In [37]: arr1 = np.arange(24).reshape(4,6)
    
    In [38]: arr1
    Out[38]:
    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]])
    
    In [39]: # 将arr1中的数组，将大于10的数组变成20，小于10的数组变成0
    
    In [40]: np.where(arr1>10, 20, 0)
    Out[40]:
    array([[ 0,  0,  0,  0,  0,  0],
           [ 0,  0,  0,  0,  0, 20],
           [20, 20, 20, 20, 20, 20],
           [20, 20, 20, 20, 20, 20]])
    

  • In [41]: # 将arr1中的数组，将大于10的数组变成20，小于10的数组变成本身
    
    In [42]: np.where(arr1>10, 20, arr1)
    Out[42]:
    array([[ 0,  1,  2,  3,  4,  5],
           [ 6,  7,  8,  9, 10, 20],
           [20, 20, 20, 20, 20, 20],
           [20, 20, 20, 20, 20, 20]])
    

• np.clip((a, a_min, a_max)

  • a : 为数组

  • a_min : 最小的值

  • a_max : 最大的值

  • In [45]: arr1
    Out[45]:
    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]])
    
    In [46]: # 设置最小值为9，最大值为20
    
    In [47]: np.clip(arr1, 9, 20)
    Out[47]:
    array([[ 9,  9,  9,  9,  9,  9],
           [ 9,  9,  9,  9, 10, 11],
           [12, 13, 14, 15, 16, 17],
           [18, 19, 20, 20, 20, 20]])
    
    In [48]: # 当值小于9会自动变成9，当大于20会变成20
    
    In [49]:
    

  基础数组常用方法

  方法	描述
  sum	沿着轴向计算所有元素的累和，0长度的数组，累和为0
  mean	数学平均值，0长度的数组平均值为NaN
  max, min	最大值和最小值
  argmax, argmin	最大值和最小值的位置
  std, var	标准差和方差
  ptp	极值()
  cumsum	从0开始元素累积和
  median	中值

  In [67]: arr1
  Out[67]:
  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]])
  
  In [68]: # 所有值的和
  
  In [69]: np.sum(arr1)
  Out[69]: 276
  
  In [70]: # 平均值
  
  In [71]: np.mean(arr1)
  Out[71]: 11.5
  
  In [72]: # 最大值
  
  In [73]: np.max(arr1)
  Out[73]: 23
  
  In [74]: # 最小值
  
  In [75]: np.min(arr1)
  Out[75]: 0
  
  In [76]: # 最大值的索引位置
  
  In [77]: np.argmax(arr1)
  Out[77]: 23
  
  In [78]: # 标准差
  
  In [79]: np.std(arr1)
  Out[79]: 6.922186552431729
  
  In [80]: # 方差
  
  In [81]: np.var(arr1)
  Out[81]: 47.916666666666664
  
  In [82]: # 极值
  
  In [83]: np.ptp(arr1)
  Out[83]: 23
  
  In [84]: # 元素累积
  
  In [85]: np.cumsum(arr1)
  Out[85]:
  array([  0,   1,   3,   6,  10,  15,  21,  28,  36,  45,  55,  66,  78,
          91, 105, 120, 136, 153, 171, 190, 210, 231, 253, 276], dtype=int32)
  
  In [86]: # 中值
  
  In [87]: np.median(arr1)
  Out[87]: 11.5
  

Nan 和 inf

Nan与inf介绍

• Nan : not a number 它表示不是一个数字
• inf : inf表示正无穷，-inf表示负无穷

注意

• 两个np.nan是不相等的
• Nan和inf都是为浮点数
• Nan 与任何值计算都是Nan

In [17]: import numpy as np

In [18]: arr = np.arange(16).reshape(4,4)

In [19]: # np.nan为浮点数，两个nan不相等

In [20]: arr = arr.astype('float')

In [21]: arr
Out[21]:
array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.],
       [12., 13., 14., 15.]])

In [22]: # 将6变成nan,

In [23]: arr[1,2] = np.nan

In [24]: arr
Out[24]:
array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5., nan,  7.],
       [ 8.,  9., 10., 11.],
       [12., 13., 14., 15.]])

In [25]: np.nan == np.nan
Out[25]: False

In [26]: # 两个nan比较是完全不相等的

判断数组中的nan的个数

• np.count_nonzero(arr)
  • 计算数组非零的个数
• np.isnan(arr)
  • 判断数组元素是否为Nan

In [31]: arr
Out[31]:
array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5., nan,  7.],
       [ 8.,  9., 10., 11.],
       [12., 13., 14., 15.]])

In [32]: # 计算数组非零的个数

In [33]: np.count_nonzero(arr)
Out[33]: 15

In [34]: # 计算数组中为nan的个数

In [35]: np.isnan(arr)
Out[35]:
array([[False, False, False, False],
       [False, False,  True, False],
       [False, False, False, False],
       [False, False, False, False]])

In [36]: # isnan 等价于 arr!= arr

In [37]: arr != arr
Out[37]:
array([[False, False, False, False],
       [False, False,  True, False],
       [False, False, False, False],
       [False, False, False, False]])

In [39]: np.count_nonzero(np.isnan(arr))
Out[39]: 1

处理Nan

​ 在Numpy中，为了避免处理后的Nan的值会对整体的数值有比较大的影响，通常我们会将其替换成中值或者均值即可

# @Time : 2020/4/30 10:01 
# @Author : SmallJ 


import numpy as np

"""
在numpy中，为了避免处理后的nan,一般我们采用替换成中值或者平均值
"""

# 生成数组
arr = np.arange(16).reshape(4, 4).astype('float')

# 生成nan数据
arr[1, 2:] = np.nan

# 处理nan数据,由于该nan为第二行。
# 如果采用行的方式,求出来的平均值或中值就不准确了
# 所以采用列的方式，来求平均值

# 第一步 采用for循环，循环出列数
for i in range(arr.shape[1]):
    # 取出每一列
    arr_col = arr[:, i]

    # 获取每一列的nan的个数
    nan_num = np.count_nonzero(np.isnan(arr_col))

    # nan为0的时候证明没有没有nan,为1时证明有nan
    if nan_num != 0:

        # 取出不是nan的数值
        # 怎么判断呢，因为两个nan之间是不相等的
        not_num = arr_col[arr_col == arr_col]
        data = np.mean(not_num)
        # 将nan进行赋值
        arr_col[arr_col != arr_col] = data

arr = arr.astype('int')
print(arr)

Numpy读取本地数据

np.loadtxt(fname,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)

参数	解释
frname	文件、字符串或产生器，可以是.gz或bz2压缩文件
dtype	数据类型，可选，csv的字符串以什么数据类型读入数组中，默认np.float
delimiter	分隔字符串，默认是任何空格，改为逗号
skiprows	跳过前x行，一般跳出第一行表头
usecols	读取指定的列，索引，元组类型
unpack	如果True，读入属性将分别写入不同数组变量，Flase读入数据只写入一个数组，默认为False