Python Matplotlib面试题精选及参考答案

绘制函数 y=2x+5 在区间 [1,10] 的折线图，设置标题和坐标轴标签

要绘制函数 y = 2x + 5 在区间 [1, 10] 的折线图，并设置标题和坐标轴标签，可借助 Python 的 matplotlib 库来实现。以下是详细的实现步骤与代码示例。 首先，要导入 matplotlib.pyplot 库，它能帮助我们绘制图形，同时导入 numpy 库，它可用于生成数据。接着，利用 numpy 的 linspace 函数生成区间 [1, 10] 内的 100 个等间距的 x 值，再依据函数 y = 2x + 5 计算对应的 y 值。然后，使用 matplotlib.pyplot 的 plot 函数绘制折线图。之后，使用 title 函数为图形添加标题，使用 xlabel 和 ylabel 函数分别为 x 轴和 y 轴添加标签。最后，使用 show 函数显示图形。

import matplotlib.pyplot as plt
import numpy as np

# 生成 x 值
x = np.linspace(1, 10, 100)

# 计算对应的 y 值
y = 2 * x + 5

# 绘制折线图
plt.plot(x, y)

# 设置标题和坐标轴标签
plt.title('Plot of y = 2x + 5')
plt.xlabel('x')
plt.ylabel('y')

# 显示图形
plt.show()

在上述代码里，np.linspace(1, 10, 100) 生成了 100 个从 1 到 10 的等间距的 x 值，y = 2 * x + 5 计算出对应的 y 值。plt.plot(x, y) 绘制了折线图，plt.title('Plot of y = 2x + 5') 设置了图形的标题，plt.xlabel('x') 和 plt.ylabel('y') 分别设置了 x 轴和 y 轴的标签，最后 plt.show() 显示图形。

在同一图中绘制 sin (x) 和 cos (x) 曲线，添加图例和网格线（x∈[0,2π]）

要在同一图中绘制 sin(x) 和 cos(x) 曲线，并且添加图例和网格线，可使用 matplotlib 库。以下是实现的步骤与代码示例。 首先，导入 matplotlib.pyplot 和 numpy 库。接着，使用 numpy 的 linspace 函数生成区间 [0, 2π] 内的 100 个等间距的 x 值，再分别计算 sin(x) 和 cos(x) 的值。然后，使用 plot 函数分别绘制 sin(x) 和 cos(x) 曲线，在绘制时通过 label 参数指定每条曲线的标签。之后，使用 legend 函数添加图例，使用 grid 函数添加网格线。最后，使用 show 函数显示图形。

import matplotlib.pyplot as plt
import numpy as np

# 生成 x 值
x = np.linspace(0, 2 * np.pi, 100)

# 计算 sin(x) 和 cos(x) 的值
y_sin = np.sin(x)
y_cos = np.cos(x)

# 绘制 sin(x) 和 cos(x) 曲线
plt.plot(x, y_sin, label='sin(x)')
plt.plot(x, y_cos, label='cos(x)')

# 添加图例和网格线
plt.legend()
plt.grid(True)

# 设置标题和坐标轴标签
plt.title('Plot of sin(x) and cos(x)')
plt.xlabel('x')
plt.ylabel('y')

# 显示图形
plt.show()

在上述代码中，np.linspace(0, 2 * np.pi, 100) 生成了 100 个从 0 到 2π 的等间距的 x 值，np.sin(x) 和 np.cos(x) 分别计算出 sin(x) 和 cos(x) 的值。plt.plot(x, y_sin, label='sin(x)') 和 plt.plot(x, y_cos, label='cos(x)') 分别绘制了 sin(x) 和 cos(x) 曲线，并指定了标签。plt.legend() 添加了图例，plt.grid(True) 添加了网格线，plt.title('Plot of sin(x) and cos(x)') 设置了图形的标题，plt.xlabel('x') 和 plt.ylabel('y') 分别设置了 x 轴和 y 轴的标签，最后 plt.show() 显示图形。

绘制分段函数：当 x<0 时 y=0，x≥0 时 y=x²，设置不同线段颜色

要绘制分段函数 y = 0 (x < 0); y = x² (x ≥ 0) 并设置不同线段颜色，可使用 matplotlib 库。以下是实现步骤与代码示例。 首先，导入 matplotlib.pyplot 和 numpy 库。接着，使用 numpy 的 linspace 函数分别生成 x < 0 和 x ≥ 0 的 x 值，再根据分段函数的定义计算对应的 y 值。然后，使用 plot 函数分别绘制 x < 0 和 x ≥ 0 的线段，并通过 color 参数设置不同的颜色。之后，使用 title 函数为图形添加标题，使用 xlabel 和 ylabel 函数分别为 x 轴和 y 轴添加标签。最后，使用 show 函数显示图形。

import matplotlib.pyplot as plt
import numpy as np

# 生成 x < 0 的 x 值
x1 = np.linspace(-5, 0, 100, endpoint=False)
y1 = np.zeros_like(x1)

# 生成 x >= 0 的 x 值
x2 = np.linspace(0, 5, 100)
y2 = x2 ** 2

# 绘制分段函数
plt.plot(x1, y1, color='blue', label='y = 0 (x < 0)')
plt.plot(x2, y2, color='red', label='y = x² (x ≥ 0)')

# 添加图例
plt.legend()

# 设置标题和坐标轴标签
plt.title('Piecewise Function Plot')
plt.xlabel('x')
plt.ylabel('y')

# 显示图形
plt.show()

在上述代码中，np.linspace(-5, 0, 100, endpoint=False) 生成了 100 个从 -5 到 0（不包含 0）的 x 值，np.zeros_like(x1) 生成了对应的 y 值为 0。np.linspace(0, 5, 100) 生成了 100 个从 0 到 5 的 x 值，x2 ** 2 计算出对应的 y 值。plt.plot(x1, y1, color='blue', label='y = 0 (x < 0)') 和 plt.plot(x2, y2, color='red', label='y = x² (x ≥ 0)') 分别绘制了 x < 0 和 x ≥ 0 的线段，并设置了不同的颜色和标签。plt.legend() 添加了图例，plt.title('Piecewise Function Plot') 设置了图形的标题，plt.xlabel('x') 和 plt.ylabel('y') 分别设置了 x 轴和 y 轴的标签，最后 plt.show() 显示图形。

绘制带数据点的折线图，使用红色虚线样式和圆形标记（数据点自定）

要绘制带数据点的折线图，使用红色虚线样式和圆形标记，可使用 matplotlib 库。以下是实现步骤与代码示例。 首先，导入 matplotlib.pyplot 库。接着，定义一组自定义的数据点，分别作为 x 轴和 y 轴的值。然后，使用 plot 函数绘制折线图，通过 linestyle 参数设置为 '--' 表示虚线样式，通过 color 参数设置为 'red' 表示红色，通过 marker 参数设置为 'o' 表示圆形标记。之后，使用 title 函数为图形添加标题，使用 xlabel 和 ylabel 函数分别为 x 轴和 y 轴添加标签。最后，使用 show 函数显示图形。

import matplotlib.pyplot as plt

# 自定义数据点
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# 绘制带数据点的折线图
plt.plot(x, y, linestyle='--', color='red', marker='o')

# 设置标题和坐标轴标签
plt.title('Dashed Line Plot with Data Points')
plt.xlabel('x')
plt.ylabel('y')

# 显示图形
plt.show()

在上述代码中，x = [1, 2, 3, 4, 5] 和 y = [2, 4, 6, 8, 10] 定义了数据点。plt.plot(x, y, linestyle='--', color='red', marker='o') 绘制了折线图，设置了虚线样式、红色和圆形标记。plt.title('Dashed Line Plot with Data Points') 设置了图形的标题，plt.xlabel('x') 和 plt.ylabel('y') 分别设置了 x 轴和 y 轴的标签，最后 plt.show() 显示图形。

绘制对数坐标下的指数函数 y=10^x（x∈[1,5]）

要绘制对数坐标下的指数函数 y = 10^x 在区间 [1, 5] 的图形，可使用 matplotlib 库。以下是实现步骤与代码示例。 首先，导入 matplotlib.pyplot 和 numpy 库。接着，使用 numpy 的 linspace 函数生成区间 [1, 5] 内的 100 个等间距的 x 值，再根据指数函数 y = 10^x 计算对应的 y 值。然后，使用 plot 函数绘制折线图。之后，使用 yscale 函数将 y 轴设置为对数坐标。再使用 title 函数为图形添加标题，使用 xlabel 和 ylabel 函数分别为 x 轴和 y 轴添加标签。最后，使用 show 函数显示图形。

import matplotlib.pyplot as plt
import numpy as np

# 生成 x 值
x = np.linspace(1, 5, 100)

# 计算对应的 y 值
y = 10 ** x

# 绘制折线图
plt.plot(x, y)

# 设置 y 轴为对数坐标
plt.yscale('log')

# 设置标题和坐标轴标签
plt.title('Exponential Function y = 10^x in Logarithmic Scale')
plt.xlabel('x')
plt.ylabel('y')

# 显示图形
plt.show()

在上述代码中，np.linspace(1, 5, 100) 生成了 100 个从 1 到 5 的等间距的 x 值，10 ** x 计算出对应的 y 值。plt.plot(x, y) 绘制了折线图，plt.yscale('log') 将 y 轴设置为对数坐标。plt.title('Exponential Function y = 10^x in Logarithmic Scale') 设置了图形的标题，plt.xlabel('x') 和 plt.ylabel('y') 分别设置了 x 轴和 y 轴的标签，最后 plt.show() 显示图形。

实现动态绘制正弦曲线（逐步添加数据点模拟动画效果）

在 Python 中，我们可以使用 matplotlib 库的 animation 模块来实现动态绘制正弦曲线的效果。其核心思路是逐步添加数据点，通过不断更新图形来模拟动画。

首先，我们需要导入必要的库，包括 matplotlib.pyplot 用于绘图，matplotlib.animation 用于创建动画，以及 numpy 用于生成数据。

接下来，定义一个初始化函数 init，用于初始化图形。在这个函数中，我们设置坐标轴的范围，并创建一个空的线条对象，用于后续更新数据。

然后，定义一个更新函数 update，该函数会在每一帧被调用。在函数内部，我们逐步生成新的正弦数据点，并将其添加到现有的数据列表中，然后更新线条对象的数据。

最后，使用 FuncAnimation 函数创建动画对象，并将其保存或显示出来。

以下是实现代码：

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# 创建图形和坐标轴
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = ax.plot([], [], 'r-', animated=True)

# 初始化函数
def init():
    ax.set_xlim(0, 2*np.pi)
    ax.set_ylim(-1, 1)
    return ln,

