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

你可能感兴趣的:(Python数据分析,python,numpy)