NumPy库—数组进阶操作

1. 数组广播机制

1.1 数组与数的计算

在Python列表中，想要对列表中所有的元素都加一个数，要么采用map函数，要么循环整个列表进行操作，但是NumPy中的数组可以直接在数组上进行操作：

import numpy as np
a1 = np.random.random((3,4))
print(a1)
# result:
[[0.53079265 0.95244657 0.43759137 0.29528944][0.98528574 0.94226323 0.03288043 0.69235467][0.76084626 0.53377807 0.61253147 0.86966922]]a2 = a1 * 10 # 所有元素都乘以10
print(a2)
# result:
[[5.30792648 9.52446567 4.37591366 2.95289442][9.85285742 9.42263232 0.32880435 6.92354665][7.60846263 5.3377807  6.12531466 8.6966922 ]]a3 = a2.round(2) # 可以使用round让所有元素只保留2位小数
print(a3)
# result:
[[5.31 9.52 4.38 2.95][9.85 9.42 0.33 6.92][7.61 5.34 6.13 8.7 ]]

1.2 数组与数组的计算

结构相同的数组之间的运算：

a1 = np.arange(0,24).reshape((3,8))
a2 = np.random.randint(1,10,size=(3,8))
a3 = a1 + a2 # 相减/相除/相乘都是可以的
print(a1)
print(a2)
print(a3)# result:
a1:
[[ 0  1  2  3  4  5  6  7][ 8  9 10 11 12 13 14 15][16 17 18 19 20 21 22 23]]
a2:
[[4 4 3 7 7 2 9 6][5 9 6 7 7 2 5 4][2 6 6 1 2 4 3 6]]
a3:
[[ 4  5  5 10 11  7 15 13][13 18 16 18 19 15 19 19][18 23 24 20 22 25 25 29]]

与行数相同并且只有1列的数组之间的运算：

a1 = np.random.randint(10,20,size=(3,8))
a2 = np.random.randint(1,10,size=(3,1))
a3 = a1 - a2
print(a1)
print(a2)
print(a3)# result:
a1:
[[12 15 16 13 14 14 10 13][15 19 11 10 10 12 11 13][14 16 13 16 11 10 15 15]]
a2:
[[7][9][3]]
a3:
[[ 5  8  9  6  7  7  3  6][ 6 10  2  1  1  3  2  4][11 13 10 13  8  7 12 12]]

与列数相同并且只有1行的数组之间的运算：

a1 = np.random.randint(10,20,size=(3,8))
a2 = np.random.randint(1,10,size=(1,8))
a3 = a1 - a2
print(a1)
print(a2)
print(a3)# result:
a1:
[[13 11 17 14 10 12 19 10][15 10 14 15 16 11 14 19][16 13 10 16 11 16 17 17]]
a2:
[[7 3 1 7 8 2 5 3]]
a3:
[[ 6  8 16  7  2 10 14  7][ 8  7 13  8  8  9  9 16][ 9 10  9  9  3 14 12 14]]

1.3 广播原则

如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符或其中一方的长度为1，则认为他们是广播兼容的。广播会在缺失和长度为1的维度上进行：

shape为(3,8,2)的数组能和(8,3)的数组进行运算吗？
分析：不能，因为按照广播原则，从后面往前面数，(3,8,2)和(8,3)中的2和3不相等，所以不能进行运算。
shape为(3,8,2)的数组能和(8,1)的数组进行运算吗？
分析：能，因为按照广播原则，从后面往前面数，(3,8,2)和(8,1)中的2和1虽然不相等，但是因为有一方的长度为1，所以能参加运算。
shape为(3,1,4)的数组能和(8,1)的数组进行运算吗？
分析：能，因为按照广播原则，从后面往前面数，(3,1,4)和(8,1)中的4和1虽然不相等且1和8不相等，但是因为有一方的长度为1，所以能参加运算。

Summary：

数组和数直接进行运算。
两个shape相同的数组是可以进行运算的。
如果两个shape不同的数组，想要进行运算，那么需要看是否满足广播原则。
如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符或其中一方的长度为1，则认为他们是广播兼容的。广播会在缺失和长度为1的维度上进行。

