---

通过 pip 安装和学习 NumPy：一篇入门指南

引言：开启数值计算之旅

在现代科学、工程、数据分析以及人工智能领域，数值计算扮演着核心角色。无论是处理大型数据集、进行复杂的数学运算，还是构建机器学习模型，高效且便捷的数值计算能力都不可或缺。而 Python，凭借其易学性和强大的生态系统，已成为许多专业人士的首选语言。

在 Python 的数值计算生态中，NumPy（Numerical Python 的简称）库无疑是基石般的存在。它提供了高性能的多维数组对象以及用于处理这些数组的工具，极大地提高了 Python 在数值计算方面的效率和表现力。几乎所有基于 Python 的数据科学和机器学习库（如 Pandas、SciPy、Matplotlib、Scikit-learn、TensorFlow、PyTorch 等）都构建在 NumPy 的基础上，或与 NumPy 数组紧密集成。因此，掌握 NumPy 是深入学习 Python 数据科学领域的必经之路。

本篇文章旨在为完全的新手或对 NumPy 感到陌生的读者提供一份详尽的入门指南。我们将从最基础的环境准备开始，详细讲解如何使用 Python 的标准包管理工具 pip 来安装 NumPy，然后逐步深入，介绍 NumPy 的核心概念——多维数组（ndarray），并通过丰富的代码示例，带领读者了解数组的创建、索引、切片、基本数学运算以及一些常用的功能。无论你的最终目标是数据分析、机器学习还是科学研究，这篇指南都将为你打下坚实的NumPy基础。

本文将涵盖以下主要内容：

1. 环境准备：确保你拥有 Python 环境和 pip 包管理器。
2. 安装 NumPy：使用 pip 进行 NumPy 的标准安装，并介绍虚拟环境的最佳实践。
3. 验证安装：确认 NumPy 已成功安装并可以正常导入使用。
4. NumPy 核心概念：理解 NumPy 数组（ndarray）及其优势。
5. NumPy 数组基础操作：学习如何创建、访问、修改和操作 NumPy 数组。
6. 常用 NumPy 功能：介绍一些在数据处理中常用的函数和技术。
7. 继续学习资源：指引你进一步深入学习 NumPy 的方向。

让我们正式开始 NumPy 的学习之旅吧！

第一步：环境准备——Python 与 pip

在安装 NumPy 之前，你需要确保你的计算机上已经安装了 Python 及其配套的包管理工具 pip。目前，推荐使用 Python 3.6 或更高版本，因为旧版本的 Python 可能不再受支持，并且在安装某些最新的库时会遇到问题。

什么是 pip？

pip 是 Python 的官方推荐的包安装工具。你可以把它想象成一个应用商店，通过它，你可以轻松地从 Python Package Index (PyPI) 这个在线仓库下载、安装、升级和管理 Python 软件包（比如 NumPy）。使用 pip 安装库非常简单，通常只需要一个命令。

如何安装 Python 和 pip？

对于大多数现代操作系统（Windows, macOS, Linux），安装 Python 的方式略有不同：

1. Windows:

   • 访问 Python 官方网站 https://www.python.org/downloads/。
   • 下载最新的 Python 3.x 安装程序（推荐使用 64位版本）。
   • 运行下载的安装程序。非常重要的一步是，在安装过程中，确保勾选 “Add Python to PATH” 选项。 这会将 Python 和 pip 的执行路径添加到系统的环境变量中，让你可以在任何命令行窗口中直接使用 python 和 pip 命令。
   • 按照安装向导完成安装。

2. macOS:

   • macOS 通常预装了 Python，但可能是旧版本（Python 2.x）。为了使用最新的 NumPy 和其他库，强烈建议安装最新的 Python 3.x。
   • 可以通过官方网站下载安装程序，方法类似 Windows。
   • 或者，更推荐使用 Homebrew 这个包管理器：
     • 如果未安装 Homebrew，请访问 https://brew.sh/ 按照指引安装。
     • 打开终端，运行命令 brew install python。这会安装最新版本的 Python 3，并会自动设置好 pip。

