1
2
3
4
5
6
7
8
9
10
x = np.linspace(0, 10+0.0001, 100)
y = np.exp(-x/2) * np.sin(2*x)
plt.figure(figsize=(10, 8))
plt.plot(x, y, color="orange", ls="-.", lw=2, marker="D", markevery=5, markersize=5, markeredgecolor="k", markerfacecolor="yellow", label=r"$e^{-x/2}*sin(2x)$")
plt.title("Damped Sine Wave")
plt.xlabel("Time(s)")
plt.ylabel("Amplitude")
plt.legend()
plt.grid()
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
labels = ["Group A", "Group B", "Group C", "Group D", "Group E"]
man_scores = np.random.randint(50, 80, size=len(labels))
woman_scores = np.random.randint(60, 90, size=len(labels))
men_std = np.random.randint(2, 8, size=len(labels))
women_std = np.random.randint(2, 8, size=len(labels))

plt.figure(figsize=(10, 6))
width=0.5 # 柱子的宽度

# 使用 `yerr` 或 `xerr` 参数为柱子添加误差条
plt.bar(labels, man_scores, width, yerr=man_std, label="Men", color="skyblue", edgecolor="blue", lw=1)
# 如果是堆叠柱状图：bottom=man_scores
plt.bar(labels, woman_scores, width, yerr=women_std, label="Women", bottom=man_scores, color="lightcoral", edgecolor="red", lw=1)

plt.ylabel("分数")
plt.title("分数（男生/女生）")
plt.legend()
plt.grid(True, ls=":", alpha=0.7)

plt.show()

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
plt.figure(figsize=(12, 7))
x_pos = np.arange(len(labels))
width = 0.35

rects1 = plt.bar(x_pos - width / 2, man_scores, width, label="Men", color="lightgreen", edgecolor="green", lw=1)

rects2 = plt.bar(x_pos + width / 2, woman_scores, width, label="Women", color="lightsalmon", edgecolor="brown", lw=1)

plt.ylabel("分数")
plt.title("分组带标签柱状图")
plt.xticks(x_pos, labels, rotation=45, ha="right")

plt.legend()

plt.grid(axis="y", ls=":", alpha=0.7)

# 添加数值标签的辅助函数
def autolabel(rects):
    for rect in rects:
        height = rect.get_height()
        plt.text(rect.get_x() + rect.get_width()/2, height + 1, f"{height}", ha="center", va="bottom", fontsize=10, color="gray")
        
        
        
autolabel(rects1)
autolabel(rects2)
plt.tight_layout()

plt.show()

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
labels = ["Q1", "Q2", "Q3"]
dataA = [120, 150, 130]
dataB = [100, 180, 110]


plt.figure(figsize=(12, 7))
x_pos = np.arange(len(labels))
width = 0.35

rects1 = plt.bar(x_pos - width / 2, dataA, width, label="companyA", color="lightgreen", edgecolor="green", lw=1)

rects2 = plt.bar(x_pos + width / 2, dataB, width, label="companyB", color="lightsalmon", edgecolor="brown", lw=1)

plt.ylabel("Sales (Millions)")
plt.xlabel("Quarter")
plt.title("Quarterly Sales Comparison")
plt.xticks(x_pos, labels, rotation=45, ha="right")

plt.legend()

plt.grid(axis="y", ls=":", alpha=0.7)

# 添加数值标签的辅助函数
def autolabel(rects):
    for rect in rects:
        height = rect.get_height()
        plt.text(rect.get_x() + rect.get_width()/2, height + 1, f"{height}", ha="center", va="bottom", fontsize=10, color="gray")
        
        
        
autolabel(rects1)
autolabel(rects2)
plt.tight_layout()

plt.show()

1
2
3
4
5
6
7
8
# 准备数据
r_line = np.arange(0, 2* np.pi + 0.00001, 0.01)  # 角度
y_line = r_line  # 半径随角度线性增长，形成螺旋线

fig = plt.figure(figsize=(10, 8))

# 定义极坐标系axes 
ax_polor_line = plt.subplot(111, projection="polar", facecolor="lightyellow")

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
# 准备数据
r_line = np.arange(0, 2* np.pi + 0.00001, 0.01)  # 角度
y_line = r_line  # 半径随角度线性增长，形成螺旋线

fig = plt.figure(figsize=(10, 8))

# 定义极坐标系axes 
ax_polor_line = plt.subplot(111, projection="polar", facecolor="lightyellow")

# 绘制极坐标系线性图
ax_polor_line.plot(r_line, y_line, color="darkblue", lw=2, label="螺旋线")