2. 数组形状的操作

2.1 reshape和resize方法

reshape是将数组转换成指定的形状，然后返回转换后的结果，对于原数组的形状是不会发生改变的。调用方式：

a1 = np.random.randint(0,10,size=(3,4))
a2 = a1.reshape((2,6)) # 将修改的结果返回，不会影响原数组本身
print(a1)
print(a2)# result:
a1:
[[1 5 4 2][2 1 7 9][4 5 7 7]]
a2:
[[1 5 4 2 2 1][7 9 4 5 7 7]]

resize是将数组转换成指定的形状，会直接修改数组本身，并不会返回任何值。调用方式：

a1 = np.random.randint(0,10,size=(3,4))
a1.resize((2,6)) # a1本身发生了改变
print(a1)# result:
[[8 7 0 1 6 8][4 4 6 8 4 3]]

2.2 flatten和ravel方法

两个方法都是将多维数组转换为一维数组，但是有以下不同：

flatten是将数组转换为一维数组后，然后将这个拷贝返回回去，所以后续对这个返回值进行修改不会影响之前的数组。
ravel是将数组转换为一维数组后，将这个视图（可以理解为引用）返回回去，所以后续对这个返回值进行修改会影响之前的数组。

x = np.array([[1,2],[3,4]])
x.flatten()[1] = 100 # 此时的x[0]的位置元素还是1,2
print(x[0])
x.ravel()[1] = 100 # 此时x[0]的位置元素是1,100
print(x[0])# result:
[1 2]
[1 100]

2.3 不同数组的组合

如果有多个数组想要组合在一起，也可以通过其中的一些函数来实现：

vstack：将数组按垂直方向进行叠加。数组的列数必须相同才能叠加：

a1 = np.random.randint(0,10,size=(3,5))
print(a1)
a2 = np.random.randint(0,10,size=(1,5))
print(a2)
a3 = np.vstack([a1,a2])
print(a3)# result:
a1:
[[0 9 4 6 1][0 9 8 9 8][3 4 8 8 6]]
a2:
[[3 5 8 3 9]]
a3:
[[0 9 4 6 1][0 9 8 9 8][3 4 8 8 6][3 5 8 3 9]]

hstack：将数组按水平方向进行叠加，数组的行必须相同才能叠加：

a1 = np.random.randint(0,10,size=(3,2))
print(a1)
a2 = np.random.randint(0,10,size=(3,1))
print(a2)
a3 = np.hstack([a1,a2])
print(a3)# result:
a1:
[[3 5][3 9][4 7]]a2:
[[2][6][0]]a3:
[[3 5 2][3 9 6][4 7 0]]

concatenate(a,b,axis)：将两个数组进行叠加，具体是按水平方向还是垂直方向，要看axis的参数，如果axis=0，那么代表的是往垂直方向（行）叠加；如果axis=1，那么代表的是往水平方向（列）上叠加；如果axis=None，那么会将两个数组合成一个一维数组，需要注意的是，如果往水平方向上叠加，那么行必须相同，如果是往垂直方向叠加，那么列必须相同：
```
a = np.array([[1,2],[3,4]])
b = np.array([[5,6]])
np.concatenate((a,b),axis=0)
# 结果：
# array([[1, 2],
#       [3, 4],
#       [5, 6]])np.concatenate((a,b.T),axis=1)
# 结果：
# array([[1, 2, 5],
#       [3, 4, 6]])np.concatenate((a,b),axis=None)
# 结果：
# array([1, 2, 3, 4, 5, 6])
```
2.4 数组的切割

