Python Tkinter之报表动态图表输出

pip install matplotlib

# 静态图表嵌入基础示例
import tkinter as tk
from tkinter import ttk
import matplotlib
matplotlib.use("TkAgg")  # 必须在import pyplot之前指定后端
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
from matplotlib.figure import Figure
import matplotlib.font_manager as fm

# ── 解决中文乱码（Windows环境）──────────────────────────────
plt.rcParams["font.sans-serif"] = ["Microsoft YaHei", "SimHei"]
plt.rcParams["axes.unicode_minus"] = False# 负号正常显示


classStaticChartApp(tk.Tk):
def__init__(self):
super().__init__()
self.title("销售报表 - 静态图表示例")
self.geometry("860x560")
self.configure(bg="#f7f7f7")
self._build_ui()

def_build_ui(self):
# 顶部标题栏
        header = tk.Frame(self, bg="#2c3e50", height=48)
        header.pack(fill="x")
        header.pack_propagate(False)
        tk.Label(header, text="2025年各季度销售额对比",
                 font=("微软雅黑", 14, "bold"),
                 bg="#2c3e50", fg="white").pack(side="left", padx=20, pady=12)

# 图表区域
        chart_frame = tk.Frame(self, bg="#f7f7f7")
        chart_frame.pack(fill="both", expand=True, padx=16, pady=12)

        fig = self._create_bar_chart()

# FigureCanvasTkAgg：把Figure渲染成Tkinter Canvas
        canvas = FigureCanvasTkAgg(fig, master=chart_frame)
        canvas.draw()
        canvas.get_tk_widget().pack(fill="both", expand=True)

# 可选：加上Matplotlib自带的工具栏（缩放、平移、保存）
        toolbar_frame = tk.Frame(self, bg="#eeeeee")
        toolbar_frame.pack(fill="x")
        toolbar = NavigationToolbar2Tk(canvas, toolbar_frame)
        toolbar.update()

def_create_bar_chart(self) -> Figure:
"""创建柱状图，返回Figure对象"""
        quarters = ["Q1", "Q2", "Q3", "Q4"]
        sales_a = [128, 195, 167, 234]   # 产品A
        sales_b = [98,  142, 188, 210]   # 产品B

        fig = Figure(figsize=(8, 4.5), dpi=100, facecolor="#f7f7f7")
        ax = fig.add_subplot(111)

        x = range(len(quarters))
        width = 0.35

        bars_a = ax.bar([i - width/2for i in x], sales_a,
                        width, label="产品A", color="#3498db", alpha=0.85)
        bars_b = ax.bar([i + width/2for i in x], sales_b,
                        width, label="产品B", color="#e74c3c", alpha=0.85)

# 在柱子顶部标注数值
for bar in bars_a:
            ax.text(bar.get_x() + bar.get_width() / 2,
                    bar.get_height() + 3,
f"{int(bar.get_height())}",
                    ha="center", va="bottom",
                    fontsize=9, color="#2c3e50")
for bar in bars_b:
            ax.text(bar.get_x() + bar.get_width() / 2,
                    bar.get_height() + 3,
f"{int(bar.get_height())}",
                    ha="center", va="bottom",
                    fontsize=9, color="#2c3e50")

        ax.set_xticks(list(x))
        ax.set_xticklabels(quarters, fontsize=11)
        ax.set_ylabel("销售额（万元）", fontsize=10)
        ax.set_ylim(0, 280)
        ax.legend(fontsize=10)
        ax.set_facecolor("#fafafa")
        ax.spines["top"].set_visible(False)
        ax.spines["right"].set_visible(False)
        fig.tight_layout()

return fig


if __name__ == "__main__":
    app = StaticChartApp()
    app.mainloop()

这段代码有两个地方容易被忽略。

第一是matplotlib.use("TkAgg")——这行必须在import matplotlib.pyplot之前执行，否则后端已经初始化完了，再改就不管用了，程序要么报错要么图表显示异常。

第二是中文字体配置。Windows下Matplotlib默认不认中文，坐标轴标签、图例全部变成方块。用plt.rcParams["font.sans-serif"] = ["Microsoft YaHei"]指定微软雅黑就能解决，这个配置放在模块顶部全局生效。