# 设置半径轴属性
ax_polor_line.set_rmax(2*np.pi + 0.00001)
ax_polor_line.set_rticks([np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi])
ax_polor_line.set_rlabel_position(-22.5)  # 设置半径刻度标签的位置

# 设置角度轴属性
ax_polor_line.set_thetagrids(np.arange(0, 360, 30))  # 角度网格线，每30度一个

ax_polor_line.grid(True, ls="--", alpha=0.7)
ax_polor_line.set_title("--螺旋线--", va = "bottom", pad = 20, fontsize=14)

ax_polor_line.legend(loc="upper right")
plt.show()

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
# 准备数据
N = 12  # 12个方向
theta_bar = np.linspace(0.0, 2 * np.pi, N, endpoint=False) # 角度
radii_bar = 10 + np.random.rand(N) * 5  # 随机半径
width_bar = (2 * np.pi) / N * 0.9 # 每个柱子的角度宽度，留出一点间隙

# 随机生成的颜色
# Colormap将数据集中每个点的数值映射为颜色，从而用颜色来直观地展示数据分布和变化
colors=plt.cm.viridis(radii_bar / radii_bar.max())  # 使用Colormap生成颜色
fig = plt.figure(figsize=(8, 8))

# 定义极坐标
ax_polor_bar = plt.subplot(111, projection="polar")
# 极坐标柱状图绘制
ax_polor_bar.bar(theta_bar, radii_bar, width=width_bar, bottom=0.0, color=colors, edgecolor="k", lw=0.5)

# 设置标题和半径轴
ax_polor_bar.set_title("风向频率图（极坐标系柱状图）", va="bottom", pad=20, fontsize=14)
ax_polor_bar.set_rmax(16)  # 最大半径
ax_polor_bar.set_rticks([5, 10, 15]) # 半径的刻度
ax_polor_bar.set_rlabel_position(90)

# 设置角度轴标签
direction_labels = ["N", "NNE", "NE", "ENE", "E", "ESE",
                   "SE", "SSE", "S", "SSW", "SW", "WSW"]
ax_polor_bar.set_xticks(theta_bar)
ax_polor_bar.set_xticklabels(direction_labels)
ax_polor_bar.tick_params(axis="x", labelsize=10)   # 角度标签字体大小

# 网格
ax_polor_bar.grid(True, ls="--", alpha=0.7)

plt.show()

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
# 准备数据
a = 1
theta = np.arange(0, 2* np.pi + 0.00001, 0.01)  # 角度
y_line = a * (1 + np.cos(theta))  # 半径随角度线性增长，形成螺旋线

fig = plt.figure(figsize=(10, 8))

# 定义极坐标系axes 
ax_polor_line = plt.subplot(111, projection="polar", facecolor="lightyellow")

# 绘制极坐标系线性图
ax_polor_line.plot(r_line, y_line, color="red", lw=2, label="螺旋线")

# 设置半径轴属性
ax_polor_line.set_rmax(2)
ax_polor_line.set_rticks([np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi])
ax_polor_line.set_rlabel_position(-22.5)  # 设置半径刻度标签的位置

# 设置角度轴属性
ax_polor_line.set_thetagrids(np.arange(0, 360, 30))  # 角度网格线，每30度一个

ax_polor_line.grid(True, ls="--", alpha=0.7)
ax_polor_line.set_title("Cardioid on Polar Axis", va = "bottom", pad = 20, fontsize=14)

ax_polor_line.legend(loc="upper right")
plt.show()

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
# 绘制正态分布的概率密度函数
from scipy.stats import norm

# 准备数据
mu = 100  # 均值
sigma = 15 # 标准差
x_data = np.random.normal(loc=mu, scale = sigma, size=10000)  # 生成正态分布

fig, ax = plt.subplots(figsize=(10, 6))

# 绘制直方图
# density=True   归一化为概率密度
n, bins, patches = ax.hist(x_data, bins = 50, density=True, alpha=0.7, color="skyblue", edgecolor="k", label="数据直方图")


# 绘制理论的概率密度函数（PDF）
y_pdf = norm.pdf(bins, loc=mu, scale=sigma)
ax.plot(bins, y_pdf, "--", color="red", lw=2, label="理论概率密度")

# 添加标题和标签
ax.set_xlabel("值：")
ax.set_ylabel("概率密度：")
ax.set_title("--直方图--")

ax.legend(loc="upper right")
ax.grid(True, ls=":", alpha=0.7)

fig.tight_layout()
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
data_group1 = np.random.normal(loc=90, scale=10, size=5000)
data_group2 = np.random.normal(loc=110, scale=12, size=5000)