通过hsplit和vsplit以及array_split可以将一个数组进行切割：
1. hsplit：按照水平方向（保持行数不变）进行切割，用于指定分割成几列，可以使用数字来代表分成几部分，也可以使用数组来代表分割的地方：
```
a1 = np.arange(16.0).reshape(4,4)
np.hsplit(a1,2) # 分割成两部分,列数必须能被2整除# result:
[array([[ 0.,  1.],[ 4.,  5.],[ 8.,  9.],[12., 13.]]),array([[ 2.,  3.],[ 6.,  7.],[10., 11.],[14., 15.]])]np.hsplit(a1,[1,2]) # 代表在下标为1的地方切一刀，下标为2的地方切一刀，分成三部分# result:
[array([[ 0.],[ 4.],[ 8.],[12.]]),array([[ 1.],[ 5.],[ 9.],[13.]]),array([[ 2.,  3.],[ 6.,  7.],[10., 11.],[14., 15.]])]
```
2. vsplit：按照垂直方向（保持列数不变），用于指定分割成几行，可以使用数字来代表分成几部分，也可以使用数组来代表分割的地方：
```
np.vsplit(a1,2) # 保持列数不变# result:
[array([[0., 1., 2., 3.],[4., 5., 6., 7.]]),array([[ 8.,  9., 10., 11.],[12., 13., 14., 15.]])]np.vsplit(a1,(1,2)) # 代表按照行进行划分，在下标为1的地方和下标为2的地方分割 # result:
[array([[0., 1., 2., 3.]]),array([[4., 5., 6., 7.]]),array([[ 8.,  9., 10., 11.],[12., 13., 14., 15.]])]
```
3. split/array_split(array,indicate_or_seciont,axis)：用于指定切割方式，在切割的时候需要指定按照行还是按照列，axis=1代表按照列（即行数不变），axis=0代表按照行（列数不变）：
```
np.array_split(a1,2,axis=0) # 按照行切割数组，保持列数不变，切割成2部分# result:
[array([[0., 1., 2., 3.],[4., 5., 6., 7.]]),array([[ 8.,  9., 10., 11.],[12., 13., 14., 15.]])]np.array_split(a1,2,axis=1) # 按照列切割数组，保持行数不变，切割成2部分# result:
[array([[ 0.,  1.],[ 4.,  5.],[ 8.,  9.],[12., 13.]]),array([[ 2.,  3.],[ 6.,  7.],[10., 11.],[14., 15.]])]
```
2.5 数组转置和轴对称

numpy中的数组其实就是线性代数中的矩阵。矩阵是可以进行转置的。ndarray有一个T属性，可以返回这个数组的转置的结果：
```
a1 = np.arange(0,24).reshape((4,6))
a2 = a1.T
print(a1)
print(a2)# result:
a1:
[[ 0  1  2  3  4  5][ 6  7  8  9 10 11][12 13 14 15 16 17][18 19 20 21 22 23]]a2:
[[ 0  6 12 18][ 1  7 13 19][ 2  8 14 20][ 3  9 15 21][ 4 10 16 22][ 5 11 17 23]]
```
另外还有一个方法叫做transpose，这个方法返回的是一个View，也即修改返回值，会影响到原来的数组：
```
a1 = np.arange(0,24).reshape((4,6))
a2 = a1.transpose()
print(a1)
print(a2)# result:
a1:
[[ 0  1  2  3  4  5][ 6  7  8  9 10 11][12 13 14 15 16 17][18 19 20 21 22 23]]a2:
[[ 0  6 12 18][ 1  7 13 19][ 2  8 14 20][ 3  9 15 21][ 4 10 16 22][ 5 11 17 23]]
```
为什么要进行矩阵转置呢，有时候在做一些计算的时候需要用到。比如做矩阵的内积的时候，就必须将矩阵进行转置后再乘以之前的矩阵：
```
a1 = np.arange(0,24).reshape((4,6))
a2 = a1.T
print(a1)
print(a2)
print(a1.dot(a2))# result:
a1:
[[ 0  1  2  3  4  5][ 6  7  8  9 10 11][12 13 14 15 16 17][18 19 20 21 22 23]]a2:
[[ 0  6 12 18][ 1  7 13 19][ 2  8 14 20][ 3  9 15 21][ 4 10 16 22][ 5 11 17 23]]内积：
[[  55  145  235  325][ 145  451  757 1063][ 235  757 1279 1801][ 325 1063 1801 2539]]
```
Summary：

