数据操作之numpy模块2——数组的切片、变形、级联、拆分与数学计算

系列其他文章
数据分析之numpy模块1——数组的创建、属性、数据类型
数据分析之numpy模块3——数组的排序、乱序、索引与上下限设置

数组的切片操作

切片操作(从start开始，stop结束，stop不包括在内)

arr

输出：array([[19, 35, 62, 60, 45, 39],
      [80, 85, 68, 72, 34, 85],
      [ 7, 72, 48, 74, 24, 35],
      [12, 52, 96, 40, 2, 58],
      [39, 94, 50, 56, 49, 62]])

1. 切出数组的指定行数据

#切出前两行数据
arr[0:2] #arr[行切片]

输出：array([[19, 35, 62, 60, 45, 39],
      [80, 85, 68, 72, 34, 85]])

2. 切出数组的指定列数据

#切出前两列数据
arr[:,0:2] #arr[行切片,列切片]

输出：array([[19, 35],
      [80, 85],
      [ 7, 72],
      [12, 52],
      [39, 94]])

3. 切出数组的指定行和列数据

#切出前两行的前两列的数据
arr[0:2,0:2] #arr[行切片,列切片]

输出：array([[19, 35],
      [80, 85]])

4. 数组数据翻转(实质是设置step为-1)

#将数组的行倒置
arr[::-1]

输出： array([[39, 94, 50, 56, 49, 62],
      [12, 52, 96, 40, 2, 58],
      [ 7, 72, 48, 74, 24, 35],
      [80, 85, 68, 72, 34, 85],
      [19, 35, 62, 60, 45, 39]])

#将数组的列倒置
arr[:,::-1]

输出：array([[39, 45, 60, 62, 35, 19],
      [85, 34, 72, 68, 85, 80],
      [35, 24, 74, 48, 72, 7],
      [58, 2, 40, 96, 52, 12],
      [62, 49, 56, 50, 94, 39]])

#所有元素倒置
arr[::-1,::-1]

输出：array([[62, 49, 56, 50, 94, 39],
      [58, 2, 40, 96, 52, 12],
      [35, 24, 74, 48, 72, 7],
      [85, 34, 72, 68, 85, 80],
      [39, 45, 60, 62, 35, 19]])

---

数组的变形操作：reshape

arr#是一个5行6列的二维数组

输出：array([[69, 80, 7, 90, 31],
      [44, 37, 57, 26, 92],
      [91, 34, 13, 16, 93],
      [54, 87, 34, 5, 16],
      [47, 66, 51, 12, 54],
      [63, 20, 11, 94, 88]])

1）reshape((n,-1))是将数组转化为二维，行数为n，列数自行计算
2）reshape((-1,n))是将数组转化为二维，列数为n，行数自行计算
3）利用reshape实现降维

#将二维的数组变形成一维
arr_1 = arr.reshape((30,))
arr_1

输出：array([69, 80, 7, 90, 31, 44, 37, 57, 26, 92,91, 34, 13, 16, 93, 54, 87,
      34, 5, 16, 47, 66, 51, 12, 54, 63, 20, 11, 94, 88])

4）利用reshape实现升维

#将一维变形成多维
arr_1.reshape((6,5))

输出：array([[69, 80, 7, 90, 31],
      [44, 37, 57, 26, 92],
      [91, 34, 13, 16, 93],
      [54, 87, 34, 5, 16],
      [47, 66, 51, 12, 54],
      [63, 20, 11, 94, 88]])

---

数组的级联操作

1. concatenate：指定方向级联

arr#是一个5行6列的二维数组

输出：array([[69, 80, 7, 90, 31],
      [44, 37, 57, 26, 92],
      [91, 34, 13, 16, 93],
      [54, 87, 34, 5, 16],
      [47, 66, 51, 12, 54],
      [63, 20, 11, 94, 88]])

• 将多个同一维度的numpy数组进行横向或者纵向的拼接

纵向拼接时要求两个数组列数相同，否则会报错；
横向拼接时要求两个数组行数相同，否则会报错；

• axis轴向的理解：

0：垂直方向（第一维）延伸，即依据列级联；
1：水平方向（第二维）延伸，即依据行级联；

• 水平方向级联：

np.concatenate((arr,arr),axis=1)

输出：array([[69, 80, 7, 90, 31, 44, 69, 80, 7, 90, 31, 44],
      [37, 57, 26, 92, 91, 34, 37, 57, 26, 92, 91, 34],
      [13, 16, 93, 54, 87, 34, 13, 16, 93, 54, 87, 34],
      [ 5, 16, 47, 66, 51, 12, 5, 16, 47, 66, 51, 12],
      [54, 63, 20, 11, 94, 88, 54, 63, 20, 11, 94, 88]])

2. vstack：竖直方向级联

• np.vstack((arr,arr))：在竖直方向上延伸，相当于np.concatenate((arr,arr),axis=0)

import numpy as np
arr1=np.array([1,2,3])
arr2=np.array([4,5,6])
print(np.vstack((arr1,arr2)))

输出：[[1 2 3]
    [4 5 6]]

3. hstack：水平方向级联

• np.hstack((arr,arr))：在水平方向上延伸，相当于np.concatenate((arr,arr),axis=1)

print(np.hstack((arr1,arr2)))

输出：[1 2 3 4 5 6]

---

数组的拆分操作：split