⚡ 方案二：动态实时刷新——让图表"活"起来

静态图表只是第一步。真正让报表系统有价值的，是数据能实时更新、图表跟着动。

实现动态刷新的核心是两个东西：ax.clear()清空上一帧的绘图内容，然后重新绘制新数据；再加上Tkinter的after()定时器驱动整个刷新循环。

# 实时数据动态折线图
import tkinter as tk
from tkinter import ttk
import matplotlib
matplotlib.use("TkAgg")
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
import matplotlib.pyplot as plt
import random
import collections

plt.rcParams["font.sans-serif"] = ["Microsoft YaHei"]
plt.rcParams["axes.unicode_minus"] = False

REFRESH_INTERVAL = 1000# 刷新间隔，单位毫秒
MAX_POINTS = 30# 折线图最多保留的数据点数


classRealtimeLineChart(tk.Tk):
"""
    实时折线图演示。
    模拟两路传感器数据，每秒刷新一次图表。
    deque自动丢弃超出长度的旧数据，无需手动截断。
    """

def__init__(self):
super().__init__()
self.title("实时数据监控")
self.geometry("900x520")
self.configure(bg="#1a1a2e")

# 用deque存储滚动数据，maxlen控制窗口大小
self.data_a = collections.deque(maxlen=MAX_POINTS)
self.data_b = collections.deque(maxlen=MAX_POINTS)
self.time_axis = collections.deque(maxlen=MAX_POINTS)
self._tick = 0
self._running = True

self._build_ui()
self._schedule_refresh()

# 窗口关闭时停止刷新
self.protocol("WM_DELETE_WINDOW", self._on_close)

def_build_ui(self):
# 顶部控制栏
        ctrl = tk.Frame(self, bg="#16213e", height=50)
        ctrl.pack(fill="x")
        ctrl.pack_propagate(False)

        tk.Label(ctrl, text="传感器实时数据",
                 font=("微软雅黑", 13, "bold"),
                 bg="#16213e", fg="#e0e0e0").pack(side="left", padx=16, pady=14)

self.status_var = tk.StringVar(value="运行中...")
        tk.Label(ctrl, textvariable=self.status_var,
                 font=("微软雅黑", 9),
                 bg="#16213e", fg="#2ecc71").pack(side="right", padx=16)

# 暂停/继续按钮
self.pause_btn = tk.Button(
            ctrl, text="暂停",
            font=("微软雅黑", 9),
            bg="#e74c3c", fg="white",
            relief="flat", padx=10, pady=4,
            command=self._toggle_pause
        )
self.pause_btn.pack(side="right", padx=8, pady=10)

# 图表区域
        chart_frame = tk.Frame(self, bg="#1a1a2e")
        chart_frame.pack(fill="both", expand=True, padx=12, pady=(8, 12))

self.fig = Figure(figsize=(9, 4.2), dpi=100, facecolor="#1a1a2e")
self.ax = self.fig.add_subplot(111)
self._style_axes()

self.canvas = FigureCanvasTkAgg(self.fig, master=chart_frame)
self.canvas.draw()
self.canvas.get_tk_widget().pack(fill="both", expand=True)

def_style_axes(self):
"""统一设置暗色主题坐标轴样式"""
self.ax.set_facecolor("#0f3460")
self.ax.tick_params(colors="#aaaaaa", labelsize=9)
for spine inself.ax.spines.values():
            spine.set_color("#444444")
self.ax.yaxis.label.set_color("#aaaaaa")
self.ax.xaxis.label.set_color("#aaaaaa")

def_generate_data(self):
"""模拟传感器数据（实际项目替换为串口/网络读取）"""
        base_a = 60 + 20 * abs(self._tick % 20 - 10) / 10
        base_b = 45 + 15 * abs((self._tick + 5) % 20 - 10) / 10
return (
round(base_a + random.uniform(-5, 5), 1),
round(base_b + random.uniform(-3, 3), 1)
        )

def_refresh_chart(self):
"""核心刷新逻辑：更新数据 → 清空旧图 → 重绘"""
        val_a, val_b = self._generate_data()
self.data_a.append(val_a)
self.data_b.append(val_b)
self.time_axis.append(self._tick)
self._tick += 1