plt.figure(figsize=(10, 6))
# 非堆叠直方图（默认）
plt.hist([data_group1, data_group2], bins=30, density=True, alpha=0.6, color=["blue", "green"], label=["组1", "组2"])
plt.title("非堆叠直方图")
plt.xlabel("取值")
plt.ylabel("概率密度")
plt.legend()
plt.grid(True, ls=":", alpha=0.7)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
data_group1 = np.random.normal(loc=90, scale=10, size=5000)
data_group2 = np.random.normal(loc=110, scale=12, size=5000)

plt.figure(figsize=(10, 6))
# 堆叠直方图
plt.hist([data_group1, data_group2], bins=30, density=True, alpha=0.8, color=["blue", "green"], label=["组1", "组2"], stacked=True)
plt.title("堆叠直方图")
plt.xlabel("取值")
plt.ylabel("概率密度")
plt.legend()
plt.grid(True, ls=":", alpha=0.7)
plt.show()

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
# 绘制正态分布的概率密度函数
from scipy.stats import norm

# 准备数据
mu = 0  # 均值
sigma = 1 # 标准差
x_data = np.random.normal(loc=mu, scale = sigma, size=10000)  # 生成正态分布

fig, ax = plt.subplots(figsize=(10, 6))

# 绘制直方图
# density=True   归一化为概率密度
n, bins, patches = ax.hist(x_data, bins = 50, density=True, alpha=0.7, color="skyblue", edgecolor="darkblue", label="数据直方图")


# 绘制理论的概率密度函数（PDF）
y_pdf = norm.pdf(bins, loc=mu, scale=sigma)
ax.plot(bins, y_pdf, "--", color="red", lw=2, label="理论概率密度")

# 添加标题和标签
ax.set_xlabel("Value")
ax.set_ylabel("Probability Density")
ax.set_title("tandard Normal Distribution Histogram and PDF")

ax.legend(loc="upper right")
ax.grid(True, ls=":", alpha=0.7)

fig.tight_layout()
plt.show()

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
# 准备数据，4组不同分布的数据

data1 = np.random.normal(loc=0, scale=1, size=200)   # 标准正态
data2 = np.random.normal(loc=2, scale=0.5, size=200)   # 均值偏移，方差减小
data3 = np.random.normal(loc=-1, scale=2, size=200)   # 均值偏移，方差变大
data4 = np.concatenate((np.random.normal(loc=5, scale=1, size=100), np.random.normal(loc=10, scale=0.5, size=50), np.random.normal(loc=-2, scale=0.8, size=50)))

all_data = [data1, data2, data3, data4]
labels = ["Group_A", "Group_B", "Group_C", "Group_D"]

plt.figure(figsize=(10, 7))

# 绘制箱线图
bplot = plt.boxplot(
    all_data,
    notch=True,# 箱体中间会有一个凹口，用于表示中位数的置信区间
    vert=True, #绘制垂直箱形图
    patch_artist=True, # 箱体将是 `Patch` 对象，可以设置填充颜色等
    tick_labels=labels,
    showmeans=True, # 展示均值
    flierprops=dict(marker="o", markerfacecolor="red", markersize=8, alpha=0.6), # 离群点的样式
    medianprops=dict(color="blue", lw=2), # 中位数线样式
    boxprops=dict(edgecolor="k", lw=1.5),   # 箱体边缘样式
    whiskerprops=dict(color="gray", ls="--", lw=1), # 须线样式
    capprops=dict(color="gray", lw=1.5)  # 须帽样式
)

# 为每个箱体设置不同的颜色
colors=["lightblue", "lightgreen", "lightcoral", "lightgoldenrodyellow"]
for patch, color in zip(bplot["boxes"], colors):
    patch.set_facecolor(color)
    
plt.title("数据分布的箱线图", fontsize=16)
plt.xlabel("数据组")
plt.ylabel("值")

plt.grid(axis="y", ls=":", alpha=0.7)
plt.show()

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
# 准备数据，4组不同分布的数据

data1 = np.random.normal(loc=75, scale=8, size=200)   # 标准正态
data2 = np.random.normal(loc=80, scale=5, size=200)   # 均值偏移，方差减小
data3 = np.random.normal(loc=70, scale=10, size=200)   # 均值偏移，方差变大

all_data = [data1, data2, data3]
labels = ["班级A", "班级B", "班级C"]

plt.figure(figsize=(10, 7))

# 绘制箱线图
bplot = plt.boxplot(
    all_data,
    notch=True,# 箱体中间会有一个凹口，用于表示中位数的置信区间
    vert=True, #绘制垂直箱形图
    patch_artist=True, # 箱体将是 `Patch` 对象，可以设置填充颜色等
    tick_labels=labels,
    showmeans=True, # 展示均值
    flierprops=dict(marker="D", markerfacecolor="green", markersize=8, alpha=0.6), # 离群点的样式
    meanprops=dict(marker="*", markerfacecolor="purple", markersize=12, markeredgecolor="yellow"),
    medianprops=dict(color="blue", lw=2), # 中位数线样式
    boxprops=dict(edgecolor="k", lw=1.5),   # 箱体边缘样式
    whiskerprops=dict(color="gray", ls="--", lw=1), # 须线样式
    capprops=dict(color="gray", lw=1.5)  # 须帽样式
)