3. Linux:

   • 大多数 Linux 发行版都预装了 Python，但同样建议安装最新的 Python 3.x。
   • 可以使用系统的包管理器进行安装（例如，Debian/Ubuntu 使用 apt，Fedora 使用 dnf，CentOS/RHEL 使用 yum）。
     • 例如，在 Ubuntu/Debian 上打开终端，运行 sudo apt update 然后 sudo apt install python3 python3-pip。
   • 或者，也可以从官方网站下载源码编译安装，但这对于新手来说可能过于复杂，不在此赘述。

验证 Python 和 pip 安装

安装完成后，打开你的命令行终端（在 Windows 上是 Command Prompt 或 PowerShell，在 macOS 和 Linux 上是 Terminal），输入以下命令并回车：

bash
python --version

或者，如果你安装的是 Python 3，可能需要使用 python3 命令：

bash
python3 --version

你应该会看到类似 Python 3.9.7 这样的输出，显示你安装的 Python 版本号。

接着，验证 pip 是否可用：

bash
pip --version

或者：

bash
pip3 --version

你应该会看到类似 pip 21.2.4 from ... 这样的输出，显示 pip 的版本号及其安装路径。

如果这两个命令都能正确显示版本信息，恭喜你，你的环境已经准备好了！如果命令无效，请检查之前的安装步骤，特别是是否将 Python 添加到了 PATH 环境变量中。

第二步：安装 NumPy——使用 pip

环境准备就绪后，安装 NumPy 就变得非常简单。只需打开你的命令行终端，运行以下命令：

bash
pip install numpy

或者，如果你的系统同时有 Python 2 和 Python 3，并且 pip 命令默认指向 Python 2，你需要明确指定使用 Python 3 的 pip：

bash
pip3 install numpy

这个命令会做几件事情：

1. pip 会连接到 PyPI（Python Package Index）。
2. 它会搜索名为 numpy 的软件包。
3. 找到后，它会下载最新稳定版本的 NumPy 及其所有必要的依赖项（尽管 NumPy 本身依赖项很少）。
4. 下载完成后，pip 会自动将 NumPy 安装到你的 Python 环境的 site-packages 目录中，使得你可以在 Python 代码中导入和使用它。

安装过程会显示下载和安装的进度，最终如果安装成功，你会看到类似 “Successfully installed numpy-x.y.z” 的提示信息，其中 x.y.z 是 NumPy 的版本号。

更新 NumPy

NumPy 会不断发布新版本，包含性能优化、新功能或 bug 修复。如果你想更新已安装的 NumPy 到最新版本，可以使用 --upgrade 标志：

bash
pip install --upgrade numpy

或者

bash
pip3 install --upgrade numpy

这个命令会检查当前安装的 NumPy 版本，如果 PyPI 上有新的版本，就会下载并安装新的版本，替换旧的。

最佳实践：使用虚拟环境

虽然你可以直接将 NumPy 安装到系统全局的 Python 环境中，但这并不是最佳实践，尤其当你开始进行多个 Python 项目时。不同项目可能需要不同版本的同一个库，或者安装不同的库组合。将所有库都安装到全局环境很容易导致版本冲突和依赖性问题。

解决这个问题的标准方法是使用虚拟环境（Virtual Environment）。虚拟环境是一个独立于系统全局 Python 环境的目录，它包含了自己独立的 Python 解释器副本和 pip，以及一个空的 site-packages 目录。你在虚拟环境中安装的所有库都只会存在于这个环境中，不会影响到全局环境或其他虚拟环境。

创建和使用虚拟环境的步骤如下：

1. 创建虚拟环境： 在你想要创建项目的目录中打开命令行终端，运行以下命令（myenv 是你给虚拟环境命名的文件夹名称，可以替换为任何你喜欢的名字）：

   bash
python -m venv myenv

   或者

   bash
python3 -m venv myenv

   这会在当前目录下创建一个名为 myenv 的文件夹，里面包含了新的 Python 环境。

2. 激活虚拟环境： 在安装库之前，你需要“激活”这个虚拟环境。激活后，你在命令行中使用的 python 和 pip 命令就会指向虚拟环境中的解释器和 pip。

   • 在 Windows 上：

     bash
myenv\Scripts\activate

   • 在 macOS 和 Linux 上：

     bash
