1.1 NumPy 的定义与作用

1.1 NumPy 的定义与作用

1.1 NumPy 的定义与作用

NumPy (Numerical Python) 是 Python 中科学计算的基础包。它是一个开源的 Python 扩展库，提供了高性能的多维数组对象及其处理数组的工具。NumPy 是几乎所有数据科学、机器学习和深度学习框架的基础，例如 Pandas、SciPy、Scikit-learn 和 TensorFlow 等。

1.1.1 NumPy 的定义

NumPy 的核心是 ndarray (n-dimensional array object)，它是一个高效的多维数组，用于存储同类型的数据。与 Python 内置的列表相比，ndarray 具有以下优势：

• 更紧凑的内存占用: ndarray 存储的数据类型相同，因此可以更有效地利用内存。

• 更快的运算速度: NumPy 使用向量化操作，可以同时对整个数组执行运算，避免了 Python 的循环开销。

• 广播机制: NumPy 可以自动处理不同形状数组之间的运算，简化了代码编写。

除了 ndarray，NumPy 还提供了大量的函数，用于数组的创建、操作、数学运算、线性代数、傅里叶变换和随机数生成等。

1.1.2 NumPy 的作用

NumPy 在数据科学和科学计算中扮演着至关重要的角色，主要体现在以下几个方面：

• 数据存储: NumPy 的 ndarray 提供了高效的数据存储方式，可以存储各种类型的数据，例如数值、布尔值、字符串等。

• 数据处理: NumPy 提供了丰富的函数，可以对数组进行各种操作，例如切片、索引、重塑、连接、拆分等。

• 数值计算: NumPy 提供了大量的数学函数，可以对数组进行各种数学运算，例如加减乘除、指数、对数、三角函数等。

• 线性代数: NumPy 提供了线性代数运算的功能，可以进行矩阵乘法、求逆、特征值分解等。

• 随机数生成: NumPy 提供了随机数生成的功能，可以生成各种分布的随机数，用于模拟和统计分析。

• 作为其他库的基础: 许多数据科学库，例如 Pandas、SciPy 和 Scikit-learn，都建立在 NumPy 的基础上，利用 NumPy 提供的数组和函数进行数据处理和分析。

1.1.3 NumPy 与 Python 列表的对比

1.1.4 NumPy 的核心概念

• 数组 (Array): NumPy 的核心数据结构，用于存储同类型的数据。

• 维度 (Dimension): 数组的轴的数量。例如，一维数组只有一个轴，二维数组有两个轴。

• 形状 (Shape): 一个元组，表示数组在每个维度上的大小。例如，一个形状为 (3, 4) 的数组有 3 行和 4 列。

• 数据类型 (dtype): 数组中元素的数据类型。例如，int32, float64, bool。

• 轴 (Axis): 数组的维度。例如，在二维数组中，axis=0 表示行，axis=1 表示列。

• 向量化 (Vectorization): 同时对整个数组执行运算，避免了 Python 的循环开销。

• 广播 (Broadcasting): NumPy 可以自动处理不同形状数组之间的运算。

1.1.5 NumPy 在数据科学流程中的位置

1.2 NumPy 代码实践与内容详解

1.2.1 NumPy 的安装

可以使用 pip 命令安装 NumPy：

pip install numpy
​

1.2.2 NumPy 的导入

import numpy as np  # 约定俗成的写法，将 NumPy 导入并命名为 np
​

1.2.3 创建 NumPy 数组

• 从 Python 列表创建:

import numpy as np
list1 = [1, 2, 3, 4, 5]
arr1 = np.array(list1)
print(arr1)  # 输出: [1 2 3 4 5]
print(type(arr1)) # 输出: <class 'numpy.ndarray'>
list2 = [[1, 2, 3], [4, 5, 6]]
arr2 = np.array(list2)
print(arr2)
# 输出:
# [[1 2 3]
#  [4 5 6]]
​

• 使用 NumPy 内置函数创建:

import numpy as np
# 创建全零数组
zeros_arr = np.zeros((2, 3))  # 创建一个 2x3 的全零数组
print(zeros_arr)
# 输出:
# [[0. 0. 0.]
#  [0. 0. 0.]]
# 创建全一数组
ones_arr = np.ones((3, 2))  # 创建一个 3x2 的全一数组
print(ones_arr)
# 输出:
# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]
# 创建指定值的数组
full_arr = np.full((2, 2), 7)  # 创建一个 2x2 的数组，所有元素都为 7
print(full_arr)
# 输出:
# [[7 7]
#  [7 7]]
# 创建单位矩阵
eye_arr = np.eye(3)  # 创建一个 3x3 的单位矩阵
print(eye_arr)
# 输出:
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]
# 创建等差数列
arange_arr = np.arange(0, 10, 2)  # 创建一个从 0 到 10 (不包括 10) 的等差数列，步长为 2
print(arange_arr)  # 输出: [0 2 4 6 8]
# 创建等间隔数列
linspace_arr = np.linspace(0, 1, 5)  # 创建一个从 0 到 1 的等间隔数列，包含 5 个元素
print(linspace_arr)  # 输出: [0.   0.25 0.5  0.75 1.  ]
# 创建随机数数组
random_arr = np.random.rand(2, 3)  # 创建一个 2x3 的随机数数组，元素值在 0 到 1 之间
print(random_arr)
# 输出 (示例):
# [[0.123 0.456 0.789]
#  [0.987 0.654 0.321]]
random_int_arr = np.random.randint(0, 10, (2, 3)) # 创建一个 2x3 的随机整数数组，元素值在 0 到 10 (不包括 10) 之间
print(random_int_arr)
# 输出 (示例):
# [[2 8 1]
#  [5 9 3]]
​