arr

输出：array([[19, 35, 62, 60, 45, 39],
      [80, 85, 68, 72, 34, 85],
      [ 7, 72, 48, 74, 24, 35],
      [12, 52, 96, 40, 2, 58],
      [39, 94, 50, 56, 49, 62]])

• 将一个多维度numpy数组进行横向或者纵向的拆分；
• axis轴向的理解：

0：垂直方向做拆分，即把每列按某一行分开；
1：水平方向做拆分，即把每行按某一列分开；

• [ ]内的数：表示按该行/列进行拆分；

a1,a2 = np.split(arr,[2],axis=1)
print(a1)
print(a2)

输出：[[19 35]
    [80 85]
    [ 7 72]
    [12 52]
    [39 94]]
   [[62 60 45 39]
    [68 72 34 85]
    [48 74 24 35]
    [96 40 2 58]
    [50 56 49 62]]

---

数组的聚合操作

# 6x6多维数组（矩阵）
arr

输出：array([[62, 65, 51, 15, 30, 63],
      [37, 8, 55, 70, 13, 84],
      [46, 44, 86, 11, 72, 91],
      [10, 47, 3, 96, 9, 36],
      [54, 24, 55, 72, 29, 45]])

• 常用操作有：sum求和、max求最大值、min求最小值、mean求平均值；
• 可以通过axis指定维度进行聚合操作，如果不指定就是对整个数组进行聚合操作：

# 求每一行的和
arr.sum(axis=1)

输出：array([286, 267, 350, 201, 279])

# 求每一行的最大值
arr.max(axis=1)

输出：array([65, 84, 91, 96, 72])

# 求数组的最大值
arr.max()

输出：96

---

常用的数学函数

1. 三角函数

• NumPy 提供了标准的三角函数：sin()、cos()、tan()

np.sin(2.5)

输出：0.5984721441039564

2. np.around：四舍五入

• numpy.around(a,decimals) 函数返回指定数字的四舍五入值。
• 参数说明：
  1） a: 数组
  2） decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

np.around(3.84,2)

输出：3.84

3. np.prod：乘积函数

• 返回给定维度上各个元素的乘积
• numpy.prod(a,axis=None,dtype=None,out=None,keepdims=,initial=)
• 参数说明：
  1）axis：是指求积的维度；
  2）keepdims：是指保持维度，不缩减；
  3）initial：是起始数，即返回的矩阵会用乘积结果再乘该起始数；

# 不指定维度则整体求乘积
np.prod([[1.,2.],[3.,4.]])

输出：24.0

# 求每行的乘积
np.prod([[1.,2.],[3.,4.]], axis=1)

输出： array([ 2. , 12. ])

# 求出数组整体乘积，并乘起始数
np.prod([1, 2], initial=5)

输出：10

---

常用的统计函数

1. array.amin() 和 array.amax()：用于计算数组中的元素沿指定轴的最小、最大值；
2. array.ptp()：计算数组中元素最大值与最小值的差（最大值 - 最小值）；
3. array.median()：函数用于计算数组中元素的中位数（中值）；
4. array.std()：函数用于计算数组中元素的标准差（一组数据平均值分散程度的一种度量）；

• 公式：std = sqrt(mean((x - x.mean())**2))；
• 如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方[2.25,0.25,0.25,2.25]，并且其平均值的平方根除以 4，即 sqrt(5/4)，结果为 1.1180339887498949。

arr[1].std()

输出：26.66718749491384

5. array.var()：函数用于计算数组中元素的方差；

• 统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)；
• 换句话说，标准差是方差的平方根。

arr[1].var()

输出： 711.138888888889

---

矩阵的相关操作

• NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。一个矩阵是一个由行（row）列（column）元素排列成的矩形阵列。

• numpy.matlib.identity() 函数返回给定大小的单位矩阵。单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。

1. 标准单位矩阵：np.eye

#eye返回一个标准的单位矩阵
np.eye(6)

输出：array([[1., 0., 0., 0., 0., 0.],
      [0., 1., 0., 0., 0., 0.],
      [0., 0., 1., 0., 0., 0.],
      [0., 0., 0., 1., 0., 0.],
      [0., 0., 0., 0., 1., 0.],
      [0., 0., 0., 0., 0., 1.]])

2. 矩阵转置：array.T

arr.T

输出：array([[69, 37, 13, 5, 54],
      [80, 57, 16, 16, 63],
      [ 7, 26, 93, 47, 20],
      [90, 92, 54, 66, 11],
      [31, 91, 87, 51, 94],
      [44, 34, 34, 12, 88]])

3. 矩阵相乘：numpy.dot

• numpy.dot(a, b, out=None)
  1）a : ndarray 数组
  2）b : ndarray 数组
  

• 第一个矩阵第一行的每个数字（2和1），各自乘以第二个矩阵第一列对应位置的数字（1和1），然后将乘积相加（ 2 x 1 + 1 x 1），得到结果矩阵左上角的那个值3。也就是说，结果矩阵第m行与第n列交叉位置的那个值，等于第一个矩阵第m行与第二个矩阵第n列，对应位置的每个值的乘积之和。

• 线性代数基于矩阵的推导

a1 = np.array([[2,1],[4,3]])
a2 = np.array([[1,2],[1,0]])
np.dot(a1,a2)

输出：array([[3, 4],
      [7, 8]])