source myenv/bin/activate

   激活成功后，你的命令行提示符前会显示虚拟环境的名称（例如 (myenv)），表示你当前正在这个环境中工作。

3. 在虚拟环境中安装 NumPy： 确保虚拟环境已激活，然后像前面一样使用 pip 命令安装 NumPy：

   bash
pip install numpy

   或

   bash
pip install --upgrade numpy

   现在，NumPy 就只会安装到 myenv 这个虚拟环境中了。

4. 退出虚拟环境： 当你完成工作，想要回到系统全局环境时，只需运行：

   bash
deactivate

   命令行提示符前的虚拟环境名称会消失。

强烈建议你在进行任何 Python 项目（包括学习 NumPy）时都使用虚拟环境。 这将使你的开发环境更加整洁、易于管理和避免冲突。

第三步：验证安装——导入 NumPy

NumPy 安装完成后，最简单的验证方法就是在 Python 环境中尝试导入它。

打开命令行终端，如果你在虚拟环境中安装的 NumPy，请先激活该环境。然后输入 python 或 python3 进入 Python 交互式解释器：

bash
python

或者

bash
python3

进入 Python 提示符 >>> 后，输入以下代码：

python
import numpy as np

这行代码是导入 NumPy 库的标准做法，并将其别名为 np。几乎所有使用 NumPy 的代码都会使用这个别名。

如果这一行代码执行后没有报错，说明 NumPy 已经成功安装并且可以被你的 Python 环境访问到。

你还可以进一步检查安装的 NumPy 版本：

python
print(np.__version__)

这会打印出当前安装的 NumPy 版本号。

如果你想进一步确认 NumPy 的功能是否正常，可以尝试创建一个简单的 NumPy 数组：

python
a = np.array([1, 2, 3, 4, 5])
print(a)

如果输出是 [1 2 3 4 5]，那么恭喜你，NumPy 已经完全准备就绪，可以开始学习它的强大功能了！

如果在导入 NumPy 时出现 ModuleNotFoundError: No module named 'numpy' 错误，这意味着 Python 解释器无法找到安装的 NumPy 库。请回顾之前的安装步骤，确认：
* 你是在正确的 Python 环境下安装的 NumPy（特别是当你使用虚拟环境时）。
* 你的 pip 命令指向了你想要安装 NumPy 的 Python 环境。
* 安装过程中没有出现错误。

第四步：NumPy 核心概念——多维数组 (ndarray)

NumPy 的核心是 ndarray（N-dimensional array object），即 N 维数组对象。与 Python 原生的列表（List）不同，NumPy 数组有以下几个显著特点和优势：

1. 同质性（Homogeneous）：NumPy 数组中的所有元素必须是相同的数据类型（如整数、浮点数、布尔值等）。这一点与 Python 列表可以存储不同类型的元素不同。同质性是 NumPy 实现高性能的基础，因为它可以更紧密地在内存中存储数据，并利用底层的 C 或 Fortran 代码进行批量运算。
2. 高性能：NumPy 的许多操作都在底层用 C 或 Fortran 实现，这使得它在处理大量数据时比纯 Python 代码（如对列表进行循环操作）快得多。
3. 内存效率：NumPy 数组通常比 Python 列表占用更少的内存，尤其对于存储大量数值数据时。
4. 丰富的函数库：NumPy 提供了大量针对数组操作的数学函数和通用函数，这些函数经过高度优化，可以直接作用于整个数组，避免了手动编写循环，这被称为“向量化”操作，是使用 NumPy 的关键技巧。

可以将 NumPy 数组视为一个固定大小的多维容器，其中所有元素都是相同类型的。一维数组就像一个向量，二维数组就像一个矩阵，三维数组就像一个张量，以此类推。

第五步：NumPy 数组基础操作

理解了 ndarray 是 NumPy 的核心后，接下来我们将学习如何创建、访问和操作这些数组。

5.1 创建 NumPy 数组

创建 NumPy 数组的最基本方法是使用 np.array() 函数，将 Python 列表或元组作为参数传入。

