Python机器学习常见库：掌握数据科学的四大神器

你已经配置好了环境，写下了第一行机器学习代码。现在，是时候认识你的"武器库"了——NumPy、Pandas、Matplotlib、Scikit-learn。这四个库构成了Python机器学习的核心生态，几乎所有的数据科学项目都绕不开它们。

但它们不是独立的工具，而是一个有机整体：NumPy提供数值计算基础，Pandas处理结构化数据，Matplotlib绘制可视化图表，Scikit-learn实现机器学习建模。数据在这些库之间流转，形成完整的分析链路。本章将带你深入理解每个库的核心功能与设计哲学，并通过实战项目融会贯通。准备好了吗？让我们打开这个"工具箱"！

开篇：机器学习开发者的工具箱

库之间的依赖关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
┌─────────────────────────────────────────────────────┐│                   你的机器学习项目                    │└─────────────────────────────────────────────────────┘                          ↓┌─────────────────────────────────────────────────────┐│              Scikit-learn (建模与预测)               ││    内部使用 NumPy 数组，接受 Pandas DataFrame 输入   │└─────────────────────────────────────────────────────┘            ↓                           ↓┌─────────────────────┐     ┌─────────────────────────┐│   Pandas (数据处理)  │     │  Matplotlib (可视化)    ││ 底层基于 NumPy 数组  │     │ 可直接绘制 DataFrame    │└─────────────────────┘     └─────────────────────────┘            ↓                           ↓┌─────────────────────────────────────────────────────┐│           NumPy (高性能数值计算基础层)                ││      用 C 实现的底层，提供 Python 接口               │└─────────────────────────────────────────────────────┘

这四个库是一个有机整体，不是相互独立的工具。数据通常在这四个库之间循环往复：

• • NumPy 数组 → Pandas DataFrame（加标签、加索引）
• • Pandas DataFrame → Matplotlib（可视化）
• • Pandas DataFrame → Scikit-learn（建模，自动转为 NumPy 数组）

原生 Python vs 科学计算库：性能对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 场景：计算 100 万个数的平方和# ❌ 方法1：使用 Python 原生列表和循环import time# 创建包含 100 万个数的列表python_list = list(range(1_000_000))start = time.time()result = 0for num in python_list:    result += num ** 2end = time.time()print(f"Python 循环耗时: {end - start:.4f} 秒")# Python 循环耗时: 0.2355 秒

1
2
3
4
5
6
7
8
9
10
11
12
# ✅ 方法2：使用 NumPy 向量化运算import numpy as npimport time# 创建 NumPy 数组numpy_array = np.arange(1_000_000)start = time.time()result = np.sum(numpy_array ** 2)end = time.time()print(f"NumPy 向量化耗时: {end - start:.4f} 秒")# NumPy 向量化耗时: 0.0053 秒

为什么 NumPy 这么快？

第一章：NumPy

1.1 定义

NumPy（Numerical Python）的设计围绕三个核心原则：

1. 1. 同质性（Homogeneity）：数组中所有元素必须是相同类型
2. 2. 向量化：用整体运算替代逐元素循环
3. 3. 内存效率：紧凑存储，避免 Python 对象的开销

数据结构：ndarray（N-dimensional array）

ndarray 是 NumPy 的核心，也是掌握 NumPy 的关键：

1
2
3
4
5
6
7
8
9
10
import numpy as np# 创建一个简单的一维数组arr = np.array([1, 2, 3, 4, 5])print(f"数组内容: {arr}")print(f"数组维度: {arr.ndim}")      # 预期输出: 1print(f"数组形状: {arr.shape}")     # 预期输出: (5,)print(f"数组元素类型: {arr.dtype}") # 预期输出: int64print(f"元素总数: {arr.size}")      # 预期输出: 5print(f"每个元素字节大小: {arr.itemsize}")  # 预期输出: 8

ndarray 的关键属性速查：