# 更新函数
def update(frame):
    x = frame * 0.01
    y = np.sin(x)
    xdata.append(x)
    ydata.append(y)
    ln.set_data(xdata, ydata)
    return ln,

# 创建动画
ani = animation.FuncAnimation(fig, update, frames=range(628),
                              init_func=init, blit=True)

# 显示动画
plt.show()

在上述代码中，init 函数设置了坐标轴的范围，update 函数不断生成新的正弦数据点并更新线条对象。FuncAnimation 函数通过不断调用 update 函数来创建动画。

在折线图中添加垂直参考线（x=π）和水平参考线（y=0.5）

在 matplotlib 中，我们可以使用 axvline 和 axhline 函数来添加垂直和水平参考线。

首先，我们需要导入 matplotlib.pyplot 和 numpy 库。然后，生成一些数据用于绘制折线图。接着，使用 plot 函数绘制折线图。

之后，使用 axvline 函数添加垂直参考线，指定 x 值为 π，并可以设置线条的颜色、样式等属性。使用 axhline 函数添加水平参考线，指定 y 值为 0.5，并同样可以设置线条的属性。

最后，添加标题和坐标轴标签，并显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

# 绘制折线图
plt.plot(x, y)

# 添加垂直参考线
plt.axvline(x=np.pi, color='r', linestyle='--', label='x = π')

# 添加水平参考线
plt.axhline(y=0.5, color='g', linestyle='--', label='y = 0.5')

# 添加标题和标签
plt.title('Sine Curve with Reference Lines')
plt.xlabel('x')
plt.ylabel('y')

# 添加图例
plt.legend()

# 显示图形
plt.show()

在上述代码中，axvline 函数添加了垂直参考线，axhline 函数添加了水平参考线，通过设置不同的颜色和样式，使参考线更加明显。

绘制带有误差线的实验数据折线图（自定义误差范围）

绘制带有误差线的折线图可以帮助我们直观地展示实验数据的不确定性。在 matplotlib 中，我们可以使用 errorbar 函数来实现。

首先，导入必要的库，包括 matplotlib.pyplot 和 numpy。然后，自定义实验数据和误差范围。

接着，使用 errorbar 函数绘制带有误差线的折线图，该函数接受 x 轴数据、y 轴数据和误差范围作为参数，并可以设置误差线的颜色、样式等属性。

最后，添加标题和坐标轴标签，并显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 自定义实验数据
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])

# 自定义误差范围
y_err = np.array([0.5, 0.3, 0.6, 0.4, 0.7])

# 绘制带有误差线的折线图
plt.errorbar(x, y, yerr=y_err, fmt='o-', color='b', ecolor='r', capsize=5)

# 添加标题和标签
plt.title('Experimental Data with Error Bars')
plt.xlabel('x')
plt.ylabel('y')

# 显示图形
plt.show()

在上述代码中，errorbar 函数的 yerr 参数指定了误差范围，fmt 参数设置了数据点和线条的样式，ecolor 参数设置了误差线的颜色，capsize 参数设置了误差线末端的横线长度。

使用随机生成的数据绘制趋势平滑曲线（应用 Savitzky-Golay 滤波器）

Savitzky-Golay 滤波器是一种常用的平滑滤波器，可以用于去除数据中的噪声，提取数据的趋势。在 Python 中，我们可以使用 scipy.signal 库中的 savgol_filter 函数来实现。

首先，导入必要的库，包括 matplotlib.pyplot、numpy 和 scipy.signal。然后，随机生成一些数据。

接着，使用 savgol_filter 函数对数据进行平滑处理，该函数接受数据、窗口长度和多项式阶数作为参数。

最后，绘制原始数据和平滑后的数据，并添加标题和坐标轴标签，显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np
from scipy.signal import savgol_filter

# 随机生成数据
x = np.linspace(0, 10, 100)
y = np.random.randn(100) + np.sin(x)

# 应用 Savitzky-Golay 滤波器进行平滑处理
y_smooth = savgol_filter(y, window_length=11, polyorder=3)

# 绘制原始数据和平滑后的数据
plt.plot(x, y, label='Original Data')
plt.plot(x, y_smooth, label='Smoothed Data')

# 添加标题和标签
plt.title('Smoothing Data with Savitzky-Golay Filter')
plt.xlabel('x')
plt.ylabel('y')

# 添加图例
plt.legend()

# 显示图形
plt.show()

在上述代码中，savgol_filter 函数的 window_length 参数指定了窗口长度，polyorder 参数指定了多项式阶数。通过调整这两个参数，可以得到不同程度的平滑效果。

绘制双 Y 轴折线图，左右轴分别表示温度和湿度变化

在 matplotlib 中，我们可以使用 twinx 函数来创建双 Y 轴折线图。

首先，导入必要的库，包括 matplotlib.pyplot 和 numpy。然后，生成温度和湿度的数据。

接着，创建一个坐标轴对象 ax1，并使用 plot 函数绘制温度数据。然后，使用 twinx 函数创建一个共享 x 轴的新坐标轴对象 ax2，并使用 plot 函数绘制湿度数据。

为了区分两条曲线，可以设置不同的颜色和标签。最后，添加标题和坐标轴标签，并显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.linspace(0, 10, 100)
temperature = np.sin(x)
humidity = np.cos(x)

# 创建图形和坐标轴
fig, ax1 = plt.subplots()

# 绘制温度数据
color = 'tab:red'
ax1.set_xlabel('Time')
ax1.set_ylabel('Temperature (°C)', color=color)
ax1.plot(x, temperature, color=color)
ax1.tick_params(axis='y', labelcolor=color)

# 创建第二个 Y 轴
ax2 = ax1.twinx()

# 绘制湿度数据
color = 'tab:blue'
ax2.set_ylabel('Humidity (%)', color=color)
ax2.plot(x, humidity, color=color)
ax2.tick_params(axis='y', labelcolor=color)

# 添加标题
plt.title('Temperature and Humidity Changes')

# 显示图形
plt.show()

在上述代码中，twinx 函数创建了一个共享 x 轴的新坐标轴对象，通过设置不同的颜色和标签，清晰地区分了温度和湿度两条曲线。

在折线图中高亮显示最大值和最小值点

在绘制折线图时，高亮显示最大值和最小值点能够让数据的关键特征更加清晰地呈现出来。在 Python 的 matplotlib 库中，我们可以借助一些简单的步骤来实现这一功能。

首先，我们需要导入必要的库，包括 matplotlib.pyplot 用于绘图，numpy 用于生成数据。接着，我们要生成一组用于绘制折线图的数据，然后找出这组数据中的最大值和最小值及其对应的索引。之后，使用 plot 函数绘制折线图，再使用 scatter 函数分别将最大值和最小值点以不同的颜色或样式突出显示出来。最后，为了增强可视化效果，还可以添加图例、标题和坐标轴标签。

以下是实现该功能的代码示例：

import matplotlib.pyplot as plt
import numpy as np

# 生成示例数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 找出最大值和最小值及其索引
max_index = np.argmax(y)
min_index = np.argmin(y)
max_value = y[max_index]
min_value = y[min_index]

# 绘制折线图
plt.plot(x, y, label='Line Plot')

# 高亮显示最大值点
plt.scatter(x[max_index], max_value, color='red', s=100, label='Max Value')

# 高亮显示最小值点
plt.scatter(x[min_index], min_value, color='green', s=100, label='Min Value')

# 添加图例、标题和坐标轴标签
plt.legend()
plt.title('Line Plot with Highlighted Max and Min Points')
plt.xlabel('X')
plt.ylabel('Y')

# 显示图形
plt.show()

在上述代码中，np.argmax(y) 和 np.argmin(y) 分别用于找出 y 数组中最大值和最小值的索引。scatter 函数用于绘制散点图，通过设置不同的颜色和大小，将最大值和最小值点与折线图区分开来。

绘制带有填充色的区域图（如 sin (x) 与 x 轴之间的区域）

绘制带有填充色的区域图可以直观地展示函数与坐标轴之间的关系。对于 sin(x) 与 x 轴之间的区域，我们可以使用 matplotlib 中的 fill_between 函数来实现。

首先，导入 matplotlib.pyplot 和 numpy 库。然后，生成 x 轴的数据和对应的 sin(x) 函数值。接着，使用 fill_between 函数填充 sin(x) 与 x 轴之间的区域，并设置填充颜色和透明度。最后，添加标题和坐标轴标签，显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成 x 轴数据
x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)

# 绘制填充区域图
plt.fill_between(x, y, color='blue', alpha=0.3)

# 添加标题和坐标轴标签
plt.title('Filled Area between sin(x) and x-axis')
plt.xlabel('X')
plt.ylabel('Y')

# 显示图形
plt.show()

在这段代码中，fill_between 函数的第一个参数是 x 轴的数据，第二个参数是 y 轴的数据，color 参数用于设置填充颜色，alpha 参数用于设置透明度。通过调整这些参数，可以得到不同的填充效果。

实现折线图的交互式提示（鼠标悬停显示数值）

为了实现折线图的交互式提示功能，即鼠标悬停在数据点上时显示该点的数值，我们可以使用 matplotlib 的 mplcursors 库。

首先，安装 mplcursors 库（如果尚未安装）。然后，导入必要的库，包括 matplotlib.pyplot 和 mplcursors。接着，生成数据并绘制折线图。最后，使用 mplcursors.cursor 函数创建一个光标对象，并设置其显示格式。

以下是实现代码：

import matplotlib.pyplot as plt
import mplcursors
import numpy as np

# 生成示例数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 绘制折线图
line, = plt.plot(x, y)

# 创建光标对象
cursor = mplcursors.cursor(line, hover=True)

# 设置显示格式
@cursor.connect("add")
def on_add(sel):
    x, y = sel.target
    sel.annotation.set_text(f"({x:.2f}, {y:.2f})")

# 添加标题和坐标轴标签
plt.title('Interactive Line Plot with Tooltips')
plt.xlabel('X')
plt.ylabel('Y')

# 显示图形
plt.show()

在上述代码中，mplcursors.cursor(line, hover=True) 创建了一个鼠标悬停时触发的光标对象。@cursor.connect("add") 装饰器用于定义当鼠标悬停在数据点上时的回调函数，该函数会在注释框中显示该点的坐标。

绘制时间序列数据折线图，横轴为日期格式

当处理时间序列数据时，将横轴设置为日期格式可以更直观地展示数据随时间的变化。在 matplotlib 中，我们可以使用 pandas 库来处理日期数据，并使用 matplotlib 绘制折线图。