“`python
import numpy as np

从列表创建一维数组 (向量)

a = np.array([1, 2, 3, 4, 5])
print(“一维数组 a:”)
print(a)
print(“数组类型:”, type(a))
print(“数组维度:”, a.ndim) # 维度数量
print(“数组形状:”, a.shape) # 各维度的大小 (行, 列, …)
print(“数组元素数量:”, a.size)
print(“元素数据类型:”, a.dtype) # 元素的数据类型

从嵌套列表创建二维数组 (矩阵)

b = np.array([[1, 2, 3], [4, 5, 6]])
print(“\n二维数组 b:”)
print(b)
print(“数组维度:”, b.ndim)
print(“数组形状:”, b.shape) # (行数, 列数)
print(“数组元素数量:”, b.size)
print(“元素数据类型:”, b.dtype)

从嵌套元组创建三维数组

c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(“\n三维数组 c:”)
print(c)
print(“数组维度:”, c.ndim)
print(“数组形状:”, c.shape) # (层数, 行数, 列数)
print(“数组元素数量:”, c.size)
print(“元素数据类型:”, c.dtype)
“`

指定数据类型 (dtype)

你可以在创建数组时通过 dtype 参数指定元素的数据类型。NumPy 支持多种数据类型，如 int32, int64, float32, float64, bool, complex, 等。

python
d = np.array([1, 2, 3], dtype=np.float64)
print("\n指定数据类型的数组 d:")
print(d)
print("元素数据类型:", d.dtype)

使用内置函数创建数组

NumPy 提供了许多方便的函数来创建特定类型的数组：

• np.zeros(shape): 创建指定形状，元素全为 0 的数组。
• np.ones(shape): 创建指定形状，元素全为 1 的数组。
• np.empty(shape): 创建指定形状，元素为随机（取决于内存状态）的数组，创建速度最快，但需要后续赋值。
• np.arange(start, stop, step): 类似于 Python 的 range()，但返回 NumPy 数组。
• np.linspace(start, stop, num): 创建在指定区间内均匀分布的 num 个元素的数组。
• np.full(shape, fill_value): 创建指定形状，元素全为 fill_value 的数组。
• np.eye(N) 或 np.identity(N): 创建 N×N 的单位矩阵（对角线为 1，其余为 0）。

python
print("\n使用内置函数创建数组:")
print("全零矩阵:\n", np.zeros((2, 3))) # 2行3列的全零矩阵
print("全一矩阵:\n", np.ones((3, 2), dtype=np.int64)) # 3行2列的全一矩阵，指定整数类型
print("空矩阵 (内容随机):\n", np.empty((2, 2)))
print("arange (0到9的整数):\n", np.arange(10))
print("arange (1到9，步长为2):\n", np.arange(1, 10, 2))
print("linspace (0到1，10个点):\n", np.linspace(0, 1, 10))
print("full (3x3，填充值7):\n", np.full((3, 3), 7))
print("单位矩阵 (4x4):\n", np.eye(4))

5.2 数组索引与切片

NumPy 数组的索引和切片功能非常强大和灵活，与 Python 列表类似，但可以扩展到多个维度。

• 基本索引 (Basic Indexing)：使用方括号 [] 和整数索引来访问单个元素。对于多维数组，使用逗号 , 分隔每个维度的索引。

  “`python
  arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
  print(“\n原始数组 arr:\n”, arr)

  print(“访问元素 (0行1列):”, arr[0, 1]) # 输出 2
  print(“访问元素 (2行2列):”, arr[2, 2]) # 输出 9
  “`

• 切片 (Slicing)：使用冒号 : 来指定范围，语法是 start:stop:step（stop 不包含）。同样，对于多维数组，使用逗号 , 分隔每个维度的切片。

  “`python
  print(“切片 (所有行, 0到2列):\n”, arr[:, 0:2]) # 输出 [[1 2], [4 5], [7 8]]
  print(“切片 (0到2行, 所有列):\n”, arr[0:2, :]) # 输出 [[1 2 3], [4 5 6]]
  print(“切片 (1到3行, 1到3列):\n”, arr[1:3, 1:3]) # 输出 [[5 6], [8 9]]
  print(“切片 (第一列):\n”, arr[:, 0]) # 输出 [1 4 7] (注意：这是一个一维数组，不是列向量)
  print(“切片 (第一行):\n”, arr[0, :]) # 输出 [1 2 3] (也是一维数组)

  使用步长切片

  print(“切片 (所有行, 隔一列):\n”, arr[:, ::2]) # 输出 [[1 3], [4 6], [7 9]]
  “`

  重要提示：NumPy 数组的切片不是原始数组的副本，而是其视图（view）。修改切片会同时修改原始数组。

  python