1.2 入门小测一份

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import numpy as np# ===== 第一步：创建数组 =====# 从列表创建data = [1, 2, 3, 4, 5]arr = np.array(data)print(f"一维数组: {arr}")# 创建二维数组（矩阵）matrix = np.array([[1, 2, 3], [4, 5, 6]])print(f"二维数组:\n{matrix}")# ===== 第二步：快速创建特殊数组 =====zeros = np.zeros((3, 4))      # 3行4列的全0数组ones = np.ones((2, 3))        # 2行3列的全1数组range_arr = np.arange(0, 10, 2)  # 等差数列: [0, 2, 4, 6, 8]linspace_arr = np.linspace(0, 1, 5)  # 0到1之间等分5个点print(f"全零数组:\n{zeros}")print(f"等差数列: {range_arr}")# ===== 第三步：数组运算 =====a = np.array([1, 2, 3])b = np.array([4, 5, 6])print(f"加法: {a + b}")        # [5, 7, 9]print(f"乘法: {a * b}")        # [4, 10, 18]print(f"平方: {a ** 2}")       # [1, 4, 9]print(f"开方: {np.sqrt(a)}")   # [1., 1.41, 1.73]# ===== 第四步：统计运算 =====data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])print(f"求和: {data.sum()}")        # 55print(f"均值: {data.mean()}")       # 5.5print(f"标准差: {data.std()}")      # 2.87print(f"最大值: {data.max()}")      # 10print(f"最小值索引: {data.argmin()}")  # 0

1.3 实例：典型应用场景

示例 1：数据生成与随机采样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import numpy as npnp.random.seed(42)  # 设置随机种子，确保结果可复现# ===== 场景：模拟学生考试成绩数据 =====n_students = 100# 生成正态分布的成绩数据# 假设平均分 75，标准差 12math_scores = np.random.normal(75, 12, n_students)english_scores = np.random.normal(70, 15, n_students)# 确保分数在 0-100 之间math_scores = np.clip(math_scores, 0, 100)english_scores = np.clip(english_scores, 0, 100)print("===== 学生成绩统计 =====")print(f"数学成绩 - 平均: {math_scores.mean():.2f}, 标准差: {math_scores.std():.2f}")print(f"英语成绩 - 平均: {english_scores.mean():.2f}, 标准差: {english_scores.std():.2f}")# 计算两科成绩的相关系数correlation = np.corrcoef(math_scores, english_scores)[0, 1]print(f"数学与英语成绩相关系数: {correlation:.3f}")# 预期输出: 相关系数约 0.0~0.3（因为是独立生成的随机数据）# 找出数学成绩前 10 名的索引top_10_indices = np.argsort(math_scores)[-10:]print(f"数学前10名成绩: {math_scores[top_10_indices]}")

示例 2：图像数据处理基础

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import numpy as np# ===== 场景：理解图像就是数组 =====# 创建一个 100x100 的灰度图像（单通道）height, width = 100, 100image = np.zeros((height, width), dtype=np.uint8)# 在中心画一个白色圆center_y, center_y = height // 2, width // 2radius = 30# 生成坐标网格（进阶：广播机制）y, x = np.ogrid[:height, :width]mask = (x - center_y)**2 + (y - center_y)**2 <= radius**2# 应用掩码image[mask] = 255print(f"图像形状: {image.shape}")print(f"图像数据类型: {image.dtype}")print(f"白色像素数量: {np.sum(image == 255)}")# 简单的图像处理：翻转image_flipped = image[::-1, :]  # 垂直翻转image_mirrored = image[:, ::-1]  # 水平镜像

示例 3：数值计算与线性代数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np# ===== 场景：线性回归的矩阵解法 =====# 线性回归的解析解: θ = (X^T X)^(-1) X^T y# 生成模拟数据np.random.seed(42)n_samples = 100n_features = 3# 特征矩阵（添加偏置列）X = np.random.randn(n_samples, n_features)X_with_bias = np.c_[np.ones(n_samples), X]  # 添加全1列作为偏置# 真实参数true_theta = np.array([2.0, 1.5, -0.8, 0.5])# 生成目标变量（添加噪声）y = X_with_bias @ true_theta + np.random.randn(n_samples) * 0.5# 使用正规方程求解# θ = (X^T X)^(-1) X^T ytheta_hat = np.linalg.inv(X_with_bias.T @ X_with_bias) @ X_with_bias.T @ yprint("===== 线性回归求解结果 =====")print(f"真实参数: {true_theta}")print(f"估计参数: {theta_hat}")print(f"参数误差: {np.abs(true_theta - theta_hat)}")# 预期输出: 估计参数应接近真实参数# 更稳定的解法（推荐）theta_hat_stable = np.linalg.lstsq(X_with_bias, y, rcond=None)[0]print(f"稳定解法结果: {theta_hat_stable}")