首先，导入 matplotlib.pyplot、pandas 和 numpy 库。然后，创建一个包含日期和数据的 pandas DataFrame。接着，将日期列转换为 datetime 类型，并设置为索引。最后，使用 plot 函数绘制折线图，并设置合适的日期格式和显示效果。

以下是实现代码：

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# 创建示例数据
dates = pd.date_range(start='2023-01-01', periods=365)
values = np.random.randn(365).cumsum()

# 创建 DataFrame
df = pd.DataFrame({'Date': dates, 'Value': values})
df.set_index('Date', inplace=True)

# 绘制时间序列折线图
plt.plot(df.index, df['Value'])

# 设置日期格式和显示效果
plt.xticks(rotation=45)
plt.title('Time Series Line Plot')
plt.xlabel('Date')
plt.ylabel('Value')

# 显示图形
plt.show()

在这段代码中，pd.date_range 函数用于生成日期序列，df.set_index('Date', inplace=True) 将日期列设置为索引。plt.xticks(rotation=45) 用于旋转横轴的日期标签，以便更好地显示。

组合折线图与文本标注（在特定位置添加注释箭头）

在折线图中添加文本标注和注释箭头可以帮助我们解释数据中的关键信息。在 matplotlib 中，我们可以使用 annotate 函数来实现这一功能。

首先，导入 matplotlib.pyplot 和 numpy 库。然后，生成数据并绘制折线图。接着，确定需要添加注释的位置，并使用 annotate 函数添加文本标注和注释箭头。最后，添加标题和坐标轴标签，显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成示例数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 绘制折线图
plt.plot(x, y)

# 添加注释箭头和文本标注
plt.annotate('Local Max', xy=(np.pi/2, 1), xytext=(2, 0.5),
             arrowprops=dict(facecolor='red', shrink=0.05))

# 添加标题和坐标轴标签
plt.title('Line Plot with Annotation')
plt.xlabel('X')
plt.ylabel('Y')

# 显示图形
plt.show()

在上述代码中，annotate 函数的第一个参数是注释文本，xy 参数指定注释箭头指向的位置，xytext 参数指定注释文本的位置，arrowprops 参数用于设置箭头的样式。通过调整这些参数，可以得到不同的注释效果。

绘制班级人数分布的横向柱状图，不同班级用不同颜色

绘制班级人数分布的横向柱状图，并为不同班级设置不同颜色，能直观呈现各班级人数差异。在 Python 里，借助 matplotlib 库可轻松实现。

首先，我们要导入所需的库，包括 matplotlib.pyplot 用于绘图，numpy 辅助数据处理。接着，定义班级名称和对应的人数数据。为了让不同班级有不同颜色，可创建一个颜色列表。然后，使用 barh 函数绘制横向柱状图，将颜色列表应用到每个班级的柱子上。同时，为了让图表更清晰，要添加标题、坐标轴标签和图例。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 定义班级名称和人数
classes = ['Class A', 'Class B', 'Class C', 'Class D']
students = [30, 35, 28, 40]

# 定义不同颜色
colors = ['red', 'green', 'blue', 'yellow']

# 绘制横向柱状图
plt.barh(classes, students, color=colors)

# 添加标题和坐标轴标签
plt.title('Class Student Distribution')
plt.xlabel('Number of Students')
plt.ylabel('Classes')

# 显示图形
plt.show()

在上述代码中，barh 函数的第一个参数是班级名称，第二个参数是人数，color 参数接收颜色列表。这样，每个班级的柱子就会显示不同颜色。通过添加标题和坐标轴标签，让图表的含义一目了然。

绘制堆叠柱状图展示季度销售额（分产品类别）

堆叠柱状图能很好地展示不同产品类别在各季度的销售额占比情况。使用 matplotlib 库，可按以下步骤实现。

先导入必要的库，然后定义产品类别、季度和对应的销售额数据。接着，使用 bar 函数绘制第一个产品类别的销售额柱状图，之后依次绘制其他产品类别的柱状图，并通过 bottom 参数设置堆叠效果。最后，添加标题、坐标轴标签和图例。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 定义产品类别和季度
products = ['Product A', 'Product B', 'Product C']
quarters = ['Q1', 'Q2', 'Q3', 'Q4']

# 定义各产品在各季度的销售额
sales = [
    [100, 120, 130, 150],
    [80, 90, 100, 110],
    [60, 70, 80, 90]
]

# 设置柱子的宽度和位置
x = np.arange(len(quarters))
width = 0.2

# 绘制堆叠柱状图
bottom = np.zeros(len(quarters))
for i, product_sales in enumerate(sales):
    plt.bar(x, product_sales, width, label=products[i], bottom=bottom)
    bottom += np.array(product_sales)

# 添加标题和坐标轴标签
plt.title('Quarterly Sales by Product')
plt.xlabel('Quarters')
plt.ylabel('Sales')

# 设置 x 轴刻度标签
plt.xticks(x, quarters)

# 添加图例
plt.legend()

# 显示图形
plt.show()

在这段代码中，bottom 数组用于记录每个季度已堆叠的销售额高度。每次绘制新的产品类别柱状图时，将其设置为 bottom 参数，实现堆叠效果。通过设置 xticks，让 x 轴显示正确的季度标签。

绘制分组柱状图比较两年间各月份降雨量

分组柱状图可清晰对比两年间各月份的降雨量。使用 matplotlib 库，按以下方式操作。

导入所需库后，定义年份、月份和对应的降雨量数据。接着，设置柱子的宽度和位置，分别绘制两年的柱状图，并将它们分组排列。最后，添加标题、坐标轴标签和图例。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 定义年份和月份
years = ['2022', '2023']
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

# 定义各年份各月份的降雨量
rainfall = [
    [50, 45, 60, 30, 35, 40, 55, 65, 50, 40, 35, 45],
    [55, 50, 65, 35, 40, 45, 60, 70, 55, 45, 40, 50]
]

# 设置柱子的宽度和位置
width = 0.35
x = np.arange(len(months))

# 绘制分组柱状图
fig, ax = plt.subplots()
rects1 = ax.bar(x - width/2, rainfall[0], width, label=years[0])
rects2 = ax.bar(x + width/2, rainfall[1], width, label=years[1])

# 添加标题和坐标轴标签
ax.set_title('Monthly Rainfall Comparison between Two Years')
ax.set_xlabel('Months')
ax.set_ylabel('Rainfall (mm)')

# 设置 x 轴刻度标签
ax.set_xticks(x)
ax.set_xticklabels(months)

# 添加图例
ax.legend()

# 显示图形
plt.show()

在代码中，通过 x - width/2 和 x + width/2 来控制两组柱子的位置，实现分组效果。使用 set_xticks 和 set_xticklabels 让 x 轴显示正确的月份标签。

实现带数据标签的柱状图（数值显示在柱顶）

带数据标签的柱状图能让读者直接看到柱子所代表的数值。使用 matplotlib 库，可这样实现。

导入必要的库，定义柱子的标签和对应的数值。使用 bar 函数绘制柱状图，然后遍历每个柱子，使用 text 函数在柱顶添加数据标签。最后，添加标题和坐标轴标签。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 定义柱子的标签和数值
labels = ['A', 'B', 'C', 'D']
values = [20, 35, 30, 25]

# 绘制柱状图
fig, ax = plt.subplots()
rects = ax.bar(labels, values)

# 添加数据标签
for rect in rects:
    height = rect.get_height()
    ax.annotate('{}'.format(height),
                xy=(rect.get_x() + rect.get_width() / 2, height),
                xytext=(0, 3),  # 3 points vertical offset
                textcoords="offset points",
                ha='center', va='bottom')

# 添加标题和坐标轴标签
ax.set_title('Bar Chart with Data Labels')
ax.set_xlabel('Categories')
ax.set_ylabel('Values')

# 显示图形
plt.show()

在上述代码中，get_height 方法获取柱子的高度，annotate 函数在柱顶添加数据标签。通过设置 xytext 调整标签的垂直偏移量。

绘制正态分布数据的直方图（bins=20）

直方图能直观展示数据的分布情况，绘制正态分布数据的直方图（bins=20），可使用 matplotlib 库。

导入所需库，使用 numpy 生成正态分布数据。然后，使用 hist 函数绘制直方图，设置 bins 参数为 20。最后，添加标题和坐标轴标签。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成正态分布数据
data = np.random.normal(loc=0, scale=1, size=1000)

# 绘制直方图
plt.hist(data, bins=20)

# 添加标题和坐标轴标签
plt.title('Histogram of Normal Distribution Data')
plt.xlabel('Value')
plt.ylabel('Frequency')

# 显示图形
plt.show()

在这段代码中，np.random.normal 函数生成均值为 0、标准差为 1 的 1000 个正态分布数据。hist 函数的 bins 参数设置为 20，将数据分成 20 个区间进行统计。通过添加标题和坐标轴标签，让直方图的含义更清晰。

绘制人口金字塔图（年龄性别分布对比）

人口金字塔图能够直观呈现一个地区人口的年龄和性别分布情况。在 Python 中，可借助 matplotlib 库来绘制。其核心在于将男性和女性人口数据分别绘制在坐标轴两侧，形成金字塔形状。

首先，需要准备年龄分组和对应的男性、女性人口数据。接着，导入 matplotlib.pyplot 和 numpy 库。然后，使用 barh 函数绘制水平柱状图，将男性人口数据绘制在负半轴，女性人口数据绘制在正半轴。为了使图表更清晰，可添加标题、坐标轴标签和图例。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 年龄分组
ages = np.arange(0, 100, 5)

# 男性和女性人口数据
male_population = np.array([100, 120, 150, 180, 200, 220, 200, 180, 150, 120, 100, 80, 60, 40, 20])
female_population = np.array([110, 130, 160, 190, 210, 230, 210, 190, 160, 130, 110, 90, 70, 50, 30])

# 绘制人口金字塔图
fig, ax = plt.subplots()
ax.barh(ages, -male_population, color='blue', label='Male')
ax.barh(ages, female_population, color='pink', label='Female')

# 设置坐标轴标签和标题
ax.set_xlabel('Population')
ax.set_ylabel('Age Group')
ax.set_title('Population Pyramid')

# 添加图例
ax.legend()

# 显示图形
plt.show()

在上述代码中，barh 函数用于绘制水平柱状图，-male_population 使男性人口数据显示在负半轴。通过设置不同的颜色和标签，能清晰区分男性和女性人口。添加标题和坐标轴标签，让图表的含义一目了然。

创建渐变颜色柱状图（颜色随数值变化）

渐变颜色柱状图可以根据柱子所代表的数值大小来改变颜色，使数据的大小对比更加直观。在 Python 中，可结合 matplotlib 和 numpy 库来实现。

