NumPy（Numerical Python）是 Python 进行科学计算和数据分析的基础库。它的核心是“高性能多维数组对象”，并且提供了丰富的数组操作工具。无论你是做数据分析、机器学习还是科学研究，NumPy 都是必不可少的基础。

1. 安装与导入 #

1.1 安装 NumPy #

在命令行中输入以下命令即可安装 NumPy：

pip install numpy  # 用 pip 安装 numpy 库

1.2 导入 NumPy #

在 Python 代码中，通常用 np 作为 NumPy 的简写：

import numpy as np  # 导入 numpy，并简写为 np，方便后续使用

2. NumPy 的核心：ndarray（N 维数组） #

2.1 什么是 ndarray？ #

• ndarray 是 NumPy 的核心数据结构，意思是“N 维数组对象”。
• 它可以看作是一个“装满数字的表格”，可以是一维、二维，甚至多维。
• ndarray 支持高效的批量运算，比 Python 原生的 list 更快更省内存。

2.2 创建数组 #

import numpy as np  # 导入 numpy

# 从 Python 列表创建一维数组
arr1 = np.array([1, 2, 3])  # 创建一维数组 [1, 2, 3]

# 从嵌套列表创建二维数组
arr2 = np.array([[1, 2], [3, 4]])  # 创建二维数组 [[1, 2], [3, 4]]

# 创建全 0 数组，形状为 3 行 4 列
zeros = np.zeros((3, 4))  # 3x4 的全 0 数组

# 创建全 1 数组，形状为 2x3x4（三维）
ones = np.ones((2, 3, 4))  # 2 个 3x4 的全 1 数组

# 创建未初始化的数组（内容随机），形状为 2x3
empty = np.empty((2, 3))  # 2x3 的未初始化数组

# 创建等差数组，类似 Python 的 range
arange = np.arange(10)  # 创建 [0, 1, ..., 9] 的一维数组

# 创建等间隔数组，从 0 到 1，分成 5 个数
linspace = np.linspace(0, 1, 5)  # 创建 [0. , 0.25, 0.5 , 0.75, 1. ]

# 创建 3x2 的随机数组，元素在 [0,1) 之间
random_arr = np.random.rand(3, 2)  # 3 行 2 列的随机数数组

# 创建 3x3 的单位矩阵（主对角线为 1，其余为 0）
identity = np.eye(3)  # 3x3 单位矩阵

2.3 数组的常用属性 #

arr = np.array([[1, 2, 3], [4, 5, 6]])  # 创建一个 2 行 3 列的二维数组
print(arr.ndim)      # 数组的维度数，这里是 2
print(arr.shape)     # 数组的形状，这里是 (2, 3)
print(arr.size)      # 数组的元素总数，这里是 6
print(arr.dtype)     # 数组元素的数据类型，这里是 int64
print(arr.itemsize)  # 每个元素占用的字节数，这里是 8 字节

3. 数据类型（dtype） #

NumPy 支持多种数据类型，可以在创建数组时指定，也可以后续转换。

# 创建时指定数据类型为 float32（32 位浮点数）
arr = np.array([1, 2, 3], dtype=np.float32)  # 元素类型为 float32

# 类型转换：将 float32 转为 int32（32 位整数）
int_arr = arr.astype(np.int32)  # 转换为 int32 类型

# 常见数据类型有：
# np.int8/16/32/64   # 有符号整数（8/16/32/64 位）
# np.uint8/16/32/64  # 无符号整数
# np.float16/32/64   # 浮点数
# np.complex64/128   # 复数
# np.bool_           # 布尔型
# np.object_         # Python 对象
# np.string_         # 字符串
# np.unicode_        # Unicode 字符串

4. 数组的基本操作 #

4.1 索引与切片 #

NumPy 数组的索引和切片方式与 Python 列表类似，但更强大。