1.4 广播机制与内存布局

广播机制

💡 广播：让不同形状的数组进行运算的规则，无需显式复制数据。

广播规则：

1. 1. 从右向左比较各维度
2. 2. 维度相等，或其中一个为 1，则兼容
3. 3. 缺失的维度视为 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import numpy as np# 示例1：数组与标量a = np.array([1, 2, 3])b = 10print(f"数组 + 标量: {a + b}")  # [11, 12, 13]# 示例2：不同形状的数组A = np.array([[1, 2, 3],     # shape: (2, 3)              [4, 5, 6]])B = np.array([10, 20, 30])    # shape: (3,)# B 自动扩展为 [[10, 20, 30], [10, 20, 30]]print(f"矩阵 + 向量:\n{A + B}")# 示例3：列向量与行向量col = np.array([[1], [2], [3]])  # shape: (3, 1)row = np.array([10, 20])          # shape: (2,)# 结果是 (3, 2) 矩阵print(f"列向量 × 行向量:\n{col + row}")# 预期输出:# [[11, 21],#  [12, 22],#  [13, 23]]

广播过程：

1
2
3
4
5
6
7
8
9
10
数组 A (3, 1):    数组 B (1, 4):    结果 (3, 4):[[1]              [[10 20 30 40]]   [[11 21 31 41] [2]        +                      [12 22 32 42] [3]]                               [13 23 33 43]]扩展过程：A 变为:           B 变为:[[1 1 1 1]        [[10 20 30 40] [2 2 2 2]   +     [10 20 30 40] [3 3 3 3]]        [10 20 30 40]]

1.5 NumPy 常用功能

数组创建

数组操作

数学运算

统计函数

第二章：Pandas

2.1 定义

Pandas 的名字来源于 Panel Data（面板数据），由 Wes McKinney 于 2008 年开发。其设计哲学包括：

1. 1. 标签化索引：每行每列都有名字，不依赖位置索引
2. 2. 对齐机制：运算时自动对齐标签，避免错位
3. 3. 缺失值处理：内置对缺失值的优雅处理
4. 4. 表格化思维：让数据操作接近 SQL 或 Excel 的思维模式

数据结构对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import pandas as pdimport numpy as np# ===== Series：带标签的一维数组 =====# 创建一个 Seriess = pd.Series([10, 20, 30, 40],               index=['a', 'b', 'c', 'd'],              name='sales')print("===== Series 示例 =====")print(s)# 预期输出:# a    10# b    20# c    30# d    40# Name: sales, dtype: int64print(f"\n值: {s.values}")      # NumPy 数组print(f"索引: {s.index}")       # Index 对象print(f"名称: {s.name}")# ===== DataFrame：表格型数据结构 =====# 创建 DataFramedf = pd.DataFrame({    'name': ['Alice', 'Bob', 'Charlie'],    'age': [25, 30, 35],    'city': ['New York', 'London', 'Tokyo']})print("\n===== DataFrame 示例 =====")print(df)# 预期输出:#      name  age      city# 0   Alice   25  New York# 1     Bob   30    London# 2 Charlie   35     Tokyoprint(f"\n形状: {df.shape}")       # (3, 3)print(f"列名: {df.columns.tolist()}")  # ['name', 'age', 'city']print(f"索引: {df.index.tolist()}")    # [0, 1, 2]print(f"数据类型:\n{df.dtypes}")