首先，准备数据和颜色映射。颜色映射可以使用 matplotlib 中的 cm 模块。接着，导入必要的库，使用 bar 函数绘制柱状图，并根据数值大小为每个柱子分配不同的颜色。为了使颜色变化更明显，可添加颜色条。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cm

# 数据
x = np.arange(10)
y = np.random.rand(10)

# 颜色映射
norm = plt.Normalize(y.min(), y.max())
colors = cm.viridis(norm(y))

# 绘制渐变颜色柱状图
fig, ax = plt.subplots()
bars = ax.bar(x, y, color=colors)

# 添加颜色条
sm = cm.ScalarMappable(cmap=cm.viridis, norm=norm)
sm.set_array([])
fig.colorbar(sm)

# 设置标题和坐标轴标签
ax.set_title('Gradient Color Bar Chart')
ax.set_xlabel('X')
ax.set_ylabel('Y')

# 显示图形
plt.show()

在上述代码中，Normalize 函数用于将数据归一化到 0 到 1 的范围，cm.viridis 是一种颜色映射，根据归一化后的数据为每个柱子分配颜色。颜色条通过 ScalarMappable 和 colorbar 函数添加，方便查看数值与颜色的对应关系。

绘制带误差条的科研数据柱状图

在科研数据可视化中，带误差条的柱状图可以展示数据的平均值和误差范围。在 Python 中，可使用 matplotlib 库来实现。

首先，准备数据和对应的误差范围。接着，导入必要的库，使用 bar 函数绘制柱状图，并通过 yerr 参数指定误差范围。为了使图表更清晰，可添加标题、坐标轴标签和图例。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 数据
x = np.arange(5)
y = np.array([20, 35, 30, 25, 40])
errors = np.array([2, 3, 1, 2, 3])

# 绘制带误差条的柱状图
fig, ax = plt.subplots()
bars = ax.bar(x, y, yerr=errors, capsize=5)

# 设置标题和坐标轴标签
ax.set_title('Bar Chart with Error Bars')
ax.set_xlabel('Categories')
ax.set_ylabel('Values')

# 设置 x 轴刻度标签
ax.set_xticks(x)
ax.set_xticklabels(['A', 'B', 'C', 'D', 'E'])

# 显示图形
plt.show()

在上述代码中，bar 函数的 yerr 参数指定了误差范围，capsize 参数设置了误差条末端横线的长度。通过设置 xticks 和 xticklabels，使 x 轴显示正确的类别标签。

实现交互式柱状图（点击柱子弹出详细数据）

交互式柱状图可以让用户通过点击柱子获取详细数据。在 Python 中，可使用 matplotlib 的事件处理机制来实现。

首先，准备数据并绘制柱状图。接着，导入必要的库，定义一个事件处理函数，当用户点击柱子时，该函数会弹出一个对话框显示详细数据。最后，将事件处理函数与图形的点击事件绑定。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np
from tkinter import messagebox
import matplotlib as mpl

# 数据
x = np.arange(5)
y = np.array([20, 35, 30, 25, 40])

# 绘制柱状图
fig, ax = plt.subplots()
bars = ax.bar(x, y)

# 定义事件处理函数
def on_click(event):
    if event.inaxes == ax:
        for bar in bars:
            if bar.contains(event)[0]:
                index = bars.index(bar)
                messagebox.showinfo("Detail", f"Value: {y[index]}")

# 绑定事件处理函数
fig.canvas.mpl_connect('button_press_event', on_click)

# 设置标题和坐标轴标签
ax.set_title('Interactive Bar Chart')
ax.set_xlabel('Categories')
ax.set_ylabel('Values')

# 设置 x 轴刻度标签
ax.set_xticks(x)
ax.set_xticklabels(['A', 'B', 'C', 'D', 'E'])

# 显示图形
plt.show()

在上述代码中，on_click 函数是事件处理函数，当用户点击柱子时，会检查点击位置是否在柱子上，如果是，则弹出一个对话框显示该柱子所代表的数值。mpl_connect 函数将事件处理函数与图形的点击事件绑定。

绘制时间序列柱状图（按周统计用户活跃数）

时间序列柱状图可以展示按周统计的用户活跃数随时间的变化情况。在 Python 中，可使用 pandas 和 matplotlib 库来实现。

首先，准备时间序列数据和对应的用户活跃数。接着，导入必要的库，将时间数据转换为 pandas 的 DatetimeIndex 类型，并按周进行分组统计。然后，使用 bar 函数绘制柱状图。为了使图表更清晰，可添加标题、坐标轴标签和图例。

以下是实现代码：

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# 生成时间序列数据
dates = pd.date_range(start='2024-01-01', periods=90)
user_activity = np.random.randint(100, 200, size=90)

# 创建 DataFrame
df = pd.DataFrame({'date': dates, 'activity': user_activity})
df.set_index('date', inplace=True)

# 按周统计用户活跃数
weekly_activity = df['activity'].resample('W').sum()

# 绘制时间序列柱状图
fig, ax = plt.subplots()
bars = ax.bar(weekly_activity.index, weekly_activity.values)

# 设置标题和坐标轴标签
ax.set_title('Weekly User Activity')
ax.set_xlabel('Date')
ax.set_ylabel('User Activity')

# 设置 x 轴刻度标签旋转角度
plt.xticks(rotation=45)

# 显示图形
plt.show()

在上述代码中，resample('W') 函数按周对数据进行重采样，sum() 函数计算每周的用户活跃数总和。通过设置 xticks(rotation=45)，使 x 轴的日期标签旋转 45 度，避免标签重叠。

绘制鸢尾花数据集散点图（用颜色区分种类）

鸢尾花数据集是一个经典的机器学习数据集，包含了三种不同种类鸢尾花的多个特征数据。通过绘制散点图并以颜色区分不同种类的鸢尾花，能够直观地观察到不同种类鸢尾花在特征上的分布差异。

我们可以使用 Python 的 seaborn 和 matplotlib 库来实现这个需求。seaborn 是基于 matplotlib 的高级可视化库，它提供了更简洁的 API 来绘制统计图形。

首先，需要导入必要的库，如 seaborn、matplotlib.pyplot 以及 sklearn.datasets 中的 load_iris 函数用于加载鸢尾花数据集。然后，使用 load_iris 函数加载数据集，并将其转换为 pandas 的 DataFrame 格式，方便后续处理。接着，使用 seaborn 的 scatterplot 函数绘制散点图，通过 hue 参数指定用鸢尾花的种类来区分颜色。最后，设置图形的标题和坐标轴标签，并显示图形。

以下是实现代码：

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
import pandas as pd

# 加载鸢尾花数据集
iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
iris_df['species'] = iris.target

# 定义种类名称映射
species_mapping = {0: iris.target_names[0], 1: iris.target_names[1], 2: iris.target_names[2]}
iris_df['species'] = iris_df['species'].map(species_mapping)

# 绘制散点图
sns.scatterplot(x='sepal length (cm)', y='sepal width (cm)', hue='species', data=iris_df)

# 设置标题和坐标轴标签
plt.title('Iris Dataset Scatter Plot')
plt.xlabel('Sepal Length (cm)')
plt.ylabel('Sepal Width (cm)')

# 显示图形
plt.show()

在上述代码中，load_iris 函数加载了鸢尾花数据集，将其转换为 DataFrame 后，通过 scatterplot 函数绘制散点图。hue='species' 使得不同种类的鸢尾花用不同颜色表示。通过设置标题和坐标轴标签，让图形的含义更加清晰。

创建气泡图：气泡大小表示第三维度数据

气泡图是一种特殊的散点图，除了用 x 和 y 坐标表示两个维度的数据外，还通过气泡的大小来表示第三维度的数据。

同样可以使用 matplotlib 库来创建气泡图。首先，准备三组数据，分别代表 x 轴、y 轴和气泡大小的数据。然后，使用 scatter 函数绘制气泡图，通过 s 参数指定气泡的大小。为了使气泡图更加直观，可以设置颜色、透明度等参数。最后，添加标题和坐标轴标签，并显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成示例数据
x = np.random.rand(50)
y = np.random.rand(50)
sizes = np.random.randint(10, 200, 50)

# 绘制气泡图
plt.scatter(x, y, s=sizes, alpha=0.5)

# 添加标题和坐标轴标签
plt.title('Bubble Chart')
plt.xlabel('X')
plt.ylabel('Y')

# 显示图形
plt.show()

在上述代码中，np.random.rand 生成了 x 和 y 轴的随机数据，np.random.randint 生成了气泡大小的随机数据。scatter 函数的 s 参数指定了气泡的大小，alpha 参数设置了气泡的透明度，使重叠的气泡也能清晰显示。

绘制带回归线的散点图（显示 R² 值）

绘制带回归线的散点图可以帮助我们观察两个变量之间的线性关系，同时显示 \(R^2\) 值可以量化这种线性关系的强度。

可以使用 numpy 进行线性回归计算，matplotlib 进行图形绘制。首先，准备 x 和 y 轴的数据。然后，使用 numpy 的 polyfit 函数进行线性回归，得到回归系数。接着，使用回归系数计算回归直线上的点。同时，计算 \(R^2\) 值。最后，使用 scatter 函数绘制散点图，使用 plot 函数绘制回归线，并在图形上显示 \(R^2\) 值。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成示例数据
x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
y = np.array([2, 4, 6, 8, 10, 12, 14, 16, 18, 20]) + np.random.randn(10)

# 进行线性回归
coefficients = np.polyfit(x, y, 1)
poly = np.poly1d(coefficients)
y_reg = poly(x)

# 计算 R² 值
y_mean = np.mean(y)
ss_tot = np.sum((y - y_mean) ** 2)
ss_res = np.sum((y - y_reg) ** 2)
r_squared = 1 - (ss_res / ss_tot)

# 绘制散点图和回归线
plt.scatter(x, y, label='Data Points')
plt.plot(x, y_reg, color='red', label='Regression Line')

# 显示 R² 值
plt.text(0.05, 0.9, f'R² = {r_squared:.2f}', transform=plt.gca().transAxes)

# 添加标题、坐标轴标签和图例
plt.title('Scatter Plot with Regression Line and R² Value')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()

# 显示图形
plt.show()

在上述代码中，np.polyfit 函数进行线性回归得到回归系数，np.poly1d 生成回归多项式。通过计算总平方和 ss_tot 和残差平方和 ss_res，得到 \(R^2\) 值。text 函数在图形上显示 \(R^2\) 值。

实现动态散点图（数据点随时间推移逐渐出现）

