Python数据处理：NumPy数值计算实操教程（新手到进阶）

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

NumPy核心解析：高效数值计算的基石

NumPy作为Python中科学计算的核心库，提供了强大的多维数组对象与高效的数值运算能力。其底层基于C语言实现，能够以极高的性能处理大规模数据，是Pandas、Matplotlib、Scikit-learn等众多数据分析和机器学习库的基础支撑。无论是在矩阵操作、统计分析还是数据清洗任务中，掌握NumPy都能显著提升代码执行效率。

一、为何选择NumPy？理解其不可替代性

尽管Python原生列表（list）使用灵活，但在进行数值计算时存在明显短板：

• 运行效率低：列表存储的是指向对象的指针，循环遍历时需频繁调用解释器，导致CPU密集型任务性能较差；
• 功能受限：缺乏对矩阵运算、广播机制等原生支持，复杂计算需要手动编写大量逻辑。

而NumPy通过以下优势解决了这些问题：

• 高性能计算：ndarray采用连续内存块存储，配合C级优化的运算内核，极大减少开销；
• 向量化操作：支持整组数据一次性运算，无需显式for循环，语法简洁且速度快；
• 丰富的数学接口：内置线性代数、傅里叶变换、随机模拟等功能模块；
• 内存占用更少：相比列表，存储相同数量的浮点数可节省80%以上空间（例如100万个浮点数，列表约占8MB，NumPy仅需约4MB）。

快速入门：安装与导入方式

# 安装命令
pip install numpy

# 标准导入习惯（通用简写）
import numpy as np

二、核心结构：深入理解ndarray数组

ndarray（N维数组）是NumPy中最基本也是最重要的数据类型，所有操作均围绕该结构展开。它具有固定大小、同质元素、支持多维索引等特点，是实现高效计算的关键载体。

1. 常见创建方法及应用场景

创建方式	代码示例	适用场景
从列表或元组转换	np.array([1,2,3])	手动构造小规模数据集
生成全0数组	np.zeros((3,4))	初始化权重矩阵或占位数组
生成全1数组	np.ones((2,3))	设置基准值或累加初始状态
空数组（未初始化）	np.empty((2,2))	快速分配大内存空间（后续赋值）
按范围生成数组	np.arange(0,10,2)	构建等差序列或时间步长
等距数值分布	np.linspace(0,1,5)	生成指定点数的均匀间隔值
随机数数组	np.random.rand(3,3)	模拟实验数据或参数初始化

实战演示：多种数组创建方式

# 1. 创建一维数组
arr1 = np.array([1, 2, 3, 4, 5])
print("一维数组：", arr1)  # 输出：[1 2 3 4 5]

# 2. 构造二维数组（即矩阵）
arr2 = np.array([[1,2,3], [4,5,6]])
print("二维数组形状：", arr2.shape)   # 输出：(2, 3)
print("数组维度数：", arr2.ndim)      # 输出：2
print("元素数据类型：", arr2.dtype)  # 默认int64，可通过dtype指定

# 3. 使用arange生成带步长的数组
arr3 = np.arange(0, 10, 2)  # 起始0，结束前于10，步长2
print("范围数组：", arr3)  # 结果：[0 2 4 6 8]

# 4. 生成3x3的随机浮点数组（0~1之间）
arr4 = np.random.rand(3, 3)
print("随机数组：\n", arr4)

2. 数组的索引与切片操作——精准提取数据

NumPy继承了Python的索引语法，并在此基础上扩展出多维访问能力，是进行子集选取、条件筛选的核心手段。

（1）一维数组的索引与切片

arr = np.arange(10)
print(arr[5])       # 获取索引为5的元素 → 5
print(arr[3:8])     # 切片区间[3,8) → [3 4 5 6 7]
print(arr[::2])     # 步长为2取值 → [0 2 4 6 8]

（2）二维数组的行列联合索引