DataFrame vs Python 字典列表对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 场景：存储学生信息# ❌ 方法1：使用字典列表students_list = [    {'name': 'Alice', 'age': 25, 'score': 85},    {'name': 'Bob', 'age': 30, 'score': 90},    {'name': 'Charlie', 'age': 35, 'score': 78}]# 获取所有年龄 - 需要循环ages = [s['age'] for s in students_list]# 计算平均分 - 需要手动计算avg_score = sum(s['score'] for s in students_list) / len(students_list)# ✅ 方法2：使用 DataFrameimport pandas as pddf = pd.DataFrame(students_list)# 获取所有年龄 - 直接取列ages = df['age']# 计算平均分 - 内置方法avg_score = df['score'].mean()# 筛选高分学生 - 链式操作high_scorers = df[df['score'] > 80]

2.2 快速入门小测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import pandas as pdimport numpy as np# ===== 第一步：创建 DataFrame =====# 从字典创建df = pd.DataFrame({    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],    'age': [25, 30, None, 35, 28],  # 包含缺失值    'department': ['Sales', 'IT', 'HR', 'IT', 'Sales'],    'salary': [50000, 70000, 45000, 80000, 55000]})# ===== 第二步：查看数据 =====print("前3行数据:")print(df.head(3))print("\n数据概览:")print(df.info())print("\n数值列统计:")print(df.describe())# ===== 第三步：数据选择 =====# 选择单列print("\n姓名列:")print(df['name'])# 选择多列print("\n姓名和薪资列:")print(df[['name', 'salary']])# 按条件筛选print("\nIT部门员工:")print(df[df['department'] == 'IT'])# 使用 loc（标签索引）和 iloc（位置索引）print("\n第2行的姓名:")print(df.loc[1, 'name'])   # 使用 locprint(df.iloc[1, 0])       # 使用 iloc# ===== 第四步：数据处理 =====# 填充缺失值df['age'] = df['age'].fillna(df['age'].mean())# 添加新列df['annual_bonus'] = df['salary'] * 0.1# 分组统计print("\n各部门平均薪资:")print(df.groupby('department')['salary'].mean())# 排序print("\n按薪资降序排列:")print(df.sort_values('salary', ascending=False))

2.3 实例：典型应用场景

示例 1：数据清洗与预处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import pandas as pdimport numpy as np# ===== 场景：清洗脏数据 =====# 创建包含各种问题的模拟数据np.random.seed(42)n = 1000data = {    'customer_id': range(1, n + 1),    'name': [f'Customer_{i}' if np.random.random() > 0.05 else None for i in range(1, n + 1)],    'age': np.random.randint(18, 70, n),    'purchase_amount': np.random.exponential(100, n),    'is_member': np.random.choice([True, False, 'True', 'False', 'Yes', 'No'], n),    'email': [f'user{i}@example.com' if np.random.random() > 0.1 else '' for i in range(n)],    'registration_date': pd.date_range('2020-01-01', periods=n, freq='D').to_list()}df = pd.DataFrame(data)# 人为添加一些异常值df.loc[10:15, 'age'] = -1  # 不合法的年龄df.loc[20:25, 'purchase_amount'] = -100  # 负的消费金额print("===== 原始数据概览 =====")print(f"数据形状: {df.shape}")print(f"缺失值统计:\n{df.isnull().sum()}")# ===== 数据清洗步骤 =====# 1. 处理缺失值print("\n步骤1: 处理缺失值")# 删除姓名缺失的行（关键信息）df_clean = df.dropna(subset=['name'])print(f"删除姓名缺失后: {df_clean.shape[0]} 行")# 2. 处理异常值print("\n步骤2: 处理异常值")# 年龄异常：设为 NaN 然后用中位数填充df_clean = df_clean.copy()df_clean.loc[df_clean['age'] < 0, 'age'] = np.nandf_clean['age'] = df_clean['age'].fillna(df_clean['age'].median())# 消费金额异常：取绝对值df_clean['purchase_amount'] = df_clean['purchase_amount'].abs()print(f"年龄范围: {df_clean['age'].min():.0f} - {df_clean['age'].max():.0f}")print(f"消费金额范围: {df_clean['purchase_amount'].min():.2f} - {df_clean['purchase_amount'].max():.2f}")# 3. 标准化布尔值print("\n步骤3: 标准化会员状态")bool_mapping = {True: True, 'True': True, 'Yes': True,                False: False, 'False': False, 'No': False}df_clean['is_member'] = df_clean['is_member'].map(bool_mapping)print(f"会员状态分布:\n{df_clean['is_member'].value_counts()}")# 4. 处理空邮箱print("\n步骤4: 处理空邮箱")df_clean.loc[df_clean['email'] == '', 'email'] = 'unknown@example.com'print(f"有效邮箱数: {(df_clean['email'] != 'unknown@example.com').sum()}")# 5. 数据类型转换df_clean['registration_date'] = pd.to_datetime(df_clean['registration_date'])print("\n===== 清洗后数据概览 =====")print(df_clean.info())print(f"\n最终数据形状: {df_clean.shape}")