要实现动态散点图，让数据点随时间推移逐渐出现，可以使用 matplotlib 的 animation 模块。

首先，准备数据。然后，创建一个空的散点图对象。接着，定义一个更新函数，在更新函数中逐步添加数据点到散点图中。最后，使用 FuncAnimation 函数创建动画对象，并显示动画。

以下是实现代码：

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# 生成示例数据
x = np.random.rand(100)
y = np.random.rand(100)

# 创建图形和坐标轴
fig, ax = plt.subplots()
scat = ax.scatter([], [])

# 初始化函数
def init():
    scat.set_offsets([])
    return scat,

# 更新函数
def update(frame):
    new_data = np.column_stack((x[:frame], y[:frame]))
    scat.set_offsets(new_data)
    return scat,

# 创建动画
ani = animation.FuncAnimation(fig, update, frames=len(x), init_func=init, blit=True)

# 显示动画
plt.show()

在上述代码中，init 函数初始化散点图为空。update 函数在每一帧中逐步添加数据点到散点图中。FuncAnimation 函数根据更新函数创建动画对象，frames 参数指定动画的帧数。

绘制高密度散点图（超过 10 万数据点优化显示）

当数据点数量超过 10 万时，直接绘制散点图可能会导致图形显示缓慢或不清晰。可以使用 matplotlib 的 hexbin 函数来优化显示。

hexbin 函数将数据点划分到六边形网格中，并根据每个网格内的数据点数量进行颜色编码，这样可以有效地展示高密度数据的分布情况。

首先，准备大量的 x 和 y 轴数据。然后，使用 hexbin 函数绘制六边形分箱图。可以设置分箱的数量、颜色映射等参数。最后，添加标题、坐标轴标签和颜色条，并显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成大量示例数据
x = np.random.randn(100000)
y = np.random.randn(100000)

# 绘制六边形分箱图
plt.hexbin(x, y, gridsize=50, cmap='Blues')

# 添加颜色条
cb = plt.colorbar()
cb.set_label('Number of points')

# 添加标题和坐标轴标签
plt.title('High Density Scatter Plot with Hexbin')
plt.xlabel('X')
plt.ylabel('Y')

# 显示图形
plt.show()

在上述代码中，np.random.randn 生成了大量的随机数据。hexbin 函数的 gridsize 参数指定了六边形网格的数量，cmap 参数指定了颜色映射。颜色条通过 colorbar 函数添加，方便查看每个颜色对应的点数。

创建三维散点图（添加颜色映射条）

三维散点图可以直观地展示三个变量之间的关系，添加颜色映射条则能引入第四个维度的信息。在 Python 中，可使用 matplotlib 库实现这一功能。

首先，导入必要的库，包括 matplotlib.pyplot、mpl_toolkits.mplot3d 用于创建三维图形，以及 numpy 用于生成数据。接着，生成三维坐标数据和对应的颜色数据。然后，创建一个三维坐标轴对象，使用 scatter 函数绘制三维散点图，并根据颜色数据为散点设置颜色。最后，添加颜色映射条和标题、坐标轴标签。

以下是实现代码：

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 生成数据
x = np.random.rand(100)
y = np.random.rand(100)
z = np.random.rand(100)
c = np.random.rand(100)

# 创建三维图形
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 绘制三维散点图
sc = ax.scatter(x, y, z, c=c, cmap='viridis')

# 添加颜色映射条
fig.colorbar(sc, label='Color Scale')

# 添加标题和坐标轴标签
ax.set_title('3D Scatter Plot with Colorbar')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

# 显示图形
plt.show()

在上述代码中，np.random.rand 生成了随机的三维坐标数据和颜色数据。scatter 函数的 c 参数指定颜色数据，cmap 参数指定颜色映射。colorbar 函数添加了颜色映射条，方便查看颜色与数值的对应关系。

绘制带边缘直方图的联合分布散点图

带边缘直方图的联合分布散点图可以同时展示两个变量的联合分布以及各自的边缘分布。在 Python 中，可使用 seaborn 库来实现。

首先，导入 seaborn 和 matplotlib.pyplot 库。然后，准备两个变量的数据。接着，使用 seaborn 的 jointplot 函数绘制联合分布散点图，并设置 kind='scatter' 表示使用散点图展示联合分布，同时设置 marginal_kws 参数来控制边缘直方图的样式。最后，添加标题并显示图形。

以下是实现代码：

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.random.randn(100)
y = np.random.randn(100)

# 绘制带边缘直方图的联合分布散点图
g = sns.jointplot(x=x, y=y, kind='scatter', marginal_kws=dict(bins=20, rug=True))

# 添加标题
g.fig.suptitle('Joint Distribution Scatter Plot with Marginal Histograms')

# 显示图形
plt.show()

在上述代码中，np.random.randn 生成了两个变量的随机数据。jointplot 函数绘制了联合分布散点图和边缘直方图，marginal_kws 参数中的 bins 控制直方图的箱数，rug 表示是否显示数据点的竖线标记。

实现散点图矩阵（pairplot）展示多变量关系

散点图矩阵（pairplot）可以同时展示多个变量之间的两两关系，有助于发现变量之间的相关性和分布特征。在 Python 中，可使用 seaborn 库实现。

首先，导入 seaborn、matplotlib.pyplot 和 pandas 库。然后，准备包含多个变量的数据集，并将其转换为 pandas 的 DataFrame 格式。接着，使用 seaborn 的 pairplot 函数绘制散点图矩阵，可通过 hue 参数指定分类变量，以不同颜色区分不同类别。最后，添加标题并显示图形。

以下是实现代码：

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# 生成数据
data = {
    'var1': np.random.randn(100),
    'var2': np.random.randn(100),
    'var3': np.random.randn(100),
    'category': np.random.choice(['A', 'B', 'C'], 100)
}
df = pd.DataFrame(data)

# 绘制散点图矩阵
g = sns.pairplot(df, hue='category')

# 添加标题
g.fig.suptitle('Pair Plot Showing Multivariate Relationships')

# 显示图形
plt.show()

在上述代码中，np.random.randn 生成了三个变量的随机数据，np.random.choice 生成了分类变量的数据。pairplot 函数根据 hue 参数将不同类别的数据用不同颜色表示，方便比较不同类别下变量之间的关系。

创建 2x2 子图网格分别绘制 sin、cos、tan、exp 函数

在 matplotlib 中，可以创建子图网格来同时展示多个图形。对于绘制 sin、cos、tan、exp 函数的需求，可以创建一个 2x2 的子图网格。

首先，导入 matplotlib.pyplot 和 numpy 库。然后，生成 x 轴的数据。接着，创建一个 2x2 的子图网格。在每个子图中，分别绘制 sin、cos、tan、exp 函数，并添加标题和坐标轴标签。最后，调整子图之间的间距并显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成 x 轴数据
x = np.linspace(-2 * np.pi, 2 * np.pi, 1000)

# 创建 2x2 子图网格
fig, axes = plt.subplots(2, 2, figsize=(10, 8))

# 绘制 sin 函数
axes[0, 0].plot(x, np.sin(x))
axes[0, 0].set_title('sin(x)')
axes[0, 0].set_xlabel('x')
axes[0, 0].set_ylabel('y')

# 绘制 cos 函数
axes[0, 1].plot(x, np.cos(x))
axes[0, 1].set_title('cos(x)')
axes[0, 1].set_xlabel('x')
axes[0, 1].set_ylabel('y')

# 绘制 tan 函数
axes[1, 0].plot(x, np.tan(x))
axes[1, 0].set_title('tan(x)')
axes[1, 0].set_xlabel('x')
axes[1, 0].set_ylabel('y')
axes[1, 0].set_ylim(-10, 10)  # 限制 y 轴范围

# 绘制 exp 函数
axes[1, 1].plot(x, np.exp(x))
axes[1, 1].set_title('exp(x)')
axes[1, 1].set_xlabel('x')
axes[1, 1].set_ylabel('y')

# 调整子图间距
plt.tight_layout()

# 显示图形
plt.show()

在上述代码中，np.linspace 生成了 x 轴的数据。subplots(2, 2) 创建了一个 2x2 的子图网格。在每个子图中，使用 plot 函数绘制相应的函数，并添加标题和坐标轴标签。tight_layout 函数调整子图之间的间距，使图形布局更美观。

实现不规则子图布局（GridSpec 高级用法）

GridSpec 是 matplotlib 中用于创建不规则子图布局的强大工具。通过 GridSpec，可以灵活地控制每个子图的大小和位置。

首先，导入 matplotlib.pyplot 和 matplotlib.gridspec 库。然后，创建一个 GridSpec 对象，指定子图网格的行数和列数。接着，根据需要划分不同的子图区域，使用 subplot 函数在指定区域创建子图。最后，在每个子图中绘制图形，并添加标题和坐标轴标签。

以下是实现代码：

import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import numpy as np

# 生成数据
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.tan(x)

# 创建 GridSpec 对象
fig = plt.figure(figsize=(10, 8))
gs = gridspec.GridSpec(3, 3)

# 创建子图 1
ax1 = plt.subplot(gs[0, :])
ax1.plot(x, y1)
ax1.set_title('sin(x)')
ax1.set_xlabel('x')
ax1.set_ylabel('y')

# 创建子图 2
ax2 = plt.subplot(gs[1, :-1])
ax2.plot(x, y2)
ax2.set_title('cos(x)')
ax2.set_xlabel('x')
ax2.set_ylabel('y')

# 创建子图 3
ax3 = plt.subplot(gs[1:, -1])
ax3.plot(x, y3)
ax3.set_title('tan(x)')
ax3.set_xlabel('x')
ax3.set_ylabel('y')
ax3.set_ylim(-10, 10)  # 限制 y 轴范围

# 创建子图 4
ax4 = plt.subplot(gs[2, 0])
ax4.plot(x, y1)
ax4.set_title('sin(x) again')
ax4.set_xlabel('x')
ax4.set_ylabel('y')

# 创建子图 5
ax5 = plt.subplot(gs[2, 1])
ax5.plot(x, y2)
ax5.set_title('cos(x) again')
ax5.set_xlabel('x')
ax5.set_ylabel('y')

# 调整子图间距
plt.tight_layout()

# 显示图形
plt.show()

在上述代码中，GridSpec(3, 3) 创建了一个 3x3 的子图网格。通过 gs[row, col] 的方式指定子图的位置和范围，subplot 函数在指定区域创建子图。最后，tight_layout 函数调整子图之间的间距，使图形布局更合理。

在主图中插入局部放大子图

在主图中插入局部放大子图能帮助用户更清晰地观察主图中特定区域的细节。在 matplotlib 里，可通过 inset_axes 来实现这一功能。