# 为每个箱体设置不同的颜色
colors=["lightblue", "lightgreen", "red"]
for patch, color in zip(bplot["boxes"], colors):
    patch.set_facecolor(color)
    
plt.title("Class Exam Scores Distribution", fontsize=16)
plt.xlabel("Class")
plt.ylabel("Score")

plt.grid(axis="y", ls=":", alpha=0.7)
plt.show()

1
!pip install scikit-learn

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import numpy as np

# 生成模拟聚类数据
X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# 运行 KMeans 聚类
kmeans = KMeans(n_clusters=4, random_state=0, n_init=10)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)

plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis', alpha=0.8)
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],
            s=200, marker='X', c='red', edgecolor='black', label='Cluster Centers')
plt.title('K-Means Clustering Results', fontsize=16)
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()
plt.grid(True, linestyle=':', alpha=0.7)
plt.show()

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
# 数据准备
np.random.seed(42)  # 为了结果可以复现
num_points = 50
data_x = np.random.randn(num_points)
data_y = data_x * 0.8 + np.random.randn(num_points) * 2  # 带了一些噪声
sizes = np.random.randint(50, 500, size=num_points)
colors = np.random.randn(num_points)

plt.figure(figsize=(10, 7))

# 绘制散点图
scatter_plot = plt.scatter(
    data_x,
    data_y,
    s = sizes,  # 尺寸（气泡大小）
    c = colors,
    cmap="viridis", # 颜色映射
    alpha=0.6,
    marker="o",
    edgecolor="k",
    lw=0.5
)

# 添加标题和标签
plt.title("散点图绘制", fontsize=16)
plt.xlabel("X 轴值")
plt.ylabel("Y 轴值")

# 添加颜色条（当使用c参数进行颜色映射时非常重要）
cbar = plt.colorbar(scatter_plot)
cbar.set_label("颜色值")

plt.grid(True, ls=":", alpha=0.7)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
np.random.seed(42)  # 为了结果可以复现
num_points = 150
data_x = np.random.randn(num_points)
data_y = data_x * 0.8 + np.random.randn(num_points) * 2  # 带了一些噪声
plt.figure(figsize=(8, 6))
plt.scatter(data_x[:50], data_y[:50], s=100, c='red', marker='o', edgecolors='blue', linewidths=1.5, label='Group 1')
plt.scatter(data_x[50:100], data_y[50:100], s=150, c='green', marker='s', edgecolors='purple', linewidths=1.5, label='Group 2')
plt.scatter(data_x[100:], data_y[100:], s=200, c='blue', marker='^', edgecolors='orange', linewidths=1.5, label='Group 3')
plt.title('Scatter Plot with Different Markers and Edge Colors')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.legend()
plt.grid(True, linestyle=':', alpha=0.7)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
np.random.seed(42)
num_points = 100
x = np.random.rand(num_points) * 10
y = np.random.rand(num_points) * 10
points_size = np.random.randint(50, 500, size=num_points)
color_values = np.random.rand(num_points)

plt.figure(figsize=(9, 7))

# 绘制散点图
scatter_plot = plt.scatter(x, y, s=points_size, c=color_values, cmap="viridis",
           edgecolor="k", lw=1)
plt.title("Random Scatter Plot with Size and Color Variation")
plt.xlabel("X-coordinate")
plt.ylabel("Y-coordinate")

# 添加颜色条（当使用c参数进行颜色映射时非常重要）
cbar = plt.colorbar(scatter_plot)
cbar.set_label("Random Color Value")

plt.grid(True, ls=":", alpha=0.7)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
labels_pie = ["五星", "四星", "三星", "二星", "一星"]
percent_pie = [95, 261, 105, 30, 9] # 某市星级酒店数量

plt.figure(figsize=(7, 7), dpi=100)

# 偏移中心量，突出一部分
explode_pie = (0, 0.1, 0, 0, 0) # 为了突出四星级酒店

# 绘制饼图
plt.pie(
    x=percent_pie, 
    explode=explode_pie, 
    labels=labels_pie, 
    colors=plt.cm.Paired.colors, # 颜色映射
    autopct="%1.1f%%", # 保留一位小数的百分比
    pctdistance=0.85,  # 百分比文本距离圆心的比例
    shadow=True,
    startangle=90 # 从90度开始绘制第一个扇形
)
plt.title("某市星级酒店数量分布", pad=20, fontsize=16)
plt.axis("equal") # 确保饼图是圆形
plt.show()

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
80
81
import pandas as pd
import matplotlib.pyplot as plt