arr_slice = arr[0:2, 0:2]
print("\n切片视图 arr_slice:\n", arr_slice)
arr_slice[0, 0] = 100 # 修改切片视图的第一个元素
print("修改切片后 原始数组 arr:\n", arr) # 原始数组也发生了变化
  如果你需要一个独立的副本，可以使用 .copy() 方法：arr_copy = arr[0:2, 0:2].copy()。

• 布尔索引 (Boolean Indexing)：使用一个布尔数组来选择元素。布尔数组的形状必须与被索引的数组相同或可广播。

  “`python
  data = np.array([10, 20, 30, 40, 50, 60])
  mask = data > 30 # 创建一个布尔数组 [False False False True True True]
  print(“\n布尔索引 mask:”, mask)
  print(“使用布尔索引选择元素:”, data[mask]) # 输出 [40 50 60]

  结合条件筛选

  print(“选择大于30的元素:”, data[data > 30])
  print(“选择偶数元素:”, data[data % 2 == 0])
  “`

• 花式索引 (Fancy Indexing)：使用一个整数数组或列表来选择元素。

  “`python
  fancy_arr = np.array([10, 20, 30, 40, 50])
  indices = [0, 2, 4] # 使用索引列表
  print(“\n花式索引选择元素:”, fancy_arr[indices]) # 输出 [10 30 50]

  对于多维数组，可以同时使用多个索引数组

  multi_dim_arr = np.array([[1, 2], [3, 4], [5, 6]])
  rows = np.array([0, 1, 2])
  cols = np.array([0, 1, 0]) # 选择 (0,0), (1,1), (2,0) 这三个元素
  print(“多维花式索引选择元素:”, multi_dim_arr[rows, cols]) # 输出 [1 4 5]
  “`

5.3 基本数学运算和通用函数 (ufuncs)

NumPy 最强大的功能之一是其对数组的向量化操作。基本算术运算符（+, -, *, /, ** 等）和许多数学函数都可以直接应用于整个数组，执行元素级别的运算。

“`python
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

print(“\n数组算术运算:”)
print(“arr1 + arr2 =”, arr1 + arr2) # [5 7 9]
print(“arr1 – arr2 =”, arr1 – arr2) # [-3 -3 -3]
print(“arr1 * arr2 =”, arr1 * arr2) # [4 10 18] (元素乘法，不是矩阵乘法)
print(“arr1 / arr2 =”, arr1 / arr2) # [0.25 0.4 0.5 ] (浮点数除法)
print(“arr1 ** 2 =”, arr1 ** 2) # [1 4 9] (元素平方)

比较运算符也返回布尔数组

print(“arr1 > arr2 =”, arr1 > arr2) # [False False False]
print(“arr1 == arr1 =”, arr1 == arr1) # [ True True True]
“`

通用函数 (Universal Functions – ufuncs)

NumPy 提供了大量的数学函数，这些函数被设计为能够快速地对 ndarray 中的每个元素进行操作。这些函数被称为“通用函数”或 ufuncs。

python
arr = np.array([0, np.pi/2, np.pi]) # 使用 np.pi
print("\n通用函数 (ufuncs):")
print("np.sin(arr) =", np.sin(arr)) # [0. 1. 0.00000000e+00] (近似于0)
print("np.cos(arr) =", np.cos(arr)) # [ 1.00000000e+00 6.12323400e-17 -1.00000000e+00] (近似于0和-1)
print("np.sqrt(arr) =", np.sqrt(arr)) # [0. 1.25331414 1.77245385]
print("np.exp(arr) =", np.exp(arr)) # [ 1. 4.81047738 23.14069263]
还有许多其他 ufuncs，如 np.log(), np.abs(), np.ceil(), np.floor(), np.round() 等等。

5.4 聚合函数

NumPy 提供了用于计算数组聚合值的函数，如求和、平均值、最小值、最大值、标准差等。