示例 2：分组聚合与数据透视

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
import pandas as pdimport numpy as np# ===== 场景：销售数据分析 =====# 创建模拟销售数据np.random.seed(42)dates = pd.date_range('2023-01-01', '2023-12-31', freq='D')products = ['Laptop', 'Phone', 'Tablet', 'Watch']regions = ['North', 'South', 'East', 'West']data = {    'date': np.random.choice(dates, 1000),    'product': np.random.choice(products, 1000),    'region': np.random.choice(regions, 1000),    'quantity': np.random.randint(1, 10, 1000),    'unit_price': np.random.choice([500, 300, 200, 150], 1000)}df = pd.DataFrame(data)df['total_sales'] = df['quantity'] * df['unit_price']print("===== 原始销售数据 =====")print(df.head())# ===== 分组聚合分析 =====# 1. 单列分组print("\n===== 各产品销售总额 =====")product_sales = df.groupby('product')['total_sales'].agg(['sum', 'mean', 'count'])product_sales.columns = ['总销售额', '平均订单额', '订单数']print(product_sales)# 2. 多列分组print("\n===== 各地区各产品销售统计 =====")region_product = df.groupby(['region', 'product'])['total_sales'].sum().unstack()print(region_product)# 3. 多种聚合函数print("\n===== 各产品详细统计 =====")product_stats = df.groupby('product').agg({    'quantity': ['sum', 'mean'],    'total_sales': ['sum', 'mean', 'std'],    'unit_price': 'mean'})print(product_stats)# ===== 数据透视表 =====print("\n===== 数据透视表：各地区各产品销售额 =====")pivot_table = pd.pivot_table(    df,     values='total_sales',    index='region',    columns='product',    aggfunc='sum',    margins=True,  # 添加合计    margins_name='Total')print(pivot_table)# ===== 时间序列分析 =====print("\n===== 月度销售趋势 =====")df['month'] = df['date'].dt.to_period('M')monthly_sales = df.groupby('month')['total_sales'].sum()print(monthly_sales.head())# 转换为 datetime 索引并重采样df_time = df.set_index('date')monthly_resample = df_time.resample('M')['total_sales'].sum()print("\n使用重采样:")print(monthly_resample.head())

示例 3：数据合并与连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import pandas as pd# ===== 场景：电商订单数据分析 =====# 订单表orders = pd.DataFrame({    'order_id': [1, 2, 3, 4, 5],    'customer_id': [101, 102, 101, 103, 102],    'order_date': pd.to_datetime(['2023-01-01', '2023-01-02', '2023-01-03',                                    '2023-01-04', '2023-01-05']),    'total_amount': [150, 200, 300, 100, 250]})# 客户表customers = pd.DataFrame({    'customer_id': [101, 102, 103, 104],    'name': ['Alice', 'Bob', 'Charlie', 'David'],    'email': ['alice@email.com', 'bob@email.com', 'charlie@email.com', 'david@email.com'],    'city': ['New York', 'London', 'Tokyo', 'Paris']})# 产品订单明细表order_items = pd.DataFrame({    'order_id': [1, 1, 2, 3, 3, 4, 5],    'product_id': ['P1', 'P2', 'P1', 'P2', 'P3', 'P1', 'P2'],    'quantity': [2, 1, 3, 1, 2, 1, 2],    'price': [50, 50, 50, 100, 100, 100, 125]})print("===== 原始表 =====")print("订单表:")print(orders)print("\n客户表:")print(customers)print("\n订单明细表:")print(order_items)# ===== 合并操作 =====# 1. 内连接print("\n===== 内连接：订单 + 客户信息 =====")orders_with_customer = pd.merge(    orders,     customers,     on='customer_id',     how='inner')print(orders_with_customer)# 2. 左连接（保留所有订单，即使没有客户信息）print("\n===== 左连接：保留所有订单 =====")orders_all = pd.merge(    orders,    customers,    on='customer_id',    how='left')print(orders_all)# 3. 多表连接print("\n===== 三表连接：完整订单信息 =====")complete_orders = (orders                   .merge(customers, on='customer_id', how='left')                   .merge(order_items, on='order_id', how='left'))print(complete_orders)# 4. 拼接操作print("\n===== 纵向拼接订单数据 =====")orders_jan = orders[orders['order_date'].dt.month == 1]# 假设有2月数据orders_feb = pd.DataFrame({    'order_id': [6, 7],    'customer_id': [101, 103],    'order_date': pd.to_datetime(['2023-02-01', '2023-02-02']),    'total_amount': [180, 220]})all_orders = pd.concat([orders_jan, orders_feb], ignore_index=True)print(all_orders)