# 模拟数据
data = {
    'type': ['水果', '水果', '蔬菜', '蔬菜', '肉类', '肉类', '谷物'],
    '食材': ['苹果', '香蕉', '白菜', '胡萝卜', '猪肉', '牛肉', '大米'],
    '花费': [50, 30, 20, 25, 80, 70, 40]
}
food = pd.DataFrame(data)

# --- 关键的修复步骤 ---
# 1. 明确定义内部饼图的顺序
#    这里我们仍然需要一个逻辑顺序来对齐内外层，即使颜色是自动的。
#    例如，我们可以根据类型名称的字母顺序，或者数据框中第一次出现的顺序。
#    为了确保内外层对应，最可靠的方法是先对数据进行排序。
#    这里我们沿用之前的逻辑，先按类型排序，这样同一类型的食材会聚集在一起。
food_sorted = food.sort_values(by=['type', '花费'], ascending=[True, False])

# 分组聚合，内圈数据（按照类型）
inner_data = food_sorted.groupby(by="type")["花费"].sum()
# 确保 inner_data 的索引顺序与 food_sorted 中 type 出现的顺序一致
# (groupby 默认会排序，所以这里可以省略 reindex，但显式写出更清晰)
inner_data = inner_data.reindex(food_sorted['type'].unique())


# 外圈数据（按照食材）
outer_data = food_sorted["花费"]
outer_labels = food_sorted["食材"]


plt.rcParams["font.size"] = 12
plt.figure(figsize=(10, 8)) # 调整图表大小以获得更好的显示效果

# 绘制内部饼图
# 使用 plt.cm.Set3.colors 作为内部饼图的颜色循环
wedges_inner, texts_inner, autotexts_inner = plt.pie(
    x = inner_data,
    radius = 0.6,
    wedgeprops=dict(lw=3, width=0.6, edgecolor="w"),
    labels=inner_data.index,
    labeldistance=0.7,
    startangle=90,
    colors=plt.cm.Set3.colors, # 让Matplotlib自动选择颜色
    autopct="%1.1f%%"
)

# 调整内部百分比文本颜色
for autotext in autotexts_inner:
    autotext.set_color("blue")
    autotext.set_fontsize(10)

# 绘制外部饼图
# 使用 plt.cm.tab20.colors 作为外部饼图的颜色循环
wedges_outer, texts_outer, autotexts_outer = plt.pie(
    x = outer_data,
    radius = 1,
    wedgeprops=dict(lw=3, width=0.3, edgecolor="k"),
    labels=outer_labels, # 使用排序后的食材标签
    labeldistance=1.05,
    autopct="%1.1f%%",
    pctdistance=0.85,
    startangle=90,
    colors=plt.cm.tab20.colors # 让Matplotlib自动选择颜色，通常tab20颜色更多，适合外层
)

# 调整外部百分比文本颜色
for autotext in autotexts_outer:
    autotext.set_color("darkred")
    autotext.set_fontsize(8)

plt.title("食物花费嵌套饼图", pad=20, fontsize=18)
plt.axis("equal") # 确保饼图是圆形

# 图例标题
# 此时图例颜色将根据 Matplotlib 自动分配的颜色来显示
plt.legend(inner_data.index, title="食物类型", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1), fontsize=10)


plt.tight_layout()
plt.show()

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
plt.figure(figsize=(7, 7), dpi=400)

# 数据
recipe = ["225g 面粉",
          "90g 糖",
          "1个鸡蛋",
          "60g 黄油",
          "100ml 牛奶",
          "1/2包酵母"]
data_donut = np.array([225, 90, 50, 60, 100, 5])
# 归一化
data_donut_norm = data_donut / data_donut.sum()

# 绘制甜甜圈图， 通过wedgeprops的width参数<radius参数创造空心
wedges, texts, autotexts = plt.pie(
    data_donut_norm,
    autopct="%1.1f%%",
    pctdistance=0.85,
    startangle=90, 
    radius=1.2,
    wedgeprops=dict(width=0.4, edgecolor="w",lw=1), # 甜甜圈的关键：width<radius 
    colors=plt.cm.tab10.colors
)

# 调整百分比文本颜色和大小
for autotext in autotexts:
    autotext.set_color("white")
    autotext.set_fontsize(10)
    
# 添加注释和箭头指向每个扇形
bbox_props = dict(boxstyle="round, pad=0.3", fc="w", ec="k", lw=0.72)
kw = dict(arrowprops=dict(arrowstyle="-"), bbox=bbox_props, va="center")