“`python
arr = np.array([[1, 2, 3], [4, 5, 6]])

print(“\n聚合函数:”)
print(“所有元素的总和:”, np.sum(arr)) # 输出 21
print(“所有元素的平均值:”, np.mean(arr)) # 输出 3.5
print(“所有元素的最小值:”, np.min(arr)) # 输出 1
print(“所有元素的最大值:”, np.max(arr)) # 输出 6
print(“所有元素的标准差:”, np.std(arr)) # 输出 1.7078…
print(“所有元素的方差:”, np.var(arr)) # 输出 2.9166…
“`

这些聚合函数通常有一个重要的参数 axis。axis 参数指定了进行聚合运算的维度。
* axis=0: 沿着列进行运算（对每一列的元素进行聚合）。
* axis=1: 沿着行进行运算（对每一行的元素进行聚合）。
* 没有 axis 参数或 axis=None: 对所有元素进行聚合。

“`python
print(“\n聚合函数与 axis 参数:”)
print(“沿着列求和 (axis=0):”, np.sum(arr, axis=0)) # 输出 [5 7 9] (第一列的和，第二列的和，第三列的和)
print(“沿着行求和 (axis=1):”, np.sum(arr, axis=1)) # 输出 [6 15] (第一行的和，第二行的和)

print(“沿着列计算平均值 (axis=0):”, np.mean(arr, axis=0)) # 输出 [2.5 3.5 4.5]
print(“沿着行计算平均值 (axis=1):”, np.mean(arr, axis=1)) # 输出 [3. 4.5]
``
理解axis` 参数对于处理多维数组至关重要。

5.5 广播 (Broadcasting)

广播是 NumPy 在执行算术运算时处理具有不同形状的数组的能力，它可以使得较小的数组在较大数组上“广播”，以便执行元素级别的操作。如果广播规则允许，这个过程无需复制数据，非常高效。

简单的广播例子：

“`python
a = np.array([1, 2, 3]) # 形状 (3,)
b = 2 # 标量 (形状 ())

print(“\n广播示例:”)
print(“a + b =”, a + b) # 输出 [3 4 5] (标量 b 被广播到与 a 相同的形状)

matrix = np.array([[1, 2, 3], [4, 5, 6]]) # 形状 (2, 3)
vector = np.array([10, 20, 30]) # 形状 (3,)

print(“matrix:\n”, matrix)
print(“vector:\n”, vector)
print(“matrix + vector:\n”, matrix + vector)

输出:

[[11 22 33]

[14 25 36]]

(vector 被广播到与 matrix 相同的形状，每一行都加上 vector)

“`

广播遵循一套规则，简单来说，两个数组在某个维度上兼容，如果它们在该维度的大小相同，或者其中一个的大小是 1。NumPy 会从末尾维度开始比较形状。如果遇到不兼容的维度，就会报错。理解广播规则能帮助你写出更简洁高效的 NumPy 代码。

5.6 形状操作

改变数组的形状而不改变其数据内容是 NumPy 中的常见操作。

• reshape(new_shape): 返回一个具有新形状的数组，如果可能的话，是原始数组的视图。新形状必须与原始数组的元素总数兼容。

  “`python
  arr = np.arange(12) # 创建一个包含0到11的一维数组 形状 (12,)
  print(“\n形状操作:”)
  print(“原始数组 (形状”, arr.shape, “):”, arr)

  reshaped_arr = arr.reshape((3, 4)) # 重塑为 3行4列的二维数组
  print(“重塑为 (3, 4) 的数组:\n”, reshaped_arr)
  print(“新数组形状:”, reshaped_arr.shape)

  可以使用 -1 让 NumPy 自动计算维度大小

  reshaped_arr2 = arr.reshape((4, -1)) # 重塑为 4行，列数自动计算 (12/4=3)
  print(“重塑为 (4, -1) 的数组:\n”, reshaped_arr2)

  reshaped_arr3 = arr.reshape((-1, 3)) # 重塑为 3列，行数自动计算 (12/3=4)
  print(“重塑为 (-1, 3) 的数组:\n”, reshaped_arr3)
  “`