支持行+列双维度定位，格式为array[行索引, 列索引]，也可分别切片。

matrix = np.array([[10, 20, 30],
                   [40, 50, 60],
                   [70, 80, 90]])

print(matrix[1, 2])        # 第2行第3列 → 60
print(matrix[0, :])         # 第1行全部 → [10 20 30]
print(matrix[:, 1])         # 第2列全部 → [20 50 80]
print(matrix[0:2, 1:3])     # 前两行、后两列 → [[20 30],[50 60]]

（3）布尔索引：基于条件的数据筛选

利用布尔表达式返回掩码数组，实现高效过滤。

data = np.array([1, 4, 7, 9, 12, 15])
mask = data > 8
print(data[mask])  # 输出大于8的元素 → [9 12 15]

# 多条件组合
mask2 = (data >= 5) & (data <= 12)
print(data[mask2]) # 输出[7 9 12]

3. 数组形状操作：重塑、拼接与分割

在实际处理中，经常需要调整数组结构以适应不同算法输入要求。

（1）重塑数组（reshape）

改变数组维度而不影响数据内容。

flat = np.arange(12)
reshaped = flat.reshape(3, 4)  # 变为3行4列
print(reshaped)

（2）合并数组

• np.concatenate()：沿指定轴连接数组
• np.vstack()：垂直堆叠（按行）
• np.hstack()：水平拼接（按列）

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

# 水平合并 → 2x4
h_combined = np.hstack((a,b))
# 垂直合并 → 4x2
v_combined = np.vstack((a,b))

（3）拆分数组（split）

将一个数组按指定位置或数量分割成多个部分。

arr = np.arange(9)
parts = np.split(arr, 3)  # 分为3段
print(parts)  # [array([0,1,2]), array([3,4,5]), array([6,7,8])]

三、核心运算能力：向量化与广播机制

NumPy最强大的特性之一就是“向量化”——无需循环即可对整个数组执行相同操作。

1. 基础算术运算

x = np.array([1,2,3])
y = np.array([4,5,6])

print(x + y)    # [5 7 9]
print(x * 2)    # [2 4 6]
print(x ** 2)   # [1 4 9]

2. 矩阵运算（线性代数基础）

A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])

# 矩阵乘法
C = A @ B  # 或 np.dot(A, B)
print(C)

3. 聚合运算（统计分析常用）

data = np.array([1, 5, 3, 9, 2])

print(data.sum())     # 总和 → 20
print(data.mean())    # 平均值 → 4.0
print(data.max())     # 最大值 → 9
print(data.std())     # 标准差

4. 广播机制：不同形状数组间的智能运算

当两个数组形状不完全相同时，NumPy会自动“扩展”较小数组以匹配较大者，前提是满足广播规则。

# 示例：标量与数组运算
arr = np.array([1,2,3])
result = arr + 10  # [11,12,13] —— 10被广播到每个元素

# 示例：行向量与列向量
row = np.array([[1,2,3]])        # 形状(1,3)
col = np.array([[1],[2],[3]])    # 形状(3,1)
broadcasted = row + col           # 结果为3x3矩阵

四、真实应用案例：传感器数据预处理流程

假设我们有一组来自设备的原始传感器读数，包含缺失值、异常波动等问题，目标是完成清洗并做初步分析。

# 模拟传感器数据（含噪声和NaN）
raw_data = np.random.randn(1000) * 10 + 5
raw_data[::100] = np.nan  # 每隔100个插入一个NaN

# 1. 清除缺失值
cleaned = raw_data[~np.isnan(raw_data)]

# 2. 过滤异常值（保留±3σ范围内）
mean_val = cleaned.mean()
std_val = cleaned.std()
filtered = cleaned[(cleaned >= mean_val - 3*std_val) & 
                  (cleaned <= mean_val + 3*std_val)]