for i, p in enumerate(wedges):
    ang = (p.theta2 - p.theta1) / 2. + p.theta1  # 计算扇形中心角度
    y = np.sin(np.deg2rad(ang))
    x = np.cos(np.deg2rad(ang))
    # 根据x坐标判断文本水平对齐方式，使其位于扇形外侧
    ha={-1:"right", 1:"left"}[int(np.sign(x))]
    # 箭头连接样式， 从扇形中心指向文本
    connectionstyle=f"angle, angleA=0, angleB={ang}"
    kw["arrowprops"].update({"connectionstyle":connectionstyle})
    
    # xytext的位置需要根据x, y符号调整，确保文本在甜甜圈外侧
    # 1.4 * np.sign(x), 1.4*y确保文本在外部
    plt.annotate(
        recipe[i],
        xy = (x * 1.05, y * 1.05),
        xytext=(1.4 * np.sign(x), 1.4*y),
        ha=ha,
        fontsize=10, 
        weight="bold",
        **kw
    )
    
plt.title("甜甜圈图---->")
plt.axis("equal")
plt.tight_layout()
plt.show()

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
80
81
import pandas as pd
import matplotlib.pyplot as plt

# 模拟数据
data = {
    'type': ['研发部', '研发部', '销售部', '销售部', '行政部', '行政部'],
    '子类别': ['前端', '后端', '国内', '国际', '人力资源', '财务'],
    '员工人数': [70, 80, 60, 40, 30, 20]
}
food = pd.DataFrame(data)

# --- 关键的修复步骤 ---
# 1. 明确定义内部饼图的顺序
#    这里我们仍然需要一个逻辑顺序来对齐内外层，即使颜色是自动的。
#    例如，我们可以根据类型名称的字母顺序，或者数据框中第一次出现的顺序。
#    为了确保内外层对应，最可靠的方法是先对数据进行排序。
#    这里我们沿用之前的逻辑，先按类型排序，这样同一类型的食材会聚集在一起。
food_sorted = food.sort_values(by=['type', '员工人数'], ascending=[True, False])

# 分组聚合，内圈数据（按照类型）
inner_data = food_sorted.groupby(by="type")["员工人数"].sum()
# 确保 inner_data 的索引顺序与 food_sorted 中 type 出现的顺序一致
# (groupby 默认会排序，所以这里可以省略 reindex，但显式写出更清晰)
inner_data = inner_data.reindex(food_sorted['type'].unique())


# 外圈数据（按照食材）
outer_data = food_sorted["员工人数"]
outer_labels = food_sorted["子类别"]


plt.rcParams["font.size"] = 12
plt.figure(figsize=(10, 8), dpi=300) # 调整图表大小以获得更好的显示效果

# 绘制内部饼图
# 使用 plt.cm.Set3.colors 作为内部饼图的颜色循环
wedges_inner, texts_inner, autotexts_inner = plt.pie(
    x = inner_data,
    radius = 0.6,
    wedgeprops=dict(lw=3, width=0.6, edgecolor="w"),
    labels=inner_data.index,
    labeldistance=0.7,
    startangle=90,
    colors=plt.cm.Set3.colors, # 让Matplotlib自动选择颜色
    autopct="%1.1f%%"
)

# 调整内部百分比文本颜色
for autotext in autotexts_inner:
    autotext.set_color("blue")
    autotext.set_fontsize(10)

# 绘制外部饼图
# 使用 plt.cm.tab20.colors 作为外部饼图的颜色循环
wedges_outer, texts_outer, autotexts_outer = plt.pie(
    x = outer_data,
    radius = 1,
    wedgeprops=dict(lw=3, width=0.3, edgecolor="k"),
    labels=outer_labels, # 使用排序后的食材标签
    labeldistance=1.05,
    autopct="%1.1f%%",
    pctdistance=0.85,
    startangle=90,
    colors=plt.cm.tab20.colors # 让Matplotlib自动选择颜色，通常tab20颜色更多，适合外层
)

# 调整外部百分比文本颜色
for autotext in autotexts_outer:
    autotext.set_color("darkred")
    autotext.set_fontsize(8)

plt.title("Company Employee Distribution", pad=20, fontsize=18)
plt.axis("equal") # 确保饼图是圆形

# 图例标题
# 此时图例颜色将根据 Matplotlib 自动分配的颜色来显示
plt.legend(inner_data.index, title="Department", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1), fontsize=10)


plt.tight_layout()
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# 模拟真实标签和预测标签
y_true = np.array([0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 0, 1, 1, 2, 2])
y_pred = np.array([0, 1, 1, 0, 2, 2, 0, 0, 2, 1, 0, 1, 1, 2, 1])