• flatten() 和 ravel(): 将多维数组展平为一维数组。flatten() 总是返回一个副本，而 ravel() 通常返回一个视图（如果可能），因此 ravel() 更高效。

  python
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print("\n展平数组:")
print("flatten():", matrix.flatten()) # 返回副本
print("ravel():", matrix.ravel()) # 通常返回视图

• transpose() 或 .T: 数组的转置（行列互换）。

  python
print("\n数组转置:")
print("原始矩阵:\n", matrix)
print("转置矩阵:\n", matrix.transpose())
print("转置矩阵 (.T 属性):\n", matrix.T)

• 数组堆叠 (Stacking) 和拆分 (Splitting)：

  • np.concatenate((arr1, arr2), axis=...): 沿着指定轴连接一系列数组。
  • np.vstack((arr1, arr2)): 垂直堆叠（按行）。
  • np.hstack((arr1, arr2)): 水平堆叠（按列）。
  • np.split(arr, indices_or_sections, axis=...): 沿着指定轴将数组拆分成多个子数组。
  • np.vsplit(arr, sections): 垂直拆分（按行）。
  • np.hsplit(arr, sections): 水平拆分（按列）。

“`python
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])

print(“\n数组堆叠与拆分:”)
print(“水平堆叠 hstack:\n”, np.hstack((a, b))) # 输出 [1 2 3 4 5 6]
print(“垂直堆叠 vstack:\n”, np.vstack((matrix1, matrix2)))

输出:

[[1 2]

[3 4]

[5 6]

[7 8]]

combined_matrix = np.vstack((matrix1, matrix2))
print(“垂直拆分 vsplit:\n”, np.vsplit(combined_matrix, 2)) # 拆分成2块，输出 [array([[1, 2], [3, 4]]), array([[5, 6], [7, 8]])]
print(“水平拆分 hsplit:\n”, np.hsplit(matrix1, 2)) # 拆分成2块，输出 [array([[1], [3]]), array([[2], [4]])]
“`

第六步：常用 NumPy 功能 (进阶入门)

除了上述基础操作，NumPy 还提供了许多其他强大功能，这些是深入学习数据科学时会经常用到的：

1. 随机数生成 (np.random)：NumPy 的 random 模块提供了生成各种分布的随机数的功能，这对于模拟、统计抽样和机器学习模型初始化非常有用。

   “`python
   print(“\n随机数生成:”)
   print(“生成 3×3 的随机浮点数 (0到1之间):”)
   print(np.random.rand(3, 3))

   print(“生成 2×2 的随机整数 (1到10之间，不包含10):”)
   print(np.random.randint(1, 10, size=(2, 2)))

   print(“从标准正态分布中生成 1×5 的随机数:”)
   print(np.random.randn(1, 5))

   设置随机种子以保证结果可复现

   np.random.seed(42) # 设置种子为 42
   print(“设置种子后的随机数 (可复现):”, np.random.rand(3))
   np.random.seed(42) # 再次设置相同的种子
   print(“再次设置种子后的随机数 (与上一次相同):”, np.random.rand(3))
   “`

2. 线性代数 (np.linalg)：NumPy 的 linalg 子模块提供了一些基本的线性代数功能，如矩阵乘法、求逆、计算行列式等。

   “`python
   matrix_a = np.array([[1, 2], [3, 4]])
   vector_b = np.array([5, 6])

   print(“\n线性代数:”)

   矩阵乘法 (对于二维数组，@ 运算符或 np.dot() 都可以表示矩阵乘法)

   print(“矩阵乘法 (matrix_a @ vector_b):”, matrix_a @ vector_b) # 输出 [17 39]
   print(“矩阵乘法 (np.dot(matrix_a, vector_b)):”, np.dot(matrix_a, vector_b)) # 输出 [17 39]
   print(“矩阵乘法 (matrix_a @ matrix_a):\n”, matrix_a @ matrix_a)

   矩阵求逆

   try:
   matrix_a_inv = np.linalg.inv(matrix_a)
   print(“matrix_a 的逆矩阵:\n”, matrix_a_inv)
   # 验证：原矩阵乘以逆矩阵应该得到单位矩阵
   print(“原矩阵 * 逆矩阵:\n”, matrix_a @ matrix_a_inv)
   except np.linalg.LinAlgError:
   print(“矩阵不可逆”)

   计算行列式

   print(“matrix_a 的行列式:”, np.linalg.det(matrix_a)) # 14 – 23 = 4 – 6 = -2
   “`
   需要更高级的线性代数功能时，通常会使用 SciPy 库，它建立在 NumPy 的基础上。