# 3. 分组统计每100个的平均值
grouped_means = filtered[:(len(filtered)//100)*100].reshape(-1, 100).mean(axis=1)

print("清洗后样本数：", len(filtered))
print("分组均值：", grouped_means)

五、性能优化建议：避免常见陷阱

即使使用NumPy，不当写法仍可能导致性能下降。以下是关键优化策略：

1. 减少数组频繁创建：重复生成临时数组会增加内存压力，尽量复用已有结构；
2. 优先使用向量化代替Python循环：避免用for遍历元素，改用内置函数如sum()、clip()等；
3. 合理设定数据类型：如无需高精度，可用np.float32或np.int8节省内存；
4. 避免不必要的拷贝：切片默认返回视图（view），若非必要不要调用copy()以免浪费资源。

六、进阶功能探索

1. 线性代数模块（np.linalg）

提供求解方程、特征值、矩阵分解等高级功能。

A = np.array([[4,1],[2,3]])
b = np.array([5,7])

# 解线性方程 Ax = b
x = np.linalg.solve(A, b)
print("解向量x：", x)

# 特征值分解
eigenvals, eigenvecs = np.linalg.eig(A)

2. 随机数生成（np.random）

支持多种分布的随机采样，适用于模拟、初始化等场景。

# 均匀分布
uniform = np.random.rand(100)

# 正态分布
normal = np.random.randn(100)

# 整数随机抽样
ints = np.random.randint(1, 10, size=10)

# 设置种子保证可重现
np.random.seed(42)

# 创建数组并进行索引操作
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr[1, 2])        # 输出第1行第2列的元素 → 6
print(arr[0:2, :])      # 提取前两行，所有列 → [[1 2 3], [4 5 6]]
print(arr[:, 1])        # 获取所有行的第1列 → [2 5 8]
print(arr[1:, 1:])       # 取从第1行开始及之后，第1列开始及之后的数据 → [[5 6], [8 9]]

# 布尔索引：根据条件筛选数据
arr = np.random.randint(0, 20, (3, 3))
print("原始数组：\n", arr)
mask = arr > 10  # 构建布尔掩码，标记大于10的元素
print("大于10的元素：\n", arr[mask])  # 使用掩码提取符合条件的值

# 数组形状变换操作
# 重塑（reshape）与展平（flatten）
arr = np.arange(12)
arr_3x4 = arr.reshape(3, 4)  # 将一维数组变为3行4列的二维结构
print("3x4数组：\n", arr_3x4)
arr_flat = arr_3x4.flatten()  # 将多维数组压平为一维
print("展平数组：", arr_flat)

# 数组合并：垂直和水平拼接
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])

# 垂直堆叠，沿行方向合并
v_arr = np.vstack((arr1, arr2))
print("垂直合并：\n", v_arr)

# 水平堆叠，沿列方向合并
h_arr = np.hstack((arr1, arr2))
print("水平合并：\n", h_arr)

# 数组拆分：按指定轴分割
arr = np.arange(12).reshape(3, 4)
# 沿着行轴（axis=0）将数组均分为3部分
split_arr = np.split(arr, 3, axis=0)
print("按行拆分：", split_arr)

# NumPy核心特性：向量化运算（无需显式循环）

## 向量化计算优势
NumPy 的“向量化运算”是其高效处理数据的核心机制。它允许对整个数组直接执行数学操作，避免使用 Python 循环，从而提升运行速度达10至100倍。

### 基本算术运算（逐元素操作）
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("取模：", arr2 % arr1)     # 求余数 → [0 1 0]

### 矩阵运算（线性代数基础）
注意区分：
*
 表示元素级乘法；
真正的矩阵乘法需使用 
@
 或 
np.dot()
 实现。

# 示例：2x3 矩阵与 3x2 矩阵相乘，结果为 2x2
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[1, 2], [3, 4], [5, 6]])

# 方法一：使用 @ 运算符（Python 3.5以上支持）
mat_mul1 = arr1 @ arr2