arr = np.arange(10)  # 创建 [0, 1, ..., 9] 的一维数组
print(arr[2])        # 取下标为 2 的元素，结果是 2
print(arr[2:5])      # 取下标 2 到 4 的元素，结果是 [2 3 4]
print(arr[:5])       # 取前 5 个元素，结果是 [0 1 2 3 4]
print(arr[::2])      # 每隔一个取一个，结果是 [0 2 4 6 8]

# 多维数组的索引
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  # 3x3 二维数组
print(arr2d[1])      # 取第 2 行，结果是 [4 5 6]
print(arr2d[1, 2])   # 取第 2 行第 3 列，结果是 6
print(arr2d[:, 1:])  # 取所有行的第 2 列及之后，结果是 [[2 3], [5 6], [8 9]]

4.2 形状操作 #

arr = np.arange(8)  # 创建 [0, 1, ..., 7] 的一维数组
reshaped = arr.reshape((2, 4))  # 改变形状为 2 行 4 列
print(reshaped)  # 输出 [[0 1 2 3], [4 5 6 7]]

flattened = arr.flatten()  # 展平成一维数组
print(flattened)  # 输出 [0 1 2 3 4 5 6 7]

# 转置：行列互换
transposed = reshaped.T  # .T 表示转置
print(transposed)  # 输出 [[0 4], [1 5], [2 6], [3 7]]

4.3 数组运算 #

NumPy 支持数组间的各种运算，且是“元素级”运算。

a = np.array([1, 2, 3])  # 一维数组
b = np.array([4, 5, 6])  # 一维数组

print(a + b)  # 数组加法，对应元素相加，结果 [5 7 9]
print(a * b)  # 数组乘法，对应元素相乘，结果 [4 10 18]
print(a**2)   # 数组平方，对每个元素平方，结果 [1 4 9]

# 矩阵乘法（点积）
mat_a = np.array([[1, 2], [3, 4]])  # 2x2 矩阵
mat_b = np.array([[5, 6], [7, 8]])  # 2x2 矩阵
# np.dot 实现矩阵乘法
print(np.dot(mat_a, mat_b))  # 结果 [[19 22], [43 50]]

# 广播机制：不同形状的数组自动对齐运算
print(a + 1)  # 数组加标量，结果 [2 3 4]，1 自动扩展为 [1 1 1]

5. 通用函数（ufunc） #

NumPy 提供快速的元素级运算函数：

arr = np.array([1.1, 2.2, 3.3])

# 数学运算
print(np.sqrt(arr))     # 平方根
print(np.exp(arr))      # 指数
print(np.log(arr))      # 自然对数
print(np.sin(arr))      # 正弦

# 统计函数
print(np.sum(arr))      # 总和
print(np.mean(arr))     # 平均值
print(np.max(arr))      # 最大值
print(np.argmax(arr))   # 最大值索引
print(np.std(arr))      # 标准差

6. 数组操作进阶 #

布尔索引 #

arr = np.array([1, 2, 3, 4, 5])
print(arr[arr > 3])     # [4 5]

# 复合条件
print(arr[(arr > 2) & (arr < 5)])  # [3 4]

花式索引 #

arr = np.arange(12).reshape((3, 4))
print(arr[[0, 2]])      # 选择第0行和第2行
print(arr[:, [1, 3]])   # 选择第1列和第3列

数组拼接 #

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])

# 垂直拼接
print(np.vstack((a, b)))  # [[1 2] [3 4] [5 6]]

# 水平拼接
print(np.hstack((a, b.T))) # [[1 2 5] [3 4 6]]

7. 线性代数 #

from numpy import linalg

# 矩阵求逆
mat = np.array([[1., 2.], [3., 4.]])
inv_mat = linalg.inv(mat)

# 行列式
det = linalg.det(mat)

# 特征值和特征向量
eigenvalues, eigenvectors = linalg.eig(mat)

# 解线性方程组
a = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = linalg.solve(a, b)  # 解3x + y = 9, x + 2y = 8