首先，导入所需的库，如 matplotlib.pyplot。接着，生成主图的数据并绘制主图。之后，确定要放大的区域，使用 inset_axes 创建一个插入的子图。在子图中绘制与主图相同的数据，但只显示放大区域的数据。为了让用户清楚放大区域的位置，可使用 mark_inset 函数在主图和子图之间添加指示线。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 绘制主图
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('Main Plot')

# 创建插入子图
axins = ax.inset_axes([0.5, 0.5, 0.4, 0.4])
axins.plot(x, y)

# 设置放大区域
x1, x2, y1, y2 = 2, 4, -0.5, 0.5
axins.set_xlim(x1, x2)
axins.set_ylim(y1, y2)
axins.set_xticklabels([])
axins.set_yticklabels([])

# 添加指示线
ax.indicate_inset_zoom(axins)

plt.show()

在上述代码中，inset_axes([0.5, 0.5, 0.4, 0.4]) 表示在主图的右上角创建一个大小为主图 40% 的子图。indicate_inset_zoom 函数会自动绘制指示线，连接主图和子图中的放大区域。

组合折线图与柱状图（共享 X 轴）

组合折线图与柱状图且共享 X 轴，可以同时展示不同类型的数据，增强数据的可视化效果。在 matplotlib 中，可按以下步骤实现。

先导入必要的库，然后生成两组数据，分别用于绘制折线图和柱状图。接着，创建一个坐标轴对象，使用 bar 函数绘制柱状图。再使用 twinx 函数创建一个共享 X 轴的新坐标轴对象，使用 plot 函数绘制折线图。为了区分两种图形，要设置不同的颜色和标签，并添加图例。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.arange(5)
y1 = np.array([20, 35, 30, 25, 40])
y2 = np.array([10, 20, 15, 25, 30])

# 创建图形和坐标轴
fig, ax1 = plt.subplots()

# 绘制柱状图
ax1.bar(x, y1, color='blue', label='Bar Chart')
ax1.set_xlabel('X')
ax1.set_ylabel('Y1', color='blue')
ax1.tick_params(axis='y', labelcolor='blue')

# 创建第二个 Y 轴
ax2 = ax1.twinx()

# 绘制折线图
ax2.plot(x, y2, color='red', label='Line Chart')
ax2.set_ylabel('Y2', color='red')
ax2.tick_params(axis='y', labelcolor='red')

# 添加图例
lines, labels = ax1.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax2.legend(lines + lines2, labels + labels2, loc='upper left')

plt.show()

在这段代码中，twinx 函数创建了一个共享 X 轴的新坐标轴，使得折线图和柱状图可以共用 X 轴。通过设置不同的颜色和标签，让两种图形能够清晰区分。

创建多图层叠加图（如折线图 + 散点图 + 面积图）

创建多图层叠加图可以综合展示不同类型的数据特征。在 matplotlib 中，可依次绘制折线图、散点图和面积图来实现。

首先，导入必要的库，生成数据。然后，使用 plot 函数绘制折线图，使用 scatter 函数绘制散点图，使用 fill_between 函数绘制面积图。为了区分不同的图层，要设置不同的颜色和透明度。最后，添加标题和坐标轴标签，显示图形。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 绘制折线图
plt.plot(x, y, color='blue', label='Line Plot')

# 绘制散点图
plt.scatter(x, y, color='red', alpha=0.5, label='Scatter Plot')

# 绘制面积图
plt.fill_between(x, y, color='green', alpha=0.2, label='Area Plot')

# 添加标题和坐标轴标签
plt.title('Multi - Layer Overlay Plot')
plt.xlabel('X')
plt.ylabel('Y')

# 添加图例
plt.legend()

plt.show()

在上述代码中，fill_between 函数用于绘制面积图，alpha 参数控制透明度，使不同图层之间不会相互遮挡，能清晰展示各自的特征。

设计仪表盘式布局（环形图 + 指标卡 + 趋势图）

设计仪表盘式布局可以直观地展示关键指标和数据趋势。在 matplotlib 中，可结合不同的图形来实现。

首先，导入必要的库，生成用于环形图、指标卡和趋势图的数据。对于环形图，使用 pie 函数并设置 wedgeprops 参数来创建环形效果。对于指标卡，使用 text 函数在合适的位置显示指标值。对于趋势图，使用 plot 函数绘制折线图。最后，调整各个图形的位置和大小，使布局合理。

以下是实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 环形图数据
sizes = [30, 20, 50]
labels = ['A', 'B', 'C']
colors = ['red', 'green', 'blue']

# 指标卡数据
indicator_value = 80

# 趋势图数据
x_trend = np.linspace(0, 10, 100)
y_trend = np.sin(x_trend)

# 创建图形
fig = plt.figure(figsize=(10, 8))

# 绘制环形图
ax1 = fig.add_subplot(2, 2, 1)
ax1.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90, wedgeprops=dict(width=0.3))
ax1.axis('equal')
ax1.set_title('Donut Chart')

# 绘制指标卡
ax2 = fig.add_subplot(2, 2, 2)
ax2.text(0.5, 0.5, f'Indicator: {indicator_value}', ha='center', va='center', fontsize=20)
ax2.axis('off')
ax2.set_title('Indicator Card')

# 绘制趋势图
ax3 = fig.add_subplot(2, 1, 2)
ax3.plot(x_trend, y_trend)
ax3.set_title('Trend Chart')
ax3.set_xlabel('X')
ax3.set_ylabel('Y')

plt.show()

在上述代码中，wedgeprops=dict(width=0.3) 将饼图转换为环形图。text 函数在指标卡子图中显示指标值，并通过 axis('off') 隐藏坐标轴。

实现响应式子图布局（自适应窗口大小）

实现响应式子图布局可以让图形在不同的窗口大小下都能保持良好的显示效果。在 matplotlib 中，可通过 constrained_layout 或 tight_layout 来实现。

constrained_layout 会自动调整子图的位置和大小，以适应图形窗口的大小。tight_layout 则会尽量减少子图之间的空白区域。

以下是使用 constrained_layout 的实现代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 创建图形和子图
fig, axes = plt.subplots(2, 2, constrained_layout=True)

# 在每个子图中绘制数据
for i in range(2):
    for j in range(2):
        axes[i, j].plot(x, y)
        axes[i, j].set_title(f'Subplot {i * 2 + j + 1}')

plt.show()

在上述代码中，constrained_layout=True 会使子图布局自适应窗口大小。当调整窗口大小时，子图会自动重新排列和调整大小，以充分利用窗口空间。

绘制三维曲面图 z=sin (x)+cos (y)

三维曲面图能够直观呈现三维空间中的函数关系。对于函数 \(z = \sin(x) + \cos(y)\)，借助 matplotlib 库的 mplot3d 工具包可绘制出其三维曲面图。

首先，需要导入必要的库，如 matplotlib.pyplot、mpl_toolkits.mplot3d 以及 numpy。numpy 用于生成数据，matplotlib 负责绘图。接着，要生成 x 和 y 轴的数据网格，可使用 np.meshgrid 函数。然后，根据函数 \(z = \sin(x) + \cos(y)\) 计算 z 轴的数据。之后，创建一个三维坐标轴对象，使用 plot_surface 函数绘制三维曲面图。为了增强可视化效果，可设置颜色映射、透明度等参数。最后，添加标题和坐标轴标签。

以下是实现代码：

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 生成 x 和 y 轴的数据
x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.linspace(-2 * np.pi, 2 * np.pi, 100)
X, Y = np.meshgrid(x, y)

# 计算 z 轴的数据
Z = np.sin(X) + np.cos(Y)

# 创建三维图形
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 绘制三维曲面图
surf = ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)

# 添加颜色条
fig.colorbar(surf, shrink=0.5, aspect=5)

# 添加标题和坐标轴标签
ax.set_title('3D Surface Plot of z = sin(x) + cos(y)')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

# 显示图形
plt.show()

在上述代码中，np.linspace 生成了 x 和 y 轴的等间距数据点，np.meshgrid 将这些点组合成二维网格。plot_surface 函数根据 X、Y 和 Z 数据绘制曲面图，cmap='viridis' 设置了颜色映射，alpha=0.8 设置了曲面的透明度。颜色条通过 colorbar 函数添加，方便查看 z 值与颜色的对应关系。

创建三维柱状图展示城市人口分布

三维柱状图可以直观地展示城市人口在不同区域和年份的分布情况。使用 matplotlib 库的 mplot3d 工具包能够创建三维柱状图。

首先，准备城市人口分布的数据，包括不同城市、不同年份的人口数量。接着，导入必要的库，创建一个三维坐标轴对象。然后，确定每个柱子的位置和高度，使用 bar3d 函数绘制三维柱状图。为了使图表更清晰，可设置柱子的颜色、透明度等参数。最后，添加标题和坐标轴标签。

以下是实现代码：

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 定义城市和年份
cities = ['City A', 'City B', 'City C']
years = [2020, 2021, 2022]

# 模拟城市人口数据
population = np.array([
    [100, 120, 130],
    [110, 130, 140],
    [120, 140, 150]
])

# 创建三维图形
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 生成柱子的位置
xpos, ypos = np.meshgrid(np.arange(len(cities)), np.arange(len(years)))
xpos = xpos.flatten()
ypos = ypos.flatten()
zpos = np.zeros_like(xpos)

# 柱子的尺寸
dx = 0.5
dy = 0.5
dz = population.flatten()

# 绘制三维柱状图
ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color='b', alpha=0.8)

# 设置坐标轴标签
ax.set_xticks(np.arange(len(cities)))
ax.set_xticklabels(cities)
ax.set_yticks(np.arange(len(years)))
ax.set_yticklabels(years)
ax.set_xlabel('Cities')
ax.set_ylabel('Years')
ax.set_zlabel('Population')

# 添加标题
ax.set_title('3D Bar Chart of City Population Distribution')

# 显示图形
plt.show()

在上述代码中，np.meshgrid 生成了柱子的 x 和 y 位置，flatten 函数将二维数组转换为一维数组。bar3d 函数根据 xpos、ypos、zpos、dx、dy 和 dz 绘制三维柱状图。通过设置 xticks 和 yticks，让坐标轴显示正确的城市和年份标签。

绘制参数方程三维螺旋线（t∈[0,10π]）

三维螺旋线可以通过参数方程来定义。使用 matplotlib 库的 mplot3d 工具包能够绘制出三维螺旋线。