# 方法二：调用 np.dot() 函数
mat_mul2 = np.dot(arr1, arr2)

print("矩阵乘法结果：\n", mat_mul1)
# 输出：
# [[22 28]
#  [49 64]]

### 聚合函数（统计分析常用）
聚合操作可用于快速计算数组的整体或局部统计量：

np.sum()
 —— 计算总和  
示例：np.sum(arr)

np.sum(arr)
  
np.mean()
 —— 计算平均值  
示例：np.mean(arr, axis=0)  # 按列求均值  
np.mean(arr, axis=0)

np.max()
 / 
np.min()
 —— 查找最大值与最小值  
示例：np.max(arr, axis=1)  # 按行求最大值  
np.max(arr, axis=1)

np.argmax()
 / 
np.argmin()
 —— 返回最值对应的索引位置  
示例：np.argmax(arr)  # 返回全局最大值的一维索引  
np.argmax(arr)

np.std()
 / 
np.var()
 —— 计算标准差与方差  
示例：np.std(arr), np.var(arr)  
np.std(arr)

### 实战演示聚合功能
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("数组总和：", np.sum(arr))              # 45
print("按列求和：", np.sum(arr, axis=0))      # [12 15 18]
print("按行求均值：", np.mean(arr, axis=1))   # [2. 5. 8.]
print("数组最大值：", np.max(arr))           # 9
print("最大值索引：", np.argmax(arr))        # 8（展平后的一维索引）

### 广播机制（Broadcasting）
NumPy 支持不同形状数组之间的运算，只要它们满足广播规则。该机制自动扩展较小数组以匹配较大数组的形状，实现高效的元素级操作，无需复制数据。

NumPy广播机制详解及其应用规则

在NumPy中，“广播”（Broadcasting）是一项核心功能，它允许形状不同的数组之间进行算术运算。其基本原理基于以下两条关键规则：

• 当两个数组维度不一致时，维度较少的数组会自动向前补全维度（例如将一维数组视为二维）；
• 对于大小为1的轴，系统会自动沿该方向扩展，使其与另一数组对应维度相匹配。

广播的实际操作示例

示例1：标量与数组之间的运算
标量会被广播到数组的每一个元素上。

arr = np.array([[1,2], [3,4]])
print(arr + 10)  # 输出：[[11 12], [13 14]]

示例2：一维数组作用于二维数组
一维数组会沿着行方向被广播，应用于每一行。

arr1 = np.array([[1,2,3], [4,5,6]])
arr2 = np.array([10, 20, 30])
print(arr1 + arr2)  # 结果：[[11 22 33], [14 25 36]]

示例3：列向量与行向量的广播组合
一个形状为(3,1)的列向量和一个形状为(2,)的一维数组可共同广播为(3,2)的二维结果。

arr1 = np.array([[1], [2], [3]])  # 形状 (3,1)
arr2 = np.array([10, 20])         # 形状 (2,)
print(arr1 + arr2)  # 广播后输出：[[11 21], [12 22], [13 23]]
np.array([1,2,3])

真实场景实战：传感器数据预处理流程

以下是一个完整的数据清洗与分析案例，模拟对含有缺失值的传感器采集数据进行处理。

import numpy as np

# 第一步：生成带异常标记的原始数据
sensor_data = np.random.randint(0, 100, (100, 3))  # 创建100×3的随机整数矩阵
np.put(sensor_data, np.random.choice(100*3, 10), -999)  # 插入10个-999表示缺失

接下来执行数据清洗步骤：

1. 构建有效值掩码：通过条件判断识别非缺失数据；
2. 按列计算均值：仅使用有效数值求各列平均；
3. 填充缺失位置：将对应列的均值填入原数组中的-999处。

mask = sensor_data != -999
col_means = np.mean(sensor_data[mask].reshape(-1, 3), axis=0)
sensor_data[sensor_data == -999] = np.take(col_means, np.where(sensor_data == -999)[1])
print("清洗后数据前5行：\n", sensor_data[:5])

