【Python数据分析】速通NumPy

文章目录

• [一、为什么要学 NumPy？​](#一、为什么要学 NumPy？)
• 二、环境配置
• [三、基础操作：创建 ndarray 数组](#三、基础操作：创建 ndarray 数组)
• 四、必懂：数组的核心属性
• 五、实用技巧：索引与切片（取数据的核心）
• 六、核心运算：不用循环的批量操作
• 七、神奇的广播机制（自动适配形状）​

一、为什么要学 NumPy？​

Python 自带的列表（list）虽然好用，但处理数值计算时效率太低 ------ 比如想给列表里所有元素乘 2，得写 for 循环；想做矩阵运算，更是麻烦。而 NumPy（Numerical Python）就是为解决这些问题而生的：​

核心是「ndarray」（N 维数组），存储和计算速度远超列表；​

支持向量 / 矩阵运算，不用写循环，一行代码搞定批量操作；​

是 Pandas、Matplotlib、Scikit-learn 等数据分析 / 机器学习库的基础，学会 NumPy，后续学习会事半功倍。​

一句话总结：做 Python 数值计算，NumPy 是必备工具！先记住固定导入方式：

import numpy as np  # 行业约定简写为np，所有人都这么用～

二、环境配置

这里简单的给出Pycharm配置conda环境的步骤：

Anaconda建议从国内的清华源快速下载：https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/

这里不介绍具体的下载安装过程了，不会的可自行搜索即可

三、基础操作：创建 ndarray 数组

创建数组是第一步，分享 6 种日常最常用的方式，覆盖 80% 使用场景：

1. 从 Python 列表 / 元组转换（最直观）

# 一维数组（类似列表，但无逗号分隔）
arr1 = np.array([1, 2, 3, 4, 5])
arr1_tuple = np.array((6, 7, 8))  # 元组也能转
print("一维数组：", arr1)  # 输出：[1 2 3 4 5]

# 二维数组（类似表格/矩阵，嵌套列表）
arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("二维数组：\n", arr2)
# 输出：
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

# 指定元素类型（默认int/float，可手动指定）
arr_float = np.array([1, 2, 3], dtype=np.float32)
print("浮点型数组：", arr_float)  # 输出：[1. 2. 3.]

2. 快速生成特定数组（实用高频）

# 全0数组（初始化数据常用）
zero_arr = np.zeros((2, 4))  # 形状：2行4列，默认float类型
print("全0数组：\n", zero_arr)

# 全1数组（比如初始化权重）
one_arr = np.ones((3, 3), dtype=np.int64)  # 指定int类型
print("全1数组：\n", one_arr)

# 连续整数数组（替代range，返回数组）
range_arr = np.arange(5, 15, 2)  # 起始5，结束15（不含），步长2
print("连续整数数组：", range_arr)  # 输出：[ 5  7  9 11 13]

# 等间隔数组（指定个数，比如画图表时取点）
linspace_arr = np.linspace(0, 10, 6)  # 0到10，分成6个均匀数
print("等间隔数组：", linspace_arr)  # 输出：[ 0.  2.  4.  6.  8. 10.]

# 随机数组（模拟数据常用）
np.random.seed(123)  # 设随机种子，保证结果可重复
rand_arr = np.random.rand(2, 3)  # 2行3列，0~1之间的随机数
rand_int_arr = np.random.randint(10, 20, size=(3, 2))  # 3行2列，10~20的随机整数
print("0~1随机数组：\n", rand_arr)
print("10~20随机整数数组：\n", rand_int_arr)

四、必懂：数组的核心属性

拿到数组后，先看这 4 个属性，快速了解数组 "底细"：

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

print("数组形状（行数, 列数）：", arr.shape)  # 输出：(3, 3) → 3行3列
print("数组维度：", arr.ndim)  # 输出：2 → 二维数组（1=一维，3=三维）
print("数组元素总数：", arr.size)  # 输出：9 → 3×3=9个元素
print("元素数据类型：", arr.dtype)  # 输出：int64 → 可通过dtype参数修改

五、实用技巧：索引与切片（取数据的核心）

和列表类似，但支持多维索引，日常最常用二维数组的 "取行、取列、取子数组"，还有超实用的 "条件索引"：

1. 基础索引（取单个元素）

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

# 语法：arr[行索引, 列索引]（索引从0开始！）
print("第2行第3列元素：", arr[1, 2])  # 输出：6（行1=第2行，列2=第3列）
print("第1行所有元素：", arr[0])  # 输出：[1 2 3]

2. 切片（取连续元素）

# 语法：arr[行切片, 列切片]，切片规则：[起始:结束:步长]（结束不包含）
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

# 取前2行，所有列
row_slice = arr[:2, :]  # 行：0~1（不含2），列：所有（:表示全部）
print("前2行：\n", row_slice)

# 取所有行，第2-3列（索引1~2）
col_slice = arr[:, 1:3]
print("第2-3列：\n", col_slice)

# 取子数组：第2-3行，第3-4列
sub_arr = arr[1:, 2:]
print("子数组：\n", sub_arr)

# 步长切片：隔一行取一行，隔一列取一列
step_slice = arr[::2, ::2]  # 行步长2，列步长2
print("步长切片结果：\n", step_slice)  # 输出：[[1 3] [9 11]]

3. 条件索引（筛选数据超实用）
   根据条件筛选元素，不用写 for 循环，一行搞定：

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

# 筛选出所有大于5的元素
mask = arr > 5  # 先得到布尔数组（True/False）
print("布尔掩码：\n", mask)
print("大于5的元素：", arr[mask])  # 输出：[6 7 8 9]

# 一行简写（常用）
print("大于3且小于8的元素：", arr[(arr > 3) & (arr < 8)])  # 输出：[4 5 6 7]

六、核心运算：不用循环的批量操作

这是 NumPy 的灵魂！所有运算都支持 "向量化"，直接作用于整个数组：​

1. 元素级运算（逐个元素计算）

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

# 加减乘除（对应元素运算）
print("arr1 + arr2 =", arr1 + arr2)  # 输出：[ 6  8 10 12]
print("arr2 - arr1 =", arr2 - arr1)  # 输出：[4 4 4 4]
print("arr1 * arr2 =", arr1 * arr2)  # 输出：[ 5 12 21 32]
print("arr2 / arr1 =", arr2 / arr1)  # 输出：[5.  3.  2.333... 2.]

# 与标量运算（所有元素都参与）
print("arr1 * 10 =", arr1 * 10)  # 输出：[10 20 30 40]
print("arr2 + 2 =", arr2 + 2)    # 输出：[7 8 9 10]

2. 矩阵运算（线性代数常用）

# 矩阵乘法（行×列）：用 np.dot() 或 @ 符号
mat1 = np.array([[1, 2], [3, 4]])  # 2行2列
mat2 = np.array([[5, 6], [7, 8]])  # 2行2列

mat_mult = mat1 @ mat2  # 等价于 np.dot(mat1, mat2)
print("矩阵乘法结果：\n", mat_mult)
# 输出：
# [[19 22]
#  [43 50]]

# 矩阵转置（行变列，列变行）
mat_trans = mat1.T
print("mat1转置：\n", mat_trans)
# 输出：
# [[1 3]
#  [2 4]]

3. 形状调整（reshape）
   改变数组形状，不改变元素（注意：元素总数要匹配）：

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

# 改成2行3列
arr_reshape1 = arr.reshape(2, 3)
print("2行3列：\n", arr_reshape1)

# 改成3行2列
arr_reshape2 = arr.reshape(3, 2)
print("3行2列：\n", arr_reshape2)

# 自动计算列数（用-1表示）
arr_reshape3 = arr.reshape(2, -1)  # 固定2行，列数自动算（6/2=3）
print("自动计算列数：\n", arr_reshape3)

4. 统计运算（数据分析常用）

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

# 全局统计
print("总和：", arr.sum())        # 输出：45
print("均值：", arr.mean())       # 输出：5.0
print("最大值：", arr.max())      # 输出：9
print("最小值：", arr.min())      # 输出：1
print("标准差：", arr.std())      # 输出：2.5819...（离散程度）

# 按行/列统计（关键：axis参数）
print("每列总和：", arr.sum(axis=0))  # axis=0 → 按列运算
print("每行均值：", arr.mean(axis=1))  # axis=1 → 按行运算

七、神奇的广播机制（自动适配形状）​

当两个数组形状不同时，NumPy 会自动 "扩展" 数组，让它们能进行元素级运算，不用手动调整形状：

# 例子1：2行3列数组 + 1行3列数组
arr1 = np.array([[1, 2, 3], [4, 5, 6]])  # 2×3
arr2 = np.array([10, 20, 30])            # 1×3
print("广播加法：\n", arr1 + arr2)
# 输出：
# [[11 22 33]
#  [14 25 36]]

# 例子2：3行2列数组 + 3行1列数组
arr3 = np.array([[1], [2], [3]])  # 3×1
arr4 = np.array([[10, 20], [30, 40], [50, 60]])  # 3×2
print("广播乘法：\n", arr4 * arr3)
# 输出：
# [[ 10  20]
#  [ 60  80]
#  [150 180]]