# 计算混淆矩阵
cm = confusion_matrix(y_true, y_pred)
class_names = ['Class 0', 'Class 1', 'Class 2']

plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=True,
            xticklabels=class_names, yticklabels=class_names,
            linewidths=.5, linecolor='black')
plt.xlabel('Predicted Label')
plt.ylabel('True Label')
plt.title('Confusion Matrix', fontsize=16)
plt.show()

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
# 准备数据：
vegetables = ["黄瓜", "番茄", "生菜", "芦笋", "土豆", "小麦", "大麦"]
farmers = ['农民A', '农民B', '农民C', '农民D', '农民E', '农民F', '农民G']

# 模拟农民丰收的数据
harvest = np.random.rand(len(vegetables), len(farmers))  # 7*7的矩阵（方阵）

plt.figure(figsize=(10, 10))

# 绘制热力图
# cmap="YIGnBu"是一个从浅黄到深绿蓝的颜色映射
# `origin`: 图像的原点位置（`'upper'` (默认) 或 `'lower'`）。
# `aspect`: 图像的宽高比。`'auto'` (默认) 自动调整，`'equal'` 保持像素的方形。
im = plt.imshow(harvest, cmap="YlGnBu", origin="upper", aspect="auto")

# 设置X轴和Y轴的刻度标签
plt.xticks(np.arange(len(farmers)), farmers, rotation=45, ha="right", fontsize=12)
plt.yticks(np.arange(len(vegetables)), vegetables, fontsize=12)

# 绘制每个单元格的数值文本
for i in range(len(vegetables)):
    for j in range(len(farmers)):
        text = plt.text(
            j,i,
            f"{harvest[i, j]:.1f}",
            ha="center",
            va="center",
            color="k",
            fontsize=9, 
            weight="bold"
        )
        
# 添加颜色条和标题
plt.title("本地农民农作物收成（吨/年）", pad=20, fontsize=18)
cbar = plt.colorbar(im, fraction=0.046, pad=0.04)
cbar.set_label("收成（吨）", rotation=270, labelpad=15, fontsize=12)

plt.tight_layout()
plt.show()

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
plt.figure(figsize=(7, 7), dpi=300)
m = np.random.randint(1, 101, size=(5, 5))
im = plt.imshow(m, cmap="hot", origin="upper", aspect="auto")


# 绘制每个单元格的数值文本
for i in range(5):
    for j in range(5):
        text = plt.text(
            j,i,
            f"{m[i, j]:.1f}",
            ha="center",
            va="center",
            color="blue",
            fontsize=9, 
            weight="bold"
        )
        
plt.title("Random 5x5 Matrix Heatmap", pad=20, fontsize=18)
plt.xlabel("Column Index")
plt.ylabel("Row Index")


# 添加颜色条和标题
cbar = plt.colorbar(im, fraction=0.046, pad=0.04)
cbar.set_label("Value", rotation=270, labelpad=15, fontsize=12)

plt.tight_layout()
plt.show()

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. 准备数据
days = np.arange(1, 6) # 5天
sleeping = [7, 8, 6, 11, 7] # 睡眠时间
eating = [2, 3, 4, 3, 2] # 吃饭时间
working = [7, 8, 7, 2, 2] # 工作时间
playing = [8, 5, 7, 8, 13] # 娱乐时间

plt.figure(figsize=(10, 7))

# 绘制堆叠面积图
plt.stackplot(
    days,
    sleeping,
    eating,
    working,
    playing,
    labels=['Sleeping', 'Eating', 'Working', 'Playing'], # 每个层的标签
    colors=['#6d904f', '#fc4f30', '#008fd5', '#e5ae38'], # 自定义颜色
    alpha=0.8 # 透明度
)
plt.xlabel('Day of the Week', fontsize=12)
plt.ylabel('Hours Spent', fontsize=12)
plt.title('Daily Activities Stack Plot', fontsize=16)
plt.legend(loc="upper left", fontsize=10)

plt.grid(True, ls=":", alpha=0.7)
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
x_base = np.linspace(0, 10, 100)
y1_base = np.sin(x_base)
y2_base = np.cos(x_base)

plt.figure(figsize=(10, 5), dpi=250)