8. 随机数生成 #

# 均匀分布
uniform = np.random.rand(3, 2)       # [0,1)区间
uniform_range = np.random.uniform(5, 10, size=(2, 3))

# 正态分布
normal = np.random.randn(100)        # 标准正态
normal_custom = np.random.normal(50, 10, size=100)

# 随机整数
integers = np.random.randint(0, 10, size=5)

# 随机排列
arr = np.arange(10)
np.random.shuffle(arr)               # 原地打乱
permuted = np.random.permutation(arr) # 返回新数组

9. 实际应用示例 #

图像处理 #

# 将图像转换为NumPy数组
from PIL import Image
img = Image.open('image.jpg')
img_arr = np.array(img)
print(img_arr.shape)  # (height, width, channels)

# 灰度转换
gray = np.dot(img_arr[...,:3], [0.2989, 0.5870, 0.1140])

数据标准化 #

标准差（Standard Deviation，记作$\sigma$）是衡量一组数据离散程度的重要统计量。它反映了数据相对于均值的波动大小，标准差越大，说明数据分布越分散；标准差越小，说明数据越集中。

# 生成一个100行5列的标准正态分布随机数据数组
data = np.random.randn(100, 5)

# 计算每一列的均值，用于Z-score标准化
mean = data.mean(axis=0)
# 计算每一列的标准差，用于Z-score标准化
std = data.std(axis=0)
# 将数据转换为均值为0、标准差为1的分布
normalized = (data - mean) / std

# 计算每一列的最小值，用于Min-Max标准化
min_val = data.min(axis=0)
# 计算每一列的最大值，用于Min-Max标准化
max_val = data.max(axis=0)
# 对数据进行Min-Max标准化处理
scaled = (data - min_val) / (max_val - min_val)

移动平均 #

移动平均（Moving Average）是一种常用的平滑算法，常用于时间序列数据的分析，比如股票价格、传感器数据等。其核心思想是：用某一时刻及其前后若干时刻的数据的平均值，来代替该时刻的值，从而消除短期波动，突出长期趋势。

以moving_average函数为例：

• window_size表示滑动窗口的大小，即每次取多少个连续的数据求平均。
• np.ones(window_size) / window_size生成一个长度为window_size的权重数组，每个权重相等，和为1。
• np.convolve(data, window, 'valid')实现滑动平均：窗口在数据上滑动，每次计算窗口覆盖范围内的加权和（这里就是简单平均）。

例如，若window_size=3，则第一个输出为(data[0]+data[1]+data[2])/3，第二个输出为(data[1]+data[2]+data[3])/3，以此类推。

移动平均常用于去噪、平滑曲线、捕捉趋势等场景。

# 定义移动平均函数，data为输入数据，window_size为窗口大小
def moving_average(data, window_size):
    # 创建一个长度为window_size的权重数组，每个元素为1/window_size，实现等权平均
    window = np.ones(window_size) / window_size
    # 使用np.convolve进行一维卷积，'valid'模式保证输出长度为len(data)-window_size+1
    return np.convolve(data, window, 'valid')

# 生成100个模拟股票价格，范围在100到200之间
stock_prices = np.random.rand(100) * 100 + 100
# 计算5日移动平均
ma_5 = moving_average(stock_prices, 5)

10. 性能优化技巧 #

1. 向量化操作：尽量使用NumPy内置函数而不是Python循环
2. 避免复制：使用视图而非副本操作（如切片返回视图）
3. 使用广播：利用广播机制代替显式循环
4. 选择合适的数据类型：使用最小满足需求的类型节省内存
5. 使用NumPy函数：如np.where, np.select等替代条件逻辑

NumPy是Python科学计算生态系统的基石，几乎所有科学计算库（如Pandas、SciPy、scikit-learn等）都基于NumPy构建。掌握NumPy对于进行高效的数据处理和数值计算至关重要。