1.2.4 数组的属性

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.ndim)  # 输出: 2 (数组的维度)
print(arr.shape) # 输出: (2, 3) (数组的形状)
print(arr.size)  # 输出: 6 (数组的元素个数)
print(arr.dtype) # 输出: int64 (数组的数据类型)
print(arr.itemsize) # 输出: 8 (每个元素占用的字节数，int64 占用 8 字节)
print(arr.nbytes) # 输出: 48 (数组占用的总字节数，等于 size * itemsize)
​

1.2.5 数组的索引和切片

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr[0])   # 输出: 1 (访问第一个元素)
print(arr[-1])  # 输出: 5 (访问最后一个元素)
print(arr[1:4])  # 输出: [2 3 4] (切片，访问索引 1 到 4 (不包括 4) 的元素)
print(arr[:3])   # 输出: [1 2 3] (切片，访问索引 0 到 3 (不包括 3) 的元素)
print(arr[3:])   # 输出: [4 5] (切片，访问索引 3 到最后一个元素的元素)
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2d[0, 0])  # 输出: 1 (访问第一行第一列的元素)
print(arr2d[1, 2])  # 输出: 6 (访问第二行第三列的元素)
print(arr2d[0])     # 输出: [1 2 3] (访问第一行)
print(arr2d[:, 0])  # 输出: [1 4 7] (访问第一列)
print(arr2d[0:2, 1:3]) # 输出: [[2 3] [5 6]] (访问一个子矩阵)
​

1.2.6 数组的运算

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print(arr1 + arr2)  # 输出: [5 7 9] (元素相加)
print(arr1 - arr2)  # 输出: [-3 -3 -3] (元素相减)
print(arr1 * arr2)  # 输出: [ 4 10 18] (元素相乘)
print(arr1 / arr2)  # 输出: [0.25 0.4  0.5 ] (元素相除)
print(arr1 ** 2)   # 输出: [1 4 9] (元素求平方)
print(arr1 > 2)    # 输出: [False False  True] (元素比较)
print(np.sum(arr1))  # 输出: 6 (所有元素求和)
print(np.mean(arr1)) # 输出: 2.0 (所有元素求平均值)
print(np.max(arr1))  # 输出: 3 (所有元素求最大值)
print(np.min(arr1))  # 输出: 1 (所有元素求最小值)
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
print(np.dot(matrix1, matrix2)) # 输出: [[19 22] [43 50]] (矩阵乘法)
​

1.2.7 数组的形状操作

import numpy as np
arr = np.arange(12)  # 创建一个包含 0 到 11 的数组
print(arr.reshape(3, 4))  # 输出: 将数组重塑为 3x4 的矩阵
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2d.flatten()) # 输出: [1 2 3 4 5 6] (将数组展平为一维数组)
print(arr2d.T)       # 输出: 数组的转置
# [[1 4]
#  [2 5]
#  [3 6]]
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print(np.concatenate((arr1, arr2))) # 输出: [1 2 3 4 5 6] (数组连接)
​

1.2.8 广播机制

NumPy 的广播机制允许不同形状的数组进行运算。当两个数组的形状不完全相同，但满足一定的条件时，NumPy 会自动扩展数组的形状，使其能够进行运算。

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = 5
print(arr1 + arr2)  # 输出: [6 7 8] (arr2 被广播为 [5 5 5])
arr3 = np.array([[1, 2, 3], [4, 5, 6]])
arr4 = np.array([10, 20, 30])
print(arr3 + arr4)
# 输出:
# [[11 22 33]
#  [14 25 36]]
# (arr4 被广播为 [[10 20 30], [10 20 30]])
​

广播规则:

1. 如果两个数组的维度数不相同，则维度数较小的数组会在其形状的前面补 1，直到两个数组的维度数相同。

2. 如果两个数组在某个维度上的大小相同，或者其中一个数组在该维度上的大小为 1，则这两个数组在该维度上是兼容的。

3. 如果两个数组在所有维度上都兼容，则它们可以一起进行广播。

4. 广播之后，每个数组表现为好像其形状已变成两个数组形状的元素之间的最大值。

5. 在任何一个数组维度上的大小为 1，并且该维度在计算中被广播，则该维度中的数组元素将使用第一个值。

1.3 总结

NumPy 是 Python 中科学计算的基础库，它提供了高效的多维数组对象 ndarray 和丰富的数组操作函数。NumPy 在数据存储、数据处理、数值计算、线性代数和随机数生成等方面都发挥着重要作用。掌握 NumPy 是进行数据科学和科学计算的必要条件。通过学习 NumPy 的基本概念、属性、索引、切片、运算和形状操作，可以有效地利用 NumPy 进行数据处理和分析。