【numpy基础】--基础操作

numpy作为一个强大的数值计算库，提供了对多维数组的很多便捷操作。
承接上一篇数组的创建，本篇主要介绍一些数组的基本操作。
1. 子数组

首先介绍获取子数组的方法，提取已有数据的一部分来参与计算是比较常用的功能。
对于一维数组，提取子数组：arr[start:stop:step]

• start：从哪个下标开始（下标从 0 开始）
  
• stop：到哪个下标结束（下标不包括 stop 这个值）
  
• step：间隔几个元素
  

1. arr = np.array(range(10))  # 生成 0~9 10个元素
2. print(arr[::2]) # 偶数
3. print(arr[1::2]) # 奇数
4. print(arr[1:6:2]) # 前六个数中的奇数
5. print(arr[::-1]) # 逆序
7. #运行结果
8. [0 2 4 6 8]
9. [1 3 5 7 9]
10. [1 3 5]
11. [9 8 7 6 5 4 3 2 1 0]

复制代码

对于多维数组，同样可以使用上面的方式，数组有几维，就可以使用几次 start:stop:step。
比如下面的二维数组：

1. arr = np.array([range(6), range(1, 7),
2.                 range(2, 8), range(3, 9),
3.                 range(4, 10)])
4. print(arr)
5. #运行结果
6. [[0 1 2 3 4 5]
7. [1 2 3 4 5 6]
8. [2 3 4 5 6 7]
9. [3 4 5 6 7 8]
10. [4 5 6 7 8 9]]
12. print(arr[::2, ::2])
13. #运行结果
14. [[0 2 4]
15. [2 4 6]
16. [4 6 8]]

复制代码

也就是按行取第 1，3，5行，然后按列取第 1，3，5列。
2. 数组副本

当我们提取子数组之后，如果对子数组进行修改，那么原始的数组也会变化。
这个因为数组是引用类型，当数组的数据量很大的时候，内存占用会比较低。
比如：

1. arr = np.array(range(5))
2. arr2 = arr[::2]
3. arr2[2] = 99
5. print(arr)
6. #运行结果
7. [ 0  1  2  3 99]
9. print(arr2)
10. #运行结果
11. [ 0  2 99]

复制代码

子数组修改之后，原始数组也改变了。
如果要避免修改原始数组，就要建立子数组的副本，也就是 copy 方法。

1. arr = np.array(range(5))
2. arr2 = arr[::2].copy() # 通过copy方法建立副本
3. arr2[2] = 99
5. print(arr)
6. #运行结果
7. [0 1 2 3 4]
9. print(arr2)
10. #运行结果
11. [ 0  2 99]

复制代码

3. 数组变形

进行数据分析时，我们常常得到的是线性的数据序列，也就是一维数组，
在numpy中，从一维变到多维非常方便。

1. #一维变多维
2. arr = list(range(9))
3. print(arr)
4. #运行结果
5. [0, 1, 2, 3, 4, 5, 6, 7, 8]
7. arr = np.array(arr).reshape((3, 3))
8. print(arr)
9. #运行结果
10. [[0 1 2]
11. [3 4 5]
12. [6 7 8]]

复制代码

注意，变换前后元素的总数量要一直，比如上面的例子中，
变换前一维数组有9个元素，变换成 3x3 的二维数组，也是9个元素。
如果变换成 3x4 或者 2x3 的二维数组，就会出错。
除了二维数组，变成三维数组也一样：

1. arr = np.array(range(24)).reshape((2, 3, 4))
3. print(arr)
4. #运行结果
5. [[[ 0  1  2  3]
6.   [ 4  5  6  7]
7.   [ 8  9 10 11]]
9. [[12 13 14 15]
10.   [16 17 18 19]
11.   [20 21 22 23]]]

复制代码

4. 拼接和拆分

最后一个基本操作是数组的拼接和拆分。
4.1. 拼接

拼接有两个方向，水平拼接和垂直拼接，拼接的数组个数不限。
比如，下面的示例是3个数组拼接在一起。

1. arr1 = np.array([range(1, 4),
2.                  range(1, 4),
3.                  range(1, 4)])
4. arr2 = np.array([range(4, 7),
5.                  range(4, 7),
6.                  range(4, 7)])
7. arr3 = np.array([range(7, 10),
8.                  range(7, 10),
9.                  range(7, 10)])
11. arr = np.concatenate([arr1, arr2, arr3])
12. print(arr)
13. #运行结果
14. [[1 2 3]
15. [1 2 3]
16. [1 2 3]
17. [4 5 6]
18. [4 5 6]
19. [4 5 6]
20. [7 8 9]
21. [7 8 9]
22. [7 8 9]]
24. arr = np.concatenate([arr1, arr2, arr3], axis=1)
25. print(arr)
26. #运行结果
27. [[1 2 3 4 5 6 7 8 9]
28. [1 2 3 4 5 6 7 8 9]
29. [1 2 3 4 5 6 7 8 9]]

复制代码

concatenate 函数用来拼接数组，默认是垂直方向拼接，设置 axis=1，按照水平方向拼接。
如果觉得记参数麻烦，记不住哪个是水平拼接，哪个是垂直拼接，还有两个专门拼接的函数，
vstack（垂直拼接）和hstack（水平拼接）。

1. arr = np.vstack([arr1, arr2, arr3])
2. print(arr)
3. #运行结果
4. [[1 2 3]
5. [1 2 3]
6. [1 2 3]
7. [4 5 6]
8. [4 5 6]
9. [4 5 6]
10. [7 8 9]
11. [7 8 9]
12. [7 8 9]]
14. arr = np.hstack([arr1, arr2, arr3])
15. print(arr)
16. #运行结果
17. [[1 2 3 4 5 6 7 8 9]
18. [1 2 3 4 5 6 7 8 9]
19. [1 2 3 4 5 6 7 8 9]]

复制代码

4.2. 拆分

拆分数组时，通过设置拆分点的下标，可以将数组拆分成任意长短的多个数组。
比如：

1. arr = np.array(range(1, 10))
2. arr1 = np.split(arr, [1, 5]) # 在下标 1 和 5 的地方拆分
3. print(arr1)
4. #运行结果
5. [array([1]), array([2, 3, 4, 5]), array([6, 7, 8, 9])]

复制代码

上面的示例中，下标1对应的值是2，下标5对应的值是6，
有2个拆分点，所以拆分成3个数组。
同样，数组的拆分也有2个简便的方法：vsplit和hsplit。
拆分多维数组时，可以按照垂直和水平两个方向拆分。

1. arr = np.array(range(1, 10)).reshape((3, 3))
2. print(arr)
3. #运行结果
4. [[1 2 3]
5. [4 5 6]
6. [7 8 9]]
8. print(np.vsplit(arr, [1]))
9. #运行结果
10. [array([[1, 2, 3]]),
11. array([[4, 5, 6],
12.        [7, 8, 9]])]
14. print(np.hsplit(arr, [1]))
15. #运行结果
16. [array([[1],
17.        [4],
18.        [7]]),
19. array([[2, 3],
20.        [5, 6],
21.        [8, 9]])]

复制代码

垂直拆分时，拆分点是下标1的行，也就是从第二行开始拆分。
水平拆分时，拆分点是下标1的列，也就是从第二列开始拆分。
超过二维的数组也可以 vsplit 和 hsplit，只是结果看上去没那么直观。
5. 总结回顾

本篇主要介绍的是numpy数组的基本操作，包括：

• 提取子数组
  
• 创建数组副本
  
• 数组变形
  
• 拼接和拆分
  

这些基本操作是进行实际的数值计算前经常会使用到的。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！