# baseline="sym"   堆叠在 Y=0 的两侧对称
plt.stackplot(x_base, y1_base, y2_base, labels=["Sin", "Cos"], alpha=0.7, baseline="sym")
plt.title('Symmetric Stack Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.legend()
plt.grid(True, linestyle=':', alpha=0.7)
plt.show()

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
# 1. 准备数据
days = np.arange(1, 8) # 7天
direct = [50, 60, 55, 70, 80, 75, 90]
search_engine = [30, 40, 45, 50, 60, 65, 70]
social_media = [20, 25, 30, 35, 40, 45, 50]

plt.figure(figsize=(10, 7))

# 绘制堆叠面积图
plt.stackplot(
    days,
    direct,
    search_engine,
    social_media,
    labels=['direct', 'Search Engine', 'Social Media'], # 每个层的标签
    colors=['#6d904f', '#fc4f30', '#008fd5'], # 自定义颜色
    alpha=0.8 # 透明度
)
plt.xlabel('Day', fontsize=12)
plt.ylabel('Traffic Count', fontsize=12)
plt.title('Website Traffic Sources Over 7 Days', fontsize=16)
plt.legend(loc="upper left", fontsize=10)

plt.grid(True, ls=":", alpha=0.7)
plt.show()

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
# 1. 准备数据
labels = np.array(["个人能力", "IQ", "服务意识", "团队精神", "解决问题能力", "持续学习"])
stats_person1 = [83, 61, 95, 67, 76, 88] # 某人的能力得分
stats_person2 = [70, 85, 75, 90, 80, 70] # 另一个人或团队的能力得分

# 2. 画图数据准备：计算角度
num_vars = len(labels)
angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist() # 角度列表
# 为了闭合图形，需要将第一个数据点和角度复制到末尾
stats_person1 = stats_person1 + stats_person1[:1]
stats_person2 = stats_person2 + stats_person2[:1]
angles = angles + angles[:1]

# 3. 用Matplotlib画蜘蛛图
fig = plt.figure(figsize=(9, 9), dpi=300)
ax = fig.add_subplot(111, polar=True) # 创建极坐标 Axes

# 绘制第一个人的数据
ax.plot(angles, stats_person1, 'o-', linewidth=2, color='blue', label='Person A') # 连线
ax.fill(angles, stats_person1, color='blue', alpha=0.25) # 填充

# 绘制第二个人的数据
ax.plot(angles, stats_person2, 'o-', linewidth=2, color='green', label='Person B') # 连线
ax.fill(angles, stats_person2, color='green', alpha=0.25) # 填充

# 4. 设置角度轴标签
ax.set_thetagrids(np.array(angles[:-1]) * 180 / np.pi, labels, fontsize=14) # 角度值和标签

# 5. 设置径向轴刻度
ax.set_rgrids([20, 40, 60, 80, 100], fontsize=12) # 半径刻度
ax.set_ylim(0, 100) # 设置径向轴范围 (0-100分)

# 6. 添加标题和图例
ax.set_title("个人能力雷达图对比", fontsize=18, pad=20)
ax.legend(loc='upper right', bbox_to_anchor=(1.2, 1.1), fontsize=12) # 调整图例位置

ax.grid(True, linestyle=':', alpha=0.7)
plt.tight_layout()
plt.show()

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
# 1. 准备数据
labels = np.array(["性能", "拍照", "续航", "屏幕", "价格"])
stats_A = [8, 7, 9, 8, 6]
stats_B = [7, 9, 7, 9, 8]

# 2. 画图数据准备：计算角度
num_vars = len(labels)
angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist() # 角度列表
# 为了闭合图形，需要将第一个数据点和角度复制到末尾
stats_A = stats_A + stats_A[:1]
stats_B = stats_B + stats_B[:1]
angles = angles + angles[:1]

# 3. 用Matplotlib画蜘蛛图
fig = plt.figure(figsize=(9, 9), dpi=300)
ax = fig.add_subplot(111, polar=True) # 创建极坐标 Axes

# 绘制第一个人的数据
ax.plot(angles, stats_A, 'o-', linewidth=2, color='blue', label='手机A') # 连线
ax.fill(angles, stats_A, color='lightblue', alpha=0.25) # 填充

# 绘制第二个人的数据
ax.plot(angles, stats_B, 'o-', linewidth=2, color='green', label='手机B') # 连线
ax.fill(angles, stats_B, color='lightgreen', alpha=0.25) # 填充

# 4. 设置角度轴标签
ax.set_thetagrids(np.array(angles[:-1]) * 180 / np.pi, labels, fontsize=14) # 角度值和标签

# 5. 设置径向轴刻度
ax.set_rgrids([2, 4, 6, 8, 10], fontsize=12) # 半径刻度
ax.set_ylim(0, 10) # 设置径向轴范围 (0-100分)

# 6. 添加标题和图例
ax.set_title("Smartphone Comparison Radar Chart", fontsize=18, pad=20)
ax.legend(loc='upper right', bbox_to_anchor=(1.2, 1.1), fontsize=12) # 调整图例位置

ax.grid(True, linestyle=':', alpha=0.7)
plt.tight_layout()
plt.show()