学numpy 这一篇就够用了

学 NumPy 前，先简单回答两个问题。

1.什么是 NumPy？

NumPy 是科学计算包。

2.NumPy 可以用来干什么？

NumPy 可以有效地存储和操作数值数组。并且相比于普通的 Python 列表，代码更少，运行速度更快。

概述

本文将分为两个部分：

第一部分是对 NumPy 数组的简单介绍，能让我们在学习之前有 numpy 数组的一个大致的轮廓。

第二部分是对 NumPy数组 的详细介绍。

Part 1： NumPy 数组介绍

每次我们要使用 NumPy库时都要进行导入（前提当然是 NumPy 已经下载安装好了）。导入的方法有多种，我们只需记住这最最常用的一种：

import numpy as np  # 这里可以翻译为：导入 NumPy 作为 np，可以理解为 NumPy 缩写为 np 了

现在我们已经成功导入了 NumPy 库了，让我们来创建第一个 NumPy 数组吧：

np.array([1, 2, 5, 8, 1])  # 使用 np.array() 创建一个 NumPy 数组

array([1, 2, 5, 8, 1])

接下来我们从下面几个方面来简单了解一下 NumPy 数组。

1. NumPy 数组是什么？

绝大多数情况下，NumPy 数组它就是一个数值类型的数组。

这个数组可以是一维的，例如：[3, 4, 8, 2] 或者 [3., 4.3, 5.]

也可以是二维的，例如：[[1, 8, 3], [8, 4, 6]] 或者 [[2., 3.4], [4.1, 5., 6.]]

还有更多维的，例如：[[[1, 2],[3, 8]], [[4, 3], [8, 1]]]

2. NumPy 数组的属性

对于一个 NumPy 数组，它有一些属性，比如 数据类型（dtype），表示数组里面的元素是整型的、浮点型的还是其他的。

3. 对单个 NumPy 数组的操作

对于一个 NumPy 数组,我们可以进行许多操作，比如 数组索引、 数组切片、 数组变形、 数组聚合、 数组排序、 数组分裂 等

下面我会依次介绍这些操作

拿一个数组作为例子，我们先创建一个 NumPy 数组（注意要使用 NumPy 库前要进行导入）：

x = np.array([1, 4, 2, 5, 0])

现在 x 是一个 NumPy 数组了。

（1）我们可以用 数组索引 获取数组里面的元素：

x[0] # 数组 x 的第一个元素（下标是从 0 开始的）

1

（2）我们可以用 数组切片 获取子数组：

切片，顾名思义，把数组的一部分切出来。

x[0:2] # 切出数组 x 的前两个元素

array([1, 4])

（3）我们可以对数组进行 变形 ：

x.reshape((5, 1)) # 将 x reshape（可以翻译为 重塑） 为 5 行 1 列的

array([[1],
       [4],
       [2],
       [5],
       [0]])

（4）我们可以将数组将数组进行 聚合 ：

聚合，顾名思义，我们可以把整个数组聚合成一个数。（也可以把一个二维数组的每一行或每一列聚合成一个数，变成一个一维数组）

print(x)   # 数组 x
print(np.sum(x))  # 将 x 中的元素都加起来
print(np.mean(x))   # 计算 x 中元素的平均值

[1 4 2 5 0]
12
2.4

（5）我们也可以把数组进行 排序 ：

print(x)           # 排序前
print(np.sort(x))  # 使用 np.sort() 进行排序后

[1 4 2 5 0]
[0 1 2 4 5]

（6）我们还可以把数组进行 分裂 ：

分裂，顾名思义，把一个数组分裂出来。（注意和切片进行区分，切片只是切出一部分）

x1, x2 = np.split(x, [2])   # 把原数组分为 x1 和 x2 两部分，你可以尝试着理解一下是怎么分的，下一部分我会详细说明
print(x1, x2)

[1 4] [2 5 0]

4. 对多个 NumPy 数组的操作

上面我们我们介绍了对单个数组的操作，接下来我们介绍多个数组间的操作。
NumPy 数组间的操作最典型的就是 数组间的计算 ，此外还有 数组的拼接 等

（1）数组间的 ** 计算 **

x = np.array([4, 8, 6, 9])
y = np.array([2.1, 5.3, 4.7, 1])
x + y

array([ 6.1, 13.3, 10.7, 10. ])

x + 2   # “2” 可以看成一个 0 维数组，这里 x 中的每个元素都会加上 2 。事实上，这是一个“广播”操作，之后会详细介绍

array([ 6, 10,  8, 11])

