Python NumPy 的学习笔记

0. 引言

Numpy 是 Python 中一个非常强大的库，它让我们可以高效地操作大量的数据。想象一下，如果你有一个超级大的数字列表，而你需要对这些数字进行各种复杂的计算，Numpy 就是你的超级英雄！

1. 为什么要用 Numpy

• 速度：Numpy 使用了 C 语言的部分代码，这让它运行得非常快。
• 功能多：Numpy 提供了很多数学函数，让复杂的数学计算变得简单。
• 省空间：Numpy 使用的是数组（array），比 Python 自带的列表（list）更节省空间。

2. 创建 Numpy 数组

想象一下，你有很多颗糖果要放进不同的盒子里，Numpy 数组就像是那些盒子，而糖果就是数据。这些盒子非常特别，因为它们可以非常快地帮你数出里面有多少颗糖果，甚至还可以快速告诉你哪些盒子的糖果比较甜！

import numpy as np

# 创建一个简单的数组
arr = np.array([1, 2, 3])
print(arr)
1
2
3
4
5

这就像是你有一个盒子，你把 1、2、3 这三颗糖果放进去。

3. 数组的形状

# 创建一个 2x3 的二维数组
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr_2d.shape)  # 输出: (2, 3)
1
2
3

这就像是你有一个大盒子，里面有两个小盒子，每个小盒子里都有三颗糖果。

4. 基础操作

4-1. 数组加法

# 创建两个数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

# 数组加法
result = arr1 + arr2
print(result)  # 输出: [5 7 9]
1
2
3
4
5
6
7

这就像是你有两个盒子，一个盒子里的糖果分别是 1、2、3，另一个是 4、5、6。现在你把它们一一对应加起来，就会得到新的盒子，里面的糖果是 5、7、9。

4-2. 数组的广播

广播是 Numpy 的一个强大功能，它让你可以用不同大小的盒子（数组）进行计算。

# 创建一个数组
arr = np.array([1, 2, 3])

# 数组与单个数字的加法
result = arr + 2
print(result)  # 输出: [3 4 5]
1
2
3
4
5
6

这就像是你有一个盒子里的糖果分别是 1、2、3，现在你决定每颗糖果都再加两颗糖果，那么盒子里的糖果就变成了 3、4、5。

再举一个示例，

# 创建一个数组
arr = np.array([1, 2, 3])

# 用一个小盒子（单个值）与大盒子（数组）进行计算
print(arr * 2)  # 输出: [2 4 6]
1
2
3
4
5

这就像是你决定每颗糖果都变成双倍大！

4-3. 数组的索引和切片

想象一下，你的糖果盒子里分了很多格，每一格都有一个编号。你可以很容易地找到任何一格里的糖果，也可以取出一部分糖果来品尝。

# 创建一个一维数组
arr = np.array([10, 20, 30, 40, 50])

# 索引：获取第三个元素
print(arr[2])  # 输出: 30

# 切片：获取第二到第四个元素
print(arr[1:4])  # 输出: [20 30 40]
1
2
3
4
5
6
7
8

这就像是你直接找到第三格的糖果，或者一次取出第二格到第四格的糖果来尝尝。

4-4. 数组形状变换

如果你想要重新组织你的糖果盒子，比如，把它们从一排变成一个矩阵，Numpy 也能帮你轻松做到。

# 创建一个一维数组
arr = np.arange(6)  # [0 1 2 3 4 5]

# 重新组织成 2x3 的数组
arr_reshape = arr.reshape(2, 3)
print(arr_reshape)
1
2
3
4
5
6

这就像是你把 6 颗糖果重新分配到了一个有两行三列的盒子里。

4-5. 数组的数学操作

Numpy 可以让你对整个糖果盒子进行数学操作，而不是一颗一颗地算。

# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])

# 计算所有糖果的总和
print(np.sum(arr))  # 输出: 15

# 计算糖果的平均数
print(np.mean(arr))  # 输出: 3.0
1
2
3
4
5
6
7
8

这就像是你不需要数每一颗糖果就能知道盒子里糖果的总数和平均甜度。

4-6. 布尔索引

假设你只想要那些特别甜的糖果，Numpy 可以帮你找出来。

# 创建一个数组
arr = np.array([10, 20, 30, 40, 50])

# 找出大于 25 的糖果
print(arr[arr > 25])  # 输出: [30 40 50]
1
2
3
4
5