3. 文件输入/输出：NumPy 提供了方便的函数用于将数组保存到文件和从文件加载数组。常用的格式有 NumPy 的二进制格式 (.npy, .npz) 和文本格式 (.txt, .csv)。

   “`python
   data_to_save = np.array([[1.1, 2.2], [3.3, 4.4]])

   print(“\n文件输入/输出:”)

   保存为 NumPy 二进制格式 (.npy) – 高效，保存数据类型和形状

   np.save(‘my_data.npy’, data_to_save)
   loaded_data_npy = np.load(‘my_data.npy’)
   print(“从 .npy 加载的数据:\n”, loaded_data_npy)

   保存为文本文件 (.txt 或 .csv) – 可读性好，但可能丢失精度或数据类型信息

   np.savetxt(‘my_data.txt’, data_to_save, fmt=’%.2f’, delimiter=’,’) # fmt指定格式，delimiter指定分隔符
   loaded_data_txt = np.loadtxt(‘my_data.txt’, delimiter=’,’)
   print(“从 .txt 加载的数据:\n”, loaded_data_txt)
   ``
使用.npy和.npz` (用于保存多个数组) 是保存和加载 NumPy 数组的首选方法，因为它们保留了数组的所有信息。

第七步：继续学习资源

这篇指南覆盖了 NumPy 的安装以及最基本和核心的概念与操作。NumPy 的功能远不止这些，例如更复杂的索引和切片技巧、ufuncs 的更多用法、数组间的比较和逻辑运算、排序、插值、傅里叶变换等。要真正掌握 NumPy，还需要进一步的学习和大量的实践。

以下是一些推荐的继续学习资源：

1. NumPy 官方文档 (https://numpy.org/doc/)：这是最权威和完整的资源，包含用户指南、教程和 API 参考。对于初学者来说，用户指南和教程部分非常有价值。
2. NumPy 教程：网上有大量优秀的 NumPy 教程，例如：
   • NumPy 官方提供的教程 (https://numpy.org/doc/stable/user/quickstart.html)
   • 各种数据科学课程和书籍中的 NumPy 章节。
3. 在线课程平台：Coursera、edX、Udemy、DataCamp 等平台提供了许多包含 NumPy 内容的 Python 数据科学课程。
4. 实践是关键：尝试使用 NumPy 解决一些实际问题，例如处理小型数据集、实现简单的算法、进行数学建模等。网站如 Kaggle 提供数据集和编程竞赛，是练习的好地方。
5. 探索其他库：当你对 NumPy 有所了解后，可以开始学习其他基于 NumPy 的库，如 Pandas (数据分析)、Matplotlib/Seaborn (数据可视化)、SciPy (科学计算)、Scikit-learn (机器学习) 等。这将让你更全面地了解 NumPy 在整个 Python 数据科学生态系统中的作用。

结论

NumPy 是 Python 进行数值计算和数据科学的基石。通过 pip 安装 NumPy 是一个简单直接的过程，而理解其核心概念——多维数组（ndarray）以及掌握数组的创建、索引、切片、基本运算和广播等技能，是高效使用 NumPy 的关键。

本指南从环境准备、详细的 pip 安装步骤（包括虚拟环境的最佳实践）讲起，逐步深入到 NumPy 数组的本质和基础操作，并通过丰富的代码示例帮助读者理解和实践。掌握 NumPy 不仅能让你在处理数值数据时事半功倍，更是打开了通往 Python 数据科学、机器学习和科学计算世界的大门。

记住，学习编程和使用库最好的方法就是动手实践。在阅读本指南的同时，强烈建议你在自己的 Python 环境中跟着代码示例一起敲击和运行，尝试修改参数，观察结果的变化。遇到问题时，不要害怕查阅文档和搜索解决方案。

祝你在 NumPy 的学习旅程中顺利前行！

---