Numpy的使用（二）

最新推荐文章于 2022-10-03 15:37:08 发布

Small-J

最新推荐文章于 2022-10-03 15:37:08 发布

阅读量1.1k

点赞数 1

分类专栏： Python数据分析文章标签： python numpy

本文链接：https://blog.csdn.net/qq_37662827/article/details/105860854

版权

Python数据分析专栏收录该内容

14 篇文章 2 订阅

订阅专栏

数组拼接

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

Small-J

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Numpy的使用（二）

数组拼接np.vstack()垂直拼接In [1]: import numpy as npIn [2]: arr = np.arange(12).reshape(3,4)In [3]: arrOut[3]:array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])In [4...
复制链接

扫一扫