随后进行标准化处理，使数据符合标准正态分布特征：

data_mean = np.mean(sensor_data, axis=0)
data_std = np.std(sensor_data, axis=0)
normalized_data = (sensor_data - data_mean) / data_std
print("标准化后数据前5行：\n", normalized_data[:5])

最后完成基础统计分析：

print("各列均值：", np.mean(normalized_data, axis=0))   # 应接近0
print("各列标准差：", np.std(normalized_data, axis=0))  # 应接近1
print("整体最大值：", np.max(normalized_data))
print("整体最小值：", np.min(normalized_data))
int64
float64

提升性能的关键技巧：避免常见陷阱

为了充分发挥NumPy的高效性，在实际编码中需注意以下几点优化策略。

1. 减少频繁创建新数组
在循环中不断生成小数组并拼接会导致严重性能损耗。

# 不推荐方式：每次迭代都新建数组
arr_list = []
for i in range(10000):
    arr_list.append(np.array([i]))
arr = np.concatenate(arr_list)

应预先分配内存空间，直接赋值以提高效率：

# 推荐做法：一次性声明大数组
arr = np.empty(10000)
for i in range(10000):
    arr[i] = i

2. 使用向量化操作替代Python原生循环
NumPy的向量化运算远快于逐元素遍历。

arr = np.arange(1000000)

# 慢速方法：使用Python for 循环
result1 = []
for x in arr:
    result1.append(x**2)

# 快速方案：利用NumPy内置运算
result2 = arr ** 2  # 执行速度提升约百倍
int32
float32

3. 合理选择数据类型以节省内存
默认情况下NumPy可能使用较大精度类型，可根据需求降级以减少资源占用。

arr = np.array([1,2,3], dtype=np.int32)    # 相比int64节省一半空间
arr_float = np.array([1.1, 2.2], dtype=np.float32)

4. 尽量使用视图而非副本
切片操作默认返回视图，共享原始数据内存，修改会影响原数组，避免不必要的复制开销。

arr = np.arange(10)
arr_view = arr[:5]  # 此为视图，未发生数据拷贝

六、NumPy进阶：线性代数与随机数

1. 线性代数运算（np.linalg）

在处理数值计算时，NumPy 提供了 np.linalg 模块用于执行常见的线性代数操作。例如，可以对矩阵进行求逆操作：

mat = np.array([[1,2], [3,4]])
inv_mat = np.linalg.inv(mat)
print("矩阵逆：\n", inv_mat)

此外，还可以使用 np.linalg.solve() 来求解形如 Ax = b 的线性方程组：

A = np.array([[1,2], [3,4]])
b = np.array([5, 11])
x = np.linalg.solve(A, b)
print("方程组解：", x)  # [1. 2.]

另一个重要的功能是计算矩阵的特征值和特征向量：

eigenvalues, eigenvectors = np.linalg.eig(mat)
print("特征值：", eigenvalues)
print("特征向量：\n", eigenvectors)

np.array([1,2,3])

2. 随机数生成（np.random）

NumPy 的 np.random 模块支持多种类型的随机数生成。比如，生成指定范围内的随机整数数组：

rand_int = np.random.randint(0, 10, (3,3))
print("随机整数数组：\n", rand_int)

也可以生成服从正态分布的随机数，默认均值为 0，标准差为 1：

rand_norm = np.random.normal(0, 1, (3,3))
print("正态分布数组：\n", rand_norm)

若需要对现有数组进行随机重排，可使用 np.random.shuffle() 方法：

arr = np.arange(10)
np.random.shuffle(arr)
print("打乱后数组：", arr)

上述方法广泛应用于数据预处理、模拟实验和机器学习任务中。

arr_copy = arr[:5].copy()  # 拷贝（独立内存）

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：python Numpy 数值计算 数据处理 NUM

相关内容：Python数据处理