这就像是你有一个魔法筛子，能筛出超级甜的糖果。

4-7. 数组的转置 (Transpose)

想象一下，你有一个盒子，里面的糖果是按行和列排列的。如果你想把行变成列，列变成行，这就是转置的魔法。

# 创建一个 2x3 的数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("原始数组:")
print(arr)

# 使用转置
print("转置后的数组:")
print(arr.T)
1
2
3
4
5
6
7
8

这就像是你把盒子旋转了一下，让里面的糖果排列方式完全变了个样。

4-8. 数组的平迭

NumPy 的 ravel() 和 flatten() 函数所要实现的功能是一致的，都是将多维数组降为一维数组。两者的区别在于返回拷贝(copy)还是返回视图(view)，numpy.flatten()返回一份拷贝，对拷贝所做的修改不会影响原始矩阵，而numpy.ravel()返回的是视图，会影响原始矩阵。

4-8-1. flatten()

flatten() 方法可以将你的糖果盒子（不管它有多少层）压扁，变成一个一维数组，这样所有的糖果都会排成一行。

# 创建一个 2x3 的数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("原始数组:")
print(arr)

# 使用 flatten
flattened_arr = arr.flatten()
print("压扁后的数组:")
print(flattened_arr)
1
2
3
4
5
6
7
8
9

这就像是你把盒子里的所有糖果都倒出来，排成一长排。

4-8-2. ravel()

ravel() 方法和 flatten() 很像，也是把多维数组变成一维，但它的工作方式略有不同。ravel() 尽可能地不创建数据的副本，所以它在某些情况下比 flatten() 更高效。

# 创建一个 2x3 的数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("原始数组:")
print(arr)

# 使用 ravel
ravelled_arr = arr.ravel()
print("展平后的数组:")
print(ravelled_arr)
1
2
3
4
5
6
7
8
9

这就像是你把所有糖果从盒子里拿出来铺平，但尽量不去动它们，让它们保持原来的顺序。

4-9. 数组的排序

我们将学习如何整理和排序我们的糖果盒子，使用sort()和argsort()方法，以及如何通过axis参数来控制我们排序的维度。

4-9-1. sort()

想象你有一个盒子，里面的糖果乱七八糟地放着。如果你想把它们按照甜度从小到大排序，这就是sort()方法的用武之地。

# 创建一个一维数组
arr = np.array([5, 3, 1, 4, 2])
print("原始数组:")
print(arr)

# 对数组进行排序
sorted_arr = np.sort(arr)
print("排序后的数组:")
print(sorted_arr)
1
2
3
4
5
6
7
8
9

这就像是你把盒子里的糖果按照大小顺序重新排列了一遍。

如果你的糖果盒子有多层（即多维数组），你可以用axis参数来指定你想按哪个方向排序。

# 创建一个 2x3 的数组
arr_2d = np.array([[5, 2, 3], [1, 4, 6]])
print("原始数组:")
print(arr_2d)

# 沿着每一行进行排序
print("沿行排序后:")
print(np.sort(arr_2d, axis=1))

# 沿着每一列进行排序
print("沿列排序后:")
print(np.sort(arr_2d, axis=0))
1
2
3
4
5
6
7
8
9
10
11
12

这就像是你决定先按糖果的颜色排序，然后又改变主意按糖果的大小排序。

4-9-2. argsort()

argsort()方法有点特别，它不直接对糖果进行排序，而是告诉你如果想要排序，糖果的编号应该怎样排列。

# 创建一个一维数组
arr = np.array([5, 3, 1, 4, 2])
print("原始数组:")
print(arr)

# 使用 argsort
sorted_indices = np.argsort(arr)
print("排序后的索引:")
print(sorted_indices)

# 使用排序后的索引来排序
print("使用索引排序后的数组:")
print(arr[sorted_indices])
1
2
3
4
5
6
7
8
9
10
11
12
13

这就像是你得到了一张纸，上面写着如果想把糖果按甜度排序，应该怎么放它们。

如果你想在多维数组中使用argsort()，你也可以利用axis参数。

# 创建一个 2x3 的数组
arr_2d = np.array([[5, 2, 3], [1, 4, 6]])
print("原始数组:")
print(arr_2d)

# 沿着每一列使用 argsort
column_indices = np.argsort(arr_2d, axis=0)
print("沿列排序后的索引:")
print(column_indices)