# 清空并重绘——比每次创建新Figure开销小得多
self.ax.clear()
self._style_axes()

        t = list(self.time_axis)
self.ax.plot(t, list(self.data_a),
                     color="#3498db", linewidth=1.8,
                     label="传感器A", marker="o",
                     markersize=3, markevery=[-1])
self.ax.plot(t, list(self.data_b),
                     color="#e74c3c", linewidth=1.8,
                     label="传感器B", marker="s",
                     markersize=3, markevery=[-1])

# 最新值标注
ifself.data_a:
self.ax.annotate(
f"{self.data_a[-1]}",
                xy=(t[-1], self.data_a[-1]),
                xytext=(4, 4), textcoords="offset points",
                color="#3498db", fontsize=8
            )
ifself.data_b:
self.ax.annotate(
f"{self.data_b[-1]}",
                xy=(t[-1], self.data_b[-1]),
                xytext=(4, -12), textcoords="offset points",
                color="#e74c3c", fontsize=8
            )

self.ax.set_ylabel("数值", fontsize=9)
self.ax.set_ylim(20, 100)
        legend = self.ax.legend(fontsize=9, loc="upper left",
                                 facecolor="#1a1a2e", edgecolor="#444")
for text in legend.get_texts():
            text.set_color("#cccccc")

self.fig.tight_layout()
self.canvas.draw()

self.status_var.set(
f"运行中... | A={self.data_a[-1] if self.data_a else'--'}  "
f"B={self.data_b[-1] if self.data_b else'--'}"
        )

def_schedule_refresh(self):
"""用after循环驱动刷新，比Thread更安全"""
ifself._running:
self._refresh_chart()
self._after_id = self.after(REFRESH_INTERVAL, self._schedule_refresh)

def_toggle_pause(self):
self._running = notself._running
ifself._running:
self.pause_btn.config(text="暂停", bg="#e74c3c")
self.status_var.set("运行中...")
else:
self.pause_btn.config(text="继续", bg="#2ecc71")
self.status_var.set("已暂停")

def_on_close(self):
"""关闭前取消定时器，避免after回调访问已销毁的组件"""
self.after_cancel(self._after_id)
self.destroy()


if __name__ == "__main__":
    app = RealtimeLineChart()
    app.mainloop()

这里有个设计决策值得说一下：为什么用after()而不是开一个Thread来刷新？

因为Tkinter的UI操作不是线程安全的。在子线程里调用canvas.draw()，轻则图表闪烁，重则触发RuntimeError甚至程序崩溃。after()是在主线程的事件循环里调度回调，天然安全，而且对于秒级刷新的场景，性能完全够用。

另一个细节：_on_close里要先after_cancel再destroy。如果直接关窗口，after的回调可能还在队列里，等主循环处理时发现窗口已经没了，就会抛异常。这个坑很隐蔽，测试阶段不一定复现，但用户那边偶尔会报错。

📈 方案三：多图表联动报表页

实际的报表系统，往往不止一张图。多个图表共享同一份数据源，切换时间范围，所有图表同步更新——这才是真正的报表联动。

# 多图表联动报表
import tkinter as tk
from tkinter import ttk
import matplotlib
matplotlib.use("TkAgg")
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec

plt.rcParams["font.sans-serif"] = ["Microsoft YaHei"]
plt.rcParams["axes.unicode_minus"] = False


# 模拟报表数据源
REPORT_DATA = {
"月度": {
"labels": ["1月", "2月", "3月", "4月", "5月", "6月"],
"revenue": [88, 102, 95, 130, 118, 145],
"cost":    [62,  70, 68,  85,  80,  96],
"category": {"电子": 38, "服装": 27, "食品": 20, "其他": 15},
    },
"季度": {
"labels": ["Q1", "Q2", "Q3", "Q4"],
"revenue": [285, 393, 412, 468],
"cost":    [200, 265, 280, 310],
"category": {"电子": 42, "服装": 25, "食品": 18, "其他": 15},
    },
}


classMultiChartReport(tk.Tk):
"""
    多图表联动报表。
    左上：收入/成本折线对比；右上：利润率柱状图；下方：品类占比饼图。
    切换时间维度时，三张图同步刷新。
    """