首先，定义参数方程 \(x = \cos(t)\)，\(y = \sin(t)\)，\(z = t\)，其中 t 的取值范围是 \([0, 10\pi]\)。接着，导入必要的库，创建一个三维坐标轴对象。然后，使用 np.linspace 生成 t 的取值，根据参数方程计算 x、y 和 z 的值。最后，使用 plot 函数绘制三维螺旋线，并添加标题和坐标轴标签。

以下是实现代码：

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 定义参数 t 的范围
t = np.linspace(0, 10 * np.pi, 1000)

# 计算 x, y, z 的值
x = np.cos(t)
y = np.sin(t)
z = t

# 创建三维图形
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 绘制三维螺旋线
ax.plot(x, y, z, color='r')

# 添加标题和坐标轴标签
ax.set_title('3D Helix Curve')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

# 显示图形
plt.show()

在上述代码中，np.linspace 生成了 t 的 1000 个等间距取值，根据参数方程计算出 x、y 和 z 的值。plot 函数根据这些值绘制三维螺旋线。

绘制三维等高线投影图

三维等高线投影图可以展示三维函数在不同高度的等值线投影情况。使用 matplotlib 库的 mplot3d 工具包能够绘制三维等高线投影图。

首先，定义一个三维函数，如 \(z = \sin(\sqrt{x^2 + y^2})\)。接着，导入必要的库，生成 x 和 y 轴的数据网格，计算 z 轴的数据。然后，创建一个三维坐标轴对象，使用 contourf 函数绘制三维等高线投影图。为了增强可视化效果，可设置颜色映射、透明度等参数。最后，添加标题和坐标轴标签。

以下是实现代码：

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 生成 x 和 y 轴的数据
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)

# 计算 z 轴的数据
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

# 创建三维图形
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 绘制三维等高线投影图
cset = ax.contourf(X, Y, Z, zdir='z', offset=-1, cmap='viridis')

# 添加颜色条
fig.colorbar(cset, shrink=0.5, aspect=5)

# 设置坐标轴范围
ax.set_xlim(-5, 5)
ax.set_ylim(-5, 5)
ax.set_zlim(-1, 1)

# 添加标题和坐标轴标签
ax.set_title('3D Contour Projection Plot')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

# 显示图形
plt.show()

在上述代码中，np.meshgrid 生成了 x 和 y 轴的二维网格，根据函数计算出 z 的值。contourf 函数绘制三维等高线投影图，zdir='z' 表示在 z 方向上投影，offset=-1 设置了投影的位置。颜色条通过 colorbar 函数添加。

创建交互式三维旋转视图（支持鼠标拖拽）

创建交互式三维旋转视图可以让用户通过鼠标拖拽来旋转和观察三维图形。使用 matplotlib 库的 mplot3d 工具包和其交互式功能能够实现这一需求。

首先，绘制一个三维图形，如三维曲面图或三维柱状图。接着，导入必要的库，创建一个三维坐标轴对象。然后，使用 plot_surface 或 bar3d 等函数绘制图形。最后，使用 plt.show() 显示图形，matplotlib 会自动支持鼠标拖拽旋转视图。

以下是一个简单的示例代码，以三维曲面图为例：

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 生成 x 和 y 轴的数据
x = np.linspace(-2 * np.pi, 2 * np.pi, 100)
y = np.linspace(-2 * np.pi, 2 * np.pi, 100)
X, Y = np.meshgrid(x, y)

# 计算 z 轴的数据
Z = np.sin(X) + np.cos(Y)

# 创建三维图形
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 绘制三维曲面图
surf = ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)

# 添加颜色条
fig.colorbar(surf, shrink=0.5, aspect=5)

# 添加标题和坐标轴标签
ax.set_title('Interactive 3D Surface Plot')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

# 显示图形
plt.show()

在上述代码中，绘制了一个三维曲面图，当使用 plt.show() 显示图形时，用户可以通过鼠标左键拖拽来旋转视图，右键拖拽来缩放视图，中键拖拽来平移视图，从而从不同角度观察三维图形。

自定义刻度格式（日期、货币、百分比形式）

在数据可视化里，按照不同需求自定义刻度格式是一项重要功能。matplotlib 提供了多种方式来实现日期、货币、百分比等特殊格式的刻度显示。

对于日期格式，matplotlib.dates 模块能实现日期的格式化。首先要将日期数据转换为 matplotlib 能识别的日期格式，然后使用 DateFormatter 自定义日期显示格式。例如，将日期显示为 “年 - 月 - 日”。

对于货币格式，可借助 FuncFormatter 自定义函数，把数值转换为货币形式。通常会在数值前添加货币符号，并且根据需求保留合适的小数位数。

对于百分比格式，同样使用 FuncFormatter 自定义函数，将数值乘以 100 并添加 “%” 符号。

以下是示例代码：

import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import matplotlib.ticker as ticker
import numpy as np
import pandas as pd

# 日期格式示例
dates = pd.date_range(start='2024-01-01', periods=10)
values = np.random.rand(10)

fig, ax = plt.subplots()
ax.plot(dates, values)

date_format = mdates.DateFormatter('%Y-%m-%d')
ax.xaxis.set_major_formatter(date_format)

# 货币格式示例
money_values = np.random.rand(10) * 1000
fig, ax = plt.subplots()
ax.plot(money_values)

def currency_formatter(x, pos):
    return f'${x:.2f}'
ax.yaxis.set_major_formatter(ticker.FuncFormatter(currency_formatter))

# 百分比格式示例
percent_values = np.random.rand(10)
fig, ax = plt.subplots()
ax.plot(percent_values)

def percent_formatter(x, pos):
    return f'{x * 100:.2f}%'
ax.yaxis.set_major_formatter(ticker.FuncFormatter(percent_formatter))

plt.show()

在这段代码中，对于日期格式，DateFormatter('%Y-%m-%d') 把日期转换为 “年 - 月 - 日” 的形式。对于货币格式，currency_formatter 函数在数值前添加 “$” 符号并保留两位小数。对于百分比格式，percent_formatter 函数将数值乘以 100 并添加 “%” 符号。

设置双坐标轴不同缩放比例（如线性与对数尺度）

当需要在同一图表中展示不同量级或变化规律的数据时，设置双坐标轴不同缩放比例是很有必要的。matplotlib 可以通过 twinx 方法创建共享 x 轴的第二个 y 轴，并且能为两个 y 轴分别设置不同的缩放比例，例如线性和对数尺度。

首先绘制一个基本的图形，然后使用 twinx 方法创建第二个 y 轴。接着，分别为两个 y 轴设置不同的缩放比例，线性尺度使用默认设置，对数尺度使用 set_yscale('log') 方法。

以下是示例代码：

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(1, 10, 100)
y1 = x
y2 = np.exp(x)

fig, ax1 = plt.subplots()

# 绘制第一个 y 轴的数据（线性尺度）
ax1.plot(x, y1, 'b-')
ax1.set_xlabel('X')
ax1.set_ylabel('Linear Scale', color='b')
ax1.tick_params('y', colors='b')

# 创建第二个 y 轴（对数尺度）
ax2 = ax1.twinx()
ax2.plot(x, y2, 'r-')
ax2.set_ylabel('Log Scale', color='r')
ax2.set_yscale('log')
ax2.tick_params('y', colors='r')

plt.show()

在这段代码中，ax1 是第一个 y 轴，使用线性尺度绘制 \(y = x\) 的数据。ax2 是通过 twinx 方法创建的第二个 y 轴，使用对数尺度绘制 \(y = e^x\) 的数据。通过分别设置 ylabel 和 tick_params，可以区分两个 y 轴的标签和刻度颜色。

实现极坐标下的雷达图（展示多维数据）

雷达图也被称为蜘蛛图，适合展示多维数据。在极坐标下实现雷达图，matplotlib 能很好地完成。

首先确定要展示的维度和每个维度的数据。接着，将数据转换为极坐标形式，计算每个维度对应的角度。然后，使用 polar 方法创建极坐标图，绘制雷达图的多边形。为了让图表更清晰，还可以添加数据标签和标题。

以下是示例代码：

import matplotlib.pyplot as plt
import numpy as np

# 定义维度和数据
categories = ['A', 'B', 'C', 'D', 'E']
values = [4, 3, 5, 2, 4]

# 计算角度
angles = np.linspace(0, 2 * np.pi, len(categories), endpoint=False)
values = np.concatenate((values, [values[0]]))
angles = np.concatenate((angles, [angles[0]]))

# 创建极坐标图
fig = plt.figure()
ax = fig.add_subplot(111, polar=True)
ax.plot(angles, values, 'o-', linewidth=2)
ax.fill(angles, values, alpha=0.25)

# 设置标签和标题
ax.set_thetagrids(angles * 180 / np.pi, categories)
ax.set_title('Radar Chart')

plt.show()

在这段代码中，np.linspace 计算每个维度对应的角度。为了让雷达图封闭，将数据和角度的第一个元素重复添加。plot 方法绘制雷达图的线条，fill 方法填充雷达图的内部。set_thetagrids 方法设置极坐标的标签。

创建自定义颜色映射（从蓝到红的渐变条）

matplotlib 允许用户创建自定义颜色映射。创建从蓝到红的渐变颜色映射，可借助 LinearSegmentedColormap 类。

首先，定义颜色映射的颜色断点和对应的颜色值。然后，使用 LinearSegmentedColormap.from_list 方法创建自定义颜色映射。最后，在绘图时使用这个自定义颜色映射。

以下是示例代码：

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import LinearSegmentedColormap

# 定义颜色映射的颜色断点和颜色值
colors = [(0, 'blue'), (1, 'red')]
cmap_name = 'blue_to_red'
cm = LinearSegmentedColormap.from_list(cmap_name, colors)

# 生成数据
x = np.linspace(0, 10, 100)
y = np.linspace(0, 10, 100)
X, Y = np.meshgrid(x, y)
Z = np.sqrt(X**2 + Y**2)

# 绘制图形并使用自定义颜色映射
plt.imshow(Z, cmap=cm)
plt.colorbar()
plt.show()

在这段代码中，colors 列表定义了颜色映射的起点和终点颜色。LinearSegmentedColormap.from_list 方法根据这个列表创建了名为 “blue_to_red” 的自定义颜色映射。在 imshow 函数中使用这个自定义颜色映射来绘制图形，并添加颜色条展示颜色映射。

添加 LaTeX 公式标注（如标题包含数学符号）

在 matplotlib 里添加 LaTeX 公式标注，能让图表的标题、标签等包含数学符号和公式。matplotlib 支持 LaTeX 语法，只需在字符串中使用美元符号 $ 包围 LaTeX 公式即可。

以下是示例代码：

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)

plt.plot(x, y)
plt.title(r'$y = \sin(x)$')
plt.xlabel(r'$x$')
plt.ylabel(r'$y$')