数组的形状改变：
1. reshape和resize都是重新定义形状，但是reshape不会修改数组本身，而是将修改后的结果返回回去，而resize是直接修改数组本身的。
2. flatten和ravel都是用来将数组变成一维数组的，并且都不会对原数组造成修改，但是flatten返回的是一个拷贝，所以对flatten的返回值得修改不会影响到原来数组，而ravel返回的是一个View，那么对返回值的修改会影响到原来数组的值。
数组的叠加：
1. hstack代表在水平方向叠加，如果想要叠加成功，那么他们的行必须一致。
2. vstack代表在垂直方向叠加，如果想要叠加成功，那么他们的列必须一致。
3. concatenate可以手动的指定axis参数具体在哪个方向叠加，如果axis=0，代表在垂直方向叠加；如果axis=1，代表在水平方向上叠加；如果axis=None，那么会先进行叠加，再转换成一维数组。
数组的切割：
1. hsplit代表在水平方向切割，按列进行切割的。他的切割方式有两种，第一种是直接指定平均切割成多少列，第二种是指定切割的下标值。
2. vsplit代表在垂直方向切割，按行进行切割，他的切割方式跟hsplit是一样的。
3. split/array_split是手动的指定axis参数，axis=0，代表按行进行切割，axis=1，代表按列进行切割。
矩阵转置：
1. 可以通过ndarray.T的形式进行转置。
2. 也可以通过ndarray.transpose()进行转置，这个方法返回的是一个View，所以对返回值上进行修改，会影响到原来的数组。

NumPy库---数组进阶操作相关推荐

如何查看numpy库数组的：类型、数据类型、尺寸、形状、维度？ (type、dtype、size、shape、ndim)
import numpy as np a1 = np.array([1,2,3,4],dtype=np.complex128) print("a1:",a1) print(&quo ...
2 NumPy库的基础操作
NumPy是一个专门用来进行数学计算的第三方库,对线性代数的支持较好.(Matlab与Python一较高下?期待...) 2.1 NumPy库安装和基本方法安装好pip后,在cmd窗口输入:pip ...
Scala数组的基本操作，数组进阶操作，多维数组
1.Scala中提供了一种数据结构-数组,其中存储相同类型的元素的固定大小的连续集合.数组用于存储数据的集合,但它往往是更加有用认为数组作为相同类型的变量的集合 2 声明数组变量: 要使用的程序的数组 ...
OpenCV_03 Numpy库和Mat
前言主要学习Numpy库的相关操作和Mat的基础知识. 目录前言一.Numpy基本操作 1.创建矩阵创建数组array() 创建全0/1数组zeros()/ones() 创建全值数组full( ...
numpy库的一些解释
Numpy库介绍 NumPy是一个的Python库,主要用于对多维数组执行计算. NumPy这个词来源于两个单词-- Numerical [njuːˈmerɪkl] (数值;数值法;数值的;数字的)和 ...
python的 numpy库学习总结和介绍(超详细)模块
目录前言 numpy是什么? 一.创建数据容器 1.np.array(),通过传递一个列表,元祖来创建 2.np.zeros(),np.ones(),np.empty(),np.full(),传递对 ...
python第三方库numpy-Python三方库：Numpy（数组处理）
Numpy是Python中用于处理数组的一个非常强大的库,同时也是Pandas等数据处理的库的核心,如果你有大量处理数组类型数据的操作,比如操作CSV文件数据或涉及数组的科学计算等,那么Numpy是一 ...
numpy库中ndarray切片操作的参数意义
ndarray切片操作的规则总结出来叫做"三帽号规则" 三帽号规则即:[开始索引:结尾索引:步长],并且切片区间是左闭右开的,即"开始索引:结尾索引"表示的区间 ...
Python 数据分析三剑客之 NumPy（六）：矩阵 / 线性代数库与 IO 操作
CSDN 课程推荐:<Python 数据分析与挖掘>,讲师刘顺祥,浙江工商大学统计学硕士,数据分析师,曾担任唯品会大数据部担任数据分析师一职,负责支付环节的数据分析业务.曾与联想.亨氏.网 ...
机器学习中的Numpy库基础——向量、矩阵和数组
1.Numpy简介 Numpy是Python机器学习技术栈的基础. Numpy可以对机器学习中常用的数据结构--向量(vector).矩阵(matrice).张量(tensor)--进行高效的操作. ...

NumPy库---数组进阶操作

文章目录