2.4 Pandas 常用功能速查表

数据读取与写入

数据选择

数据清洗

分组与聚合

第三章：Matplotlib

3.1 定义

Matplotlib 由 John D. Hunter 于 2003 年创建，设计灵感来自 MATLAB。其核心设计原则：

1. 1. 渐进式复杂度：简单的事情简单做，复杂的事情能做
2. 2. 面向对象：所有图形元素都是对象，可精细控制
3. 3. 出版级质量：支持多种输出格式，满足学术出版需求

对象模型

理解 Matplotlib 的关键是理解其对象层级结构：

1
2
3
4
5
6
7
8
9
Figure (整个图形窗口)├── Axes (单个子图/绑图区域)  ← 最核心的对象│   ├── XAxis, YAxis (坐标轴)│   │   ├── Tick (刻度)│   │   └── Label (轴标签)│   ├── Legend (图例)│   ├── Title (标题)│   └── 各种绘图元素 (Line2D, Patch, Text, Image, etc.)└── 其他子图...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import matplotlib.pyplot as pltimport numpy as np# ===== 理解 Figure 和 Axes =====# 创建 Figure 和 Axesfig, ax = plt.subplots(figsize=(8, 6))# 查看对象类型print(f"Figure 类型: {type(fig)}")print(f"Axes 类型: {type(ax)}")# 创建示例数据x = np.linspace(0, 2*np.pi, 100)y = np.sin(x)# 在 Axes 上绘图ax.plot(x, y, label='sin(x)', color='blue', linewidth=2)ax.set_xlabel('X 轴')ax.set_ylabel('Y 轴')ax.set_title('正弦函数图像')ax.legend()ax.grid(True, alpha=0.3)# 显示图形plt.tight_layout()plt.show()# 保存图形fig.savefig('sine_wave.png', dpi=150, bbox_inches='tight')print("图形已保存为 sine_wave.png")

3.2 快速入门小测验

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import matplotlib.pyplot as pltimport numpy as np# 设置中文显示（重要！）plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']plt.rcParams['axes.unicode_minus'] = False# ===== 方式1：快速绘图（ pyplot 接口）=====x = np.linspace(0, 10, 50)y = np.sin(x)plt.figure(figsize=(10, 4))plt.plot(x, y, 'b-', label='sin(x)')plt.plot(x, np.cos(x), 'r--', label='cos(x)')plt.xlabel('X 轴')plt.ylabel('Y 轴')plt.title('三角函数')plt.legend()plt.grid(True)plt.show()# ===== 方式2：面向对象接口（推荐）=====fig, axes = plt.subplots(1, 2, figsize=(12, 4))# 子图1：折线图axes[0].plot(x, y, 'b-', linewidth=2)axes[0].set_title('折线图')axes[0].set_xlabel('X')axes[0].set_ylabel('sin(X)')# 子图2：散点图axes[1].scatter(x, y, c=x, cmap='viridis', s=50)axes[1].set_title('散点图（颜色映射X值）')axes[1].set_xlabel('X')plt.tight_layout()plt.show()

3.3 实例：常见图表类型

示例 1：探索性数据分析图表