plt.show()

在这段代码中，r 前缀表示原始字符串，避免反斜杠被转义。$y = \sin(x)$、$x$ 和 $y$ 是 LaTeX 公式，分别作为标题、x 轴标签和 y 轴标签。这样，图表中的标题和标签就会以数学公式的形式显示。

优化图像导出质量（设置 dpi=300 且去除白边）

在数据可视化工作中，图像的导出质量至关重要。高质量的图像能够更清晰地展示数据特征，在学术论文、报告等场景中有着重要的应用。matplotlib 为我们提供了丰富的功能来优化图像导出质量，比如设置高分辨率（DPI）和去除白边。

DPI（每英寸点数）决定了图像的清晰度，数值越高图像越清晰。通常情况下，300 DPI 能满足大多数印刷需求。而去除白边可以让图像更加紧凑，突出主体内容。

在 matplotlib 里，我们可以使用 savefig 函数来保存图像，通过设置 dpi 参数为 300 来提高图像分辨率。同时，使用 bbox_inches='tight' 参数可以去除图像周围的白边。

以下是示例代码：

import matplotlib.pyplot as plt
import numpy as np

# 生成示例数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 绘制图形
plt.plot(x, y)

# 保存图像，设置 DPI 为 300 并去除白边
plt.savefig('output.png', dpi=300, bbox_inches='tight')

# 关闭图形
plt.close()

在上述代码中，首先生成了一组示例数据并绘制了一个简单的正弦曲线。然后使用 savefig 函数将图像保存为 output.png 文件，同时设置 dpi=300 以提高图像分辨率，bbox_inches='tight' 去除图像周围的白边。最后使用 plt.close() 关闭图形，释放资源。

实现暗黑主题样式（修改背景色、坐标轴颜色）

暗黑主题在视觉上能给人带来独特的感受，并且在某些场景下可以减少眼睛的疲劳。在 matplotlib 中，我们可以通过修改图形的背景色、坐标轴颜色等元素来实现暗黑主题样式。

具体来说，我们可以使用 rcParams 来全局设置图形的样式，也可以在单个图形中单独设置。通过修改 figure.facecolor（图形背景色）、axes.facecolor（坐标轴背景色）、axes.labelcolor（坐标轴标签颜色）、xtick.color（x 轴刻度颜色）和 ytick.color（y 轴刻度颜色）等参数，我们可以打造出一个暗黑主题的图形。

以下是示例代码：

import matplotlib.pyplot as plt
import numpy as np

# 设置暗黑主题样式
plt.rcParams['figure.facecolor'] = '#222222'
plt.rcParams['axes.facecolor'] = '#222222'
plt.rcParams['axes.labelcolor'] = 'white'
plt.rcParams['xtick.color'] = 'white'
plt.rcParams['ytick.color'] = 'white'

# 生成示例数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 绘制图形
plt.plot(x, y, color='cyan')

# 设置标题和标签
plt.title('Dark Theme Plot', color='white')
plt.xlabel('X')
plt.ylabel('Y')

# 显示图形
plt.show()

在这段代码中，首先使用 rcParams 全局设置了图形的背景色为深灰色（#222222），坐标轴标签颜色和刻度颜色为白色。然后生成了一组示例数据并绘制了一个正弦曲线，曲线颜色设置为青色（cyan）。最后设置了图形的标题和坐标轴标签，并显示图形。

实现实时数据刷新折线图（每秒追加新数据点）

实时数据可视化在很多领域都有着广泛的应用，比如金融市场监控、传感器数据实时展示等。在 matplotlib 中，我们可以使用 FuncAnimation 函数来实现实时数据刷新的折线图。

FuncAnimation 函数可以定时调用一个更新函数，在更新函数中我们可以追加新的数据点，并更新折线图的显示。

以下是示例代码：

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# 创建图形和坐标轴
fig, ax = plt.subplots()
x_data, y_data = [], []
line, = ax.plot([], [], lw=2)

# 初始化函数
def init():
    line.set_data([], [])
    return line,

# 更新函数
def update(frame):
    # 生成新的数据点
    x = frame
    y = np.sin(x)
    x_data.append(x)
    y_data.append(y)

    # 更新折线图
    line.set_data(x_data, y_data)
    ax.relim()
    ax.autoscale_view()

    return line,

# 创建动画
ani = animation.FuncAnimation(fig, update, frames=range(100), init_func=init, blit=True, interval=1000)

# 显示图形
plt.show()

在上述代码中，首先创建了一个空的折线图。然后定义了 init 函数用于初始化折线图，update 函数用于更新折线图的数据。在 update 函数中，每秒生成一个新的数据点并追加到 x_data 和 y_data 列表中，然后更新折线图的显示。最后使用 FuncAnimation 函数创建动画，设置更新间隔为 1000 毫秒（即每秒更新一次），并显示图形。

创建可缩放 / 平移的交互式图表

在处理复杂的数据可视化时，可缩放和平移的交互式图表能让用户更方便地查看数据细节。matplotlib 提供了内置的交互功能，通过 NavigationToolbar2TkAgg（在 Tkinter 环境中）或 NavigationToolbar2QT（在 Qt 环境中）等工具条，用户可以实现图表的缩放和平移操作。

以下是一个使用 Tkinter 作为后端的示例代码：

import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg
import tkinter as tk
import numpy as np

# 创建 Tkinter 窗口
root = tk.Tk()

# 生成示例数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 创建图形
fig = plt.Figure(figsize=(6, 4), dpi=100)
ax = fig.add_subplot(111)
ax.plot(x, y)

# 创建画布并将图形添加到画布上
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)

# 创建导航工具条
toolbar = NavigationToolbar2TkAgg(canvas, root)
toolbar.update()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)

# 运行 Tkinter 主循环
root.mainloop()

在这段代码中，首先创建了一个 Tkinter 窗口。然后生成了一组示例数据并绘制了一个正弦曲线。接着创建了一个 FigureCanvasTkAgg 画布，并将图形添加到画布上。最后创建了一个 NavigationToolbar2TkAgg 导航工具条，用户可以通过工具条上的按钮实现图表的缩放和平移操作。

开发图表配置 GUI 界面（滑动条调节参数）

开发一个图表配置的 GUI 界面可以让用户更直观地调整图表的参数。我们可以使用 tkinter 库来创建一个简单的 GUI 界面，通过滑动条来调节图表的参数，比如线条的宽度、颜色等。

以下是示例代码：

import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import tkinter as tk
import numpy as np

# 创建 Tkinter 窗口
root = tk.Tk()

# 生成示例数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 创建图形
fig = plt.Figure(figsize=(6, 4), dpi=100)
ax = fig.add_subplot(111)
line, = ax.plot(x, y)

# 创建画布并将图形添加到画布上
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)

# 定义滑动条回调函数
def update_line_width(value):
    line.set_linewidth(float(value))
    canvas.draw()

# 创建滑动条
slider = tk.Scale(root, from_=1, to=10, orient=tk.HORIZONTAL, command=update_line_width)
slider.set(2)
slider.pack(side=tk.BOTTOM)

# 运行 Tkinter 主循环
root.mainloop()

在上述代码中，首先创建了一个 Tkinter 窗口和一个简单的正弦曲线图表。然后定义了一个 update_line_width 回调函数，用于更新线条的宽度。接着创建了一个滑动条，用户可以通过滑动条调节线条的宽度，滑动条的值会传递给 update_line_width 函数，函数会更新线条的宽度并重新绘制图表。最后运行 Tkinter 的主循环，启动 GUI 界面。

生成 GIF 动态图展示迭代优化过程

在数据分析和机器学习领域，常常需要可视化迭代优化的过程，以此来深入理解算法的收敛情况与性能表现。借助 Python 的matplotlib和imageio库，能够生成 GIF 动态图，直观呈现迭代优化的进程。

matplotlib是一个强大的绘图库，可用于绘制各种静态图表；imageio则可用于处理图像和视频，方便生成 GIF 动态图。

下面通过一个简单的示例，展示如何生成一个 GIF 动态图来呈现迭代优化的过程。假设我们要优化一个简单的二次函数 \(f(x) = x^2\)，使用梯度下降法进行迭代优化。

以下是具体的实现代码：

import numpy as np
import matplotlib.pyplot as plt
import imageio

# 定义目标函数
def f(x):
    return x**2

# 定义梯度函数
def df(x):
    return 2 * x

# 梯度下降法迭代
def gradient_descent(x0, learning_rate, num_iterations):
    x = x0
    history = [x]
    for _ in range(num_iterations):
        grad = df(x)
        x = x - learning_rate * grad
        history.append(x)
    return history

# 初始化参数
x0 = 5
learning_rate = 0.1
num_iterations = 20

# 进行梯度下降迭代
history = gradient_descent(x0, learning_rate, num_iterations)

# 生成GIF动态图
filenames = []
for i, x in enumerate(history):
    plt.figure()
    # 绘制目标函数曲线
    x_vals = np.linspace(-6, 6, 100)
    y_vals = f(x_vals)
    plt.plot(x_vals, y_vals, label='f(x) = x^2')
    # 绘制当前迭代点
    plt.scatter(x, f(x), color='red', label=f'Iteration {i}')
    plt.title(f'Gradient Descent Iteration {i}')
    plt.xlabel('x')
    plt.ylabel('f(x)')
    plt.legend()
    # 保存当前帧
    filename = f'iteration_{i}.png'
    plt.savefig(filename)
    filenames.append(filename)
    plt.close()

# 使用imageio生成GIF
with imageio.get_writer('gradient_descent.gif', mode='I', duration=0.5) as writer:
    for filename in filenames:
        image = imageio.imread(filename)
        writer.append_data(image)

# 删除临时图片文件
import os
for filename in filenames:
    os.remove(filename)

在上述代码中，首先定义了目标函数 \(f(x) = x^2\) 及其梯度函数 \(df(x) = 2x\)。接着实现了梯度下降法的迭代过程，将每次迭代的结果存储在history列表中。

然后，通过循环遍历history列表，为每次迭代绘制一张静态图。在每张图中，绘制了目标函数的曲线以及当前迭代点，并且添加了标题、坐标轴标签和图例。将每张图保存为一个临时的 PNG 文件，并将文件名存储在filenames列表中。

最后，使用imageio库将所有临时 PNG 文件合并成一个 GIF 动态图，并设置每帧的显示时长为 0.5 秒。生成 GIF 后，删除所有临时 PNG 文件，以节省磁盘空间。

通过这种方式，我们可以清晰地看到梯度下降法在迭代优化过程中，点是如何逐步接近函数最小值的，从而更好地理解算法的工作原理和收敛情况。