# 沿着每一行使用 argsort
row_indices = np.argsort(arr_2d, axis=1)
print("沿行排序后的索引:")
print(row_indices)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这就像是你得到了一张更复杂的纸，上面告诉你如果想按不同的方式排序糖果，它们的编号应该怎样排列。

4-10. 数组的组合

有时我们会有许多糖果盒子，我们可能想要把它们堆叠起来或者连接起来，以便更好地管理。Numpy为我们提供了几种方法来做到这一点：hstack()、vstack()、concatenate()和append()。让我们来看看它们是如何工作的，包括如何使用axis参数来控制操作的方向。

4-10-1. hstack()

hstack()，或称为"horizontal stack"（水平堆叠），让你可以把多个数组水平地连接起来。这种方式特别适合当你想要扩展你的糖果集合，把更多的糖果并排放在一起。

# 创建两个一维数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print("原始数组1:")
print(arr1)
print("原始数组2:")
print(arr2)

# 水平堆叠
hstack_arr = np.hstack((arr1, arr2))
print("水平堆叠后:")
print(hstack_arr)
1
2
3
4
5
6
7
8
9
10
11
12

这就像是你把两盒糖果并排放置，现在它们组成了一个更大的糖果展示。

如果你的糖果盒子是多维的，hstack()依然能够工作，把它们水平地连接起来。

# 创建两个二维数组
arr1_2d = np.array([[1, 2, 3], [7, 8, 9]])
arr2_2d = np.array([[4, 5, 6], [10, 11, 12]])
print("原始二维数组1:")
print(arr1_2d)
print("原始二维数组2:")
print(arr2_2d)

# 水平堆叠二维数组
hstack_arr_2d = np.hstack((arr1_2d, arr2_2d))
print("水平堆叠后的二维数组:")
print(hstack_arr_2d)
1
2
3
4
5
6
7
8
9
10
11
12

这就像是你把两个双层糖果盒子并排放置，使每层都更宽了。

通过hstack()，我们可以轻松地将不同的糖果盒子水平连接起来，无论是简单的一维数组还是更复杂的多维数组。

4-10-2. vstack()

vstack()是"vertical stack"（垂直堆叠）的缩写。想象你有几盒糖果，你想把它们堆叠起来，一盒放在另一盒的上面。

# 创建两个一维数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print("原始数组1:")
print(arr1)
print("原始数组2:")
print(arr2)

# 垂直堆叠
vstack_arr = np.vstack((arr1, arr2))
print("垂直堆叠后:")
print(vstack_arr)
1
2
3
4
5
6
7
8
9
10
11
12

这就像是你把两盒糖果叠在一起，现在它们变成了一个两层的大盒子。

4-10-3. concatenate()

concatenate()方法可以让你选择是水平连接还是垂直连接数组。通过axis参数，你可以控制连接的方向：axis=0代表垂直连接，而axis=1代表水平连接。

# 创建两个一维数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

# 垂直连接
concat_arr_v = np.concatenate((arr1, arr2), axis=0)
print("垂直连接后:")
print(concat_arr_v)

# 如果是二维数组，我们可以水平连接它们
arr1_2d = np.array([[1, 2, 3]])
arr2_2d = np.array([[4, 5, 6]])
concat_arr_h = np.concatenate((arr1_2d, arr2_2d), axis=1)
print("水平连接后:")
print(concat_arr_h)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这就像是你可以选择把两盒糖果放在一起变成一盒，或者把它们并排放置。

4-10-4. append()

append()方法可以将值添加到数组的末尾。默认情况下，它会将所有输入平铺成一维数组，但你也可以通过axis参数来指定添加的方向。

# 创建一个一维数组
arr = np.array([1, 2, 3])
print("原始数组:")
print(arr)

# 添加元素
append_arr = np.append(arr, [4, 5, 6])
print("添加元素后:")
print(append_arr)

# 创建两个二维数组
arr_2d_1 = np.array([[1, 2, 3]])
arr_2d_2 = np.array([[4, 5, 6]])

# 垂直添加
append_arr_2d_v = np.append(arr_2d_1, arr_2d_2, axis=0)
print("垂直添加后:")
print(append_arr_2d_v)

# 注意：对于二维数组，append不支持axis=1的直接操作，需要使用其他方法如concatenate来实现水平添加。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这就像是你可以决定把新的糖果放在盒子的底部，或者旁边，根据你想要的方式来扩展糖果盒子。

完结！