def__init__(self):
super().__init__()
self.title("经营分析报表")
self.geometry("1050x680")
self.configure(bg="#f4f6f9")
self.current_period = tk.StringVar(value="月度")
self._build_ui()
self._render_all()

def_build_ui(self):
# 顶部控制栏
        header = tk.Frame(self, bg="#2c3e50", height=52)
        header.pack(fill="x")
        header.pack_propagate(False)

        tk.Label(header, text="经营分析报表",
                 font=("微软雅黑", 15, "bold"),
                 bg="#2c3e50", fg="white").pack(side="left", padx=20, pady=14)

# 时间维度切换
        seg_frame = tk.Frame(header, bg="#2c3e50")
        seg_frame.pack(side="right", padx=16, pady=12)

for period in ["月度", "季度"]:
            rb = tk.Radiobutton(
                seg_frame, text=period,
                variable=self.current_period, value=period,
                font=("微软雅黑", 10),
                bg="#2c3e50", fg="#bdc3c7",
                selectcolor="#3498db",
                activebackground="#2c3e50",
                activeforeground="white",
                command=self._render_all
            )
            rb.pack(side="left", padx=6)

# 导出按钮
        tk.Button(
            header, text="导出图表",
            font=("微软雅黑", 9),
            bg="#27ae60", fg="white",
            relief="flat", padx=10, pady=3,
            command=self._export_chart
        ).pack(side="right", padx=(0, 8), pady=14)

# 图表容器
self.chart_frame = tk.Frame(self, bg="#f4f6f9")
self.chart_frame.pack(fill="both", expand=True, padx=14, pady=10)

# 创建Figure（用GridSpec划分三个子图区域）
self.fig = Figure(figsize=(10.5, 6), dpi=100, facecolor="#f4f6f9")
        gs = gridspec.GridSpec(2, 2, figure=self.fig,
                               hspace=0.38, wspace=0.28)
self.ax_line  = self.fig.add_subplot(gs[0, 0])   # 左上：折线
self.ax_bar   = self.fig.add_subplot(gs[0, 1])   # 右上：柱状
self.ax_pie   = self.fig.add_subplot(gs[1, :])   # 下方：饼图（跨两列）

self.canvas = FigureCanvasTkAgg(self.fig, master=self.chart_frame)
self.canvas.draw()
self.canvas.get_tk_widget().pack(fill="both", expand=True)

def_render_all(self):
"""根据当前选择的时间维度，刷新全部子图"""
        period = self.current_period.get()
        data = REPORT_DATA[period]

for ax in [self.ax_line, self.ax_bar, self.ax_pie]:
            ax.clear()

self._draw_line(data)
self._draw_bar(data)
self._draw_pie(data)

self.fig.tight_layout(pad=2.0)
self.canvas.draw()

def_draw_line(self, data: dict):
"""收入 vs 成本折线对比图"""
        ax = self.ax_line
        labels = data["labels"]
        x = range(len(labels))

        ax.plot(x, data["revenue"], color="#3498db", linewidth=2,
                marker="o", markersize=5, label="收入")
        ax.plot(x, data["cost"], color="#e74c3c", linewidth=2,
                marker="s", markersize=5, label="成本", linestyle="--")

# 填充收入与成本之间的利润区域
        ax.fill_between(x, data["revenue"], data["cost"],
                        alpha=0.12, color="#2ecc71")

        ax.set_xticks(list(x))
        ax.set_xticklabels(labels, fontsize=9)
        ax.set_title("收入 vs 成本", fontsize=10, fontweight="bold", pad=8)
        ax.set_ylabel("金额（万元）", fontsize=9)
        ax.legend(fontsize=9)
        ax.set_facecolor("#fafafa")
        ax.spines["top"].set_visible(False)
        ax.spines["right"].set_visible(False)

def_draw_bar(self, data: dict):
"""利润率柱状图"""
        ax = self.ax_bar
        labels = data["labels"]
        profit_rate = [
round((r - c) / r * 100, 1)
for r, c inzip(data["revenue"], data["cost"])
        ]

        colors = ["#2ecc71"if p >= 25else"#f39c12"if p >= 20else"#e74c3c"
for p in profit_rate]
        bars = ax.bar(labels, profit_rate, color=colors, alpha=0.85, width=0.5)