（2）数组的 拼接 ：
拼接，顾名思义，把两个或多个数组拼接在一起。

np.concatenate([x, y])   # 利用 np.concatenate（） 拼接 x 和 y

array([4. , 8. , 6. , 9. , 2.1, 5.3, 4.7, 1. ])

Part 2：NumPy 数组的详细介绍

1. 创建 NumPy 数组

1）利用 列表 和 np.array() 创建 NumPy 数组

L = [2, 3, 5]  # 创建一个 Python 列表 L
x = np.array(L)
y = np.array([3, 4, 6.1])
print(x)
print(y)

[2 3 5]
[3.  4.  6.1]

请记住，不同于 Python 列表，NumPy 要求数组必须同一类型。如果类型不匹配，NumPy 会自动向上转换。

# 整型自动转换为浮点型：
x = np.array([2, 5.3, 2, 10])
x

array([ 2. ,  5.3,  2. , 10. ])

2）利用 np.arange() 创建一个线性序列数组

np.arange() 的参数依次是 start、stop、step

# start=0，stop=20，step=2
# 意思是 从 0 开始，到 20 结束，步长为 2
# 注意，输出是不会有 20(stop) 的
x = np.arange(0, 20, 2)
x

array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

注意，使用 np.arange() 函数时输入的参数可以是 一个、两个或者三个。

①一个参数时，参数值为stop，start取默认值0，step取默认值1

a1 = np.arange(5)
a2 = np.arange(10)
print(a1)
print(a2)

[0 1 2 3 4]
[0 1 2 3 4 5 6 7 8 9]

②两个参数时，第一个参数为start、第二个参数为stop，step取默认值1

b1 = np.arange(2, 4)
b2 = np.arange(3, 7)
print(b1)
print(b2)

[2 3]
[3 4 5 6]

③三个参数时，第一个参数为start、第二个参数为stop、第三个参数为step

c1 = np.arange(1, 5, 1)
c2 = np.arange(5, 1, -1)   # step为负数时，你尝试从答案理解一下
c3 = np.arange(5, 1, -2)
print(c1)
print(c2)
print(c3)

[1 2 3 4]
[5 4 3 2]
[5 3]

3）创建随机数数组

①np.random.randint()

# 创建一个 3×3 的、[0, 10) 区间的随机整型数组
np.random.randint(0, 10, (3, 3))

array([[4, 3, 6],
       [8, 2, 5],
       [8, 4, 0]])

②np.random.random()

# 创建一个 3×3的、在0 ~ 1 之间的随机数组成的数组
np.random.random((3, 3))

array([[0.3404152 , 0.55781784, 0.61522996],
       [0.68567632, 0.73912314, 0.6967783 ],
       [0.76376602, 0.94942223, 0.986581  ]])

③np.random.normal()

# 创建一个 2×2的、均值为 0，标准差为 1 的
# 正态分布的随机数数组
np.random.normal(0, 1, (2, 2))

array([[1.32345339, 1.57178262],
       [0.72432636, 1.34134081]])

4）利用 np.linspace() 创建 NumPy 数组

# 创建一个 5 个元素的数组，这 5 个数均匀地分配到 0 ~ 1
a = np.linspace(0, 1, 5)

# 创建一个 3 个元素的数组，这 3 个数均匀地分配到 1 ~ 5
b = np.linspace(1, 5, 3)

print(a)
print(b)

[0.   0.25 0.5  0.75 1.  ]
[1. 3. 5.]

5）利用 NumPy 内置方法 创建特殊矩阵

# 创建一个长度为 10 的数组，数组的值都是 0 （整型）
x = np.zeros(10, dtype=int)
x

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

# 创建一个长度为 3×4 的浮点型数组，数组的值都是 1
x = np.ones((3, 4), dtype=float)
x

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

# 创建一个 3×5 的数组，数组的值都是 8
x = np.full((3, 5), 8)
x

array([[8, 8, 8, 8, 8],
       [8, 8, 8, 8, 8],
       [8, 8, 8, 8, 8]])

# 创建一个 3×3 的单位矩阵
x = np.eye(3)
x

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

# 创建一个由 3 个整型数组成的未初始化的数组
# 数组的值都是内存空间中的任意值
np.empty(3)

array([1., 1., 1.])

2. NumPy 数组的属性

numpy 比较常用的属性是：shape (数组每个维度的大小)

# 先利用前面介绍过的 np.random.randint() 方法创建一个 3×4的、 [0, 10) 区间的随机整型数组
x = np.random.randint