for bar, val inzip(bars, profit_rate):
            ax.text(bar.get_x() + bar.get_width() / 2,
                    bar.get_height() + 0.5,
f"{val}%", ha="center", va="bottom",
                    fontsize=8.5, color="#333")

        ax.axhline(y=25, color="#2ecc71", linestyle="--",
                   linewidth=1, alpha=0.6, label="目标线 25%")
        ax.set_title("利润率", fontsize=10, fontweight="bold", pad=8)
        ax.set_ylabel("%", fontsize=9)
        ax.set_ylim(0, max(profit_rate) + 8)
        ax.legend(fontsize=8)
        ax.set_facecolor("#fafafa")
        ax.spines["top"].set_visible(False)
        ax.spines["right"].set_visible(False)

def_draw_pie(self, data: dict):
"""品类销售占比饼图"""
        ax = self.ax_pie
        cat = data["category"]
        labels = list(cat.keys())
        sizes  = list(cat.values())
        colors = ["#3498db", "#e74c3c", "#2ecc71", "#f39c12"]
        explode = [0.04] * len(labels)

        wedges, texts, autotexts = ax.pie(
            sizes, labels=labels, colors=colors,
            explode=explode, autopct="%1.1f%%",
            startangle=140, pctdistance=0.82,
            wedgeprops={"linewidth": 1.5, "edgecolor": "white"}
        )
for at in autotexts:
            at.set_fontsize(9)
for t in texts:
            t.set_fontsize(10)

        ax.set_title("品类销售占比", fontsize=10, fontweight="bold", pad=8)

def_export_chart(self):
"""将当前图表导出为PNG文件"""
from tkinter import filedialog
        path = filedialog.asksaveasfilename(
            defaultextension=".png",
            filetypes=[("PNG图片", "*.png"), ("所有文件", "*.*")],
            initialfile=f"报表_{self.current_period.get()}.png"
        )
if path:
self.fig.savefig(path, dpi=150, bbox_inches="tight",
                             facecolor=self.fig.get_facecolor())
            tk.messagebox.showinfo("导出成功", f"图表已保存至：\n{path}")


if __name__ == "__main__":
    app = MultiChartReport()
    app.mainloop()

这套多图表方案里，GridSpec是个很顺手的工具——比add_subplot(行, 列, 编号)的方式灵活得多，可以让某个子图跨越多列（比如这里的饼图用gs[1, :]横跨整行），实现不规则的布局。

导出功能用的是fig.savefig()，注意要传facecolor=self.fig.get_facecolor()，否则导出的图片背景会变成白色，和程序里看到的颜色对不上。

💡 几个绕不开的性能细节

ax.clear()还是重建Figure？ 对于动态刷新场景，ax.clear()加重绘比每次Figure()重建快得多——后者涉及完整的对象初始化，在1秒刷新间隔下感觉不明显，但如果刷新频率提到200ms以下，卡顿就很明显了。

canvas.draw()还是canvas.draw_idle()？draw_idle()会把重绘请求加入Tkinter的事件队列，在队列空闲时才执行，适合高频刷新场景（能自动合并多次重绘请求）；draw()是立即同步执行。秒级刷新用哪个差别不大，但如果你在做100ms以下的高频图表，换成draw_idle()能明显减少CPU占用。

中文字体的另一个坑：tight_layout()有时候会把中文标题裁掉一截，尤其是标题里有汉字的情况。解决方法是给tight_layout加pad参数：fig.tight_layout(pad=2.0)，留出足够的边距。

📦 写在最后

三套方案，覆盖了Tkinter报表图表的三个典型场景：

静态嵌入适合数据固定的展示型报表；动态刷新适合设备监控、数据采集这类需要实时更新的场景；多图表联动则是完整报表系统的标准形态，切换维度、导出图片，该有的都有。

核心思路始终是那一条：Figure管数据和样式，FigureCanvasTkAgg负责渲染，after()驱动刷新循环，三者各司其职。

如果你在实际项目里遇到过图表刷新卡顿、中文乱码、导出颜色偏差这类问题，欢迎在评论区聊聊你的解决思路。

相关技术标签：#Python#Tkinter#Matplotlib#数据可视化#报表开发