2025年Python Tkinter新手入门：环境搭建与基础组件完全指南

# 检查Tkinter是否已安装
import tkinter

# 打印Tkinter版本信息
print(f"Tkinter版本: {tkinter.TkVersion}")
print(f"Tcl/Tk版本: {tkinter.TclVersion}")

python -m tkinter

brew install python

python3 -m tkinter

sudo apt-get update
sudo apt-get install python3-tk

sudo dnf install python3-tkinter

sudo yum install python3-tkinter

python3 -m tkinter

import tkinter as tk

# 创建主窗口
root = tk.Tk()
# 设置窗口标题
root.title("我的第一个Tkinter应用")
# 设置窗口大小
root.geometry("800x600")
# 设置窗口是否可调整大小（width, height）
root.resizable(True, True)
# 设置窗口图标（在Windows系统上有效）
# root.iconbitmap("icon.ico")
# 启动主事件循环
root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("标签示例")
root.geometry("500x300")

# 创建一个文本标签
text_label = tk.Label(root, text="欢迎来到Tkinter世界！", font=("Arial", 16))
text_label.pack(pady=20)

# 创建一个带背景色和前景色的标签
color_label = tk.Label(root, text="彩色标签", bg="blue", fg="white", font=("Arial", 14))
color_label.pack(pady=10)

# 创建一个多行文本标签
multiline_label = tk.Label(root, text="这是一个\n多行文本标签", justify="center", font=("Arial", 12))
multiline_label.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("按钮示例")
root.geometry("500x300")

# 定义按钮点击事件处理函数
def on_button_click():
    label.config(text="按钮被点击了！")

# 创建一个标签用于显示信息
label = tk.Label(root, text="请点击按钮", font=("Arial", 14))
label.pack(pady=20)

# 创建一个普通按钮
button1 = tk.Button(root, text="点击我", command=on_button_click, font=("Arial", 12))
button1.pack(pady=10)

# 创建一个带背景色和前景色的按钮
button2 = tk.Button(root, text="彩色按钮", bg="green", fg="white", font=("Arial", 12))
button2.pack(pady=10)

# 创建一个禁用的按钮
button3 = tk.Button(root, text="禁用按钮", state="disabled", font=("Arial", 12))
button3.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("输入框示例")
root.geometry("500x300")

# 定义获取输入内容的函数
def get_input():
    input_text = entry.get()
    label.config(text=f"你输入的是：{input_text}")

# 定义清除输入内容的函数
def clear_input():
    entry.delete(0, "end")

# 创建一个标签
label = tk.Label(root, text="请输入文本", font=("Arial", 14))
label.pack(pady=20)

# 创建一个输入框
entry = tk.Entry(root, font=("Arial", 12), width=30)
entry.pack(pady=10)

# 创建一个按钮用于获取输入内容
get_button = tk.Button(root, text="获取输入", command=get_input, font=("Arial", 12))
get_button.pack(pady=5)

# 创建一个按钮用于清除输入内容
clear_button = tk.Button(root, text="清除输入", command=clear_input, font=("Arial", 12))
clear_button.pack(pady=5)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("文本框示例")
root.geometry("500x400")

# 定义获取文本框内容的函数
def get_text():
    text_content = text.get("1.0", "end-1c")  # 从第1行第0列到最后一行（不包括末尾的换行符）
    label.config(text=f"文本框内容长度：{len(text_content)}个字符")

# 定义清除文本框内容的函数
def clear_text():
    text.delete("1.0", "end")

# 创建一个标签
label = tk.Label(root, text="请输入多行文本", font=("Arial", 14))
label.pack(pady=10)

# 创建一个文本框，设置宽度、高度和字体
text = tk.Text(root, width=40, height=10, font=("Arial", 12))
text.pack(pady=10)

# 创建一个按钮用于获取文本框内容
get_button = tk.Button(root, text="获取内容", command=get_text, font=("Arial", 12))
get_button.pack(pady=5)

# 创建一个按钮用于清除文本框内容
clear_button = tk.Button(root, text="清除内容", command=clear_text, font=("Arial", 12))
clear_button.pack(pady=5)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("复选框示例")
root.geometry("500x300")

# 创建布尔变量用于存储复选框状态
var1 = tk.BooleanVar()
var2 = tk.BooleanVar()
var3 = tk.BooleanVar()

# 定义显示选中状态的函数
def show_selection():
    selected_items = []
    if var1.get():
        selected_items.append("选项1")
    if var2.get():
        selected_items.append("选项2")
    if var3.get():
        selected_items.append("选项3")
    
    if selected_items:
        label.config(text=f"你选中了：{', '.join(selected_items)}")
    else:
        label.config(text="你没有选中任何选项")

# 创建一个标签
label = tk.Label(root, text="请选择选项", font=("Arial", 14))
label.pack(pady=20)

# 创建复选框
check1 = tk.Checkbutton(root, text="选项1", variable=var1, font=("Arial", 12))
check1.pack(pady=5)

check2 = tk.Checkbutton(root, text="选项2", variable=var2, font=("Arial", 12))
check2.pack(pady=5)

check3 = tk.Checkbutton(root, text="选项3", variable=var3, font=("Arial", 12))
check3.pack(pady=5)

# 创建一个按钮用于显示选中状态
show_button = tk.Button(root, text="显示选中状态", command=show_selection, font=("Arial", 12))
show_button.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("单选按钮示例")
root.geometry("500x300")

# 创建字符串变量用于存储选中的选项
var = tk.StringVar(value="选项1")

# 定义显示选中选项的函数
def show_selection():
    label.config(text=f"你选中了：{var.get()}")

# 创建一个标签
label = tk.Label(root, text="请选择一个选项", font=("Arial", 14))
label.pack(pady=20)

# 创建单选按钮
radio1 = tk.Radiobutton(root, text="选项1", variable=var, value="选项1", font=("Arial", 12))
radio1.pack(pady=5)

radio2 = tk.Radiobutton(root, text="选项2", variable=var, value="选项2", font=("Arial", 12))
radio2.pack(pady=5)

radio3 = tk.Radiobutton(root, text="选项3", variable=var, value="选项3", font=("Arial", 12))
radio3.pack(pady=5)

# 创建一个按钮用于显示选中选项
show_button = tk.Button(root, text="显示选中选项", command=show_selection, font=("Arial", 12))
show_button.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("列表框示例")
root.geometry("500x300")

# 定义显示选中项的函数
def show_selection():
    selected_indices = listbox.curselection()
    if selected_indices:
        selected_items = [listbox.get(i) for i in selected_indices]
        label.config(text=f"你选中了：{', '.join(selected_items)}")
    else:
        label.config(text="你没有选中任何选项")

# 创建一个标签
label = tk.Label(root, text="请选择选项", font=("Arial", 14))
label.pack(pady=10)

# 创建一个列表框，设置宽度和高度
listbox = tk.Listbox(root, width=30, height=5, font=("Arial", 12), selectmode="multiple")  # selectmode可以是"single"（单选）或"multiple"（多选）
listbox.pack(pady=10)

# 向列表框中添加选项
options = ["选项1", "选项2", "选项3", "选项4", "选项5"]
for option in options:
    listbox.insert("end", option)

# 创建一个按钮用于显示选中项
show_button = tk.Button(root, text="显示选中项", command=show_selection, font=("Arial", 12))
show_button.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("下拉菜单示例")
root.geometry("500x300")

# 创建字符串变量用于存储选中的选项
var = tk.StringVar(value="选项1")

# 定义显示选中选项的函数
def show_selection(*args):
    label.config(text=f"你选中了：{var.get()}")

# 绑定变量变化事件
var.trace("w", show_selection)

# 创建一个标签
label = tk.Label(root, text="请选择一个选项", font=("Arial", 14))
label.pack(pady=20)

# 创建下拉菜单
options = ["选项1", "选项2", "选项3", "选项4", "选项5"]
option_menu = tk.OptionMenu(root, var, *options)
option_menu.config(font=("Arial", 12), width=20)
option_menu.pack(pady=10)

# 创建一个标签用于显示选中的选项
result_label = tk.Label(root, text="", font=("Arial", 12))
result_label.pack(pady=20)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("滑块示例")
root.geometry("500x300")

# 定义显示滑块值的函数
def show_value(value):
    label.config(text=f"滑块值：{value}")

# 创建一个标签
label = tk.Label(root, text="请拖动滑块", font=("Arial", 14))
label.pack(pady=20)

# 创建水平滑块
horizontal_scale = tk.Scale(root, from_=0, to=100, orient="horizontal", length=300, command=show_value, font=("Arial", 12))
horizontal_scale.pack(pady=10)

# 创建垂直滑块
vertical_scale = tk.Scale(root, from_=0, to=100, orient="vertical", length=200, command=show_value, font=("Arial", 12))
vertical_scale.pack(side="right", padx=20)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("消息框示例")
root.geometry("500x300")

# 创建一个消息框，设置宽度和字体
message = tk.Message(root, text="这是一个消息框组件，它可以显示多行文本，当文本长度超过设置的宽度时会自动换行。消息框与标签类似，但更适合显示较长的文本内容。", width=400, font=("Arial", 12))
message.pack(pady=20)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("画布示例")
root.geometry("600x400")

# 创建一个画布，设置宽度、高度和背景色
canvas = tk.Canvas(root, width=500, height=300, bg="white")
canvas.pack(pady=20)

# 在画布上绘制图形
# 绘制矩形（x1, y1, x2, y2）
canvas.create_rectangle(50, 50, 200, 150, fill="blue", outline="black", width=2)

# 绘制椭圆（x1, y1, x2, y2）
canvas.create_oval(250, 50, 400, 150, fill="red", outline="black", width=2)

# 绘制线段（x1, y1, x2, y2）
canvas.create_line(50, 200, 450, 200, fill="green", width=3)

# 绘制多边形（点的坐标序列）
canvas.create_polygon(100, 250, 250, 180, 400, 250, fill="yellow", outline="black", width=2)

# 在画布上添加文本
canvas.create_text(250, 100, text="Tkinter画布示例", font=("Arial", 16), fill="purple")

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("框架示例")
root.geometry("600x400")

# 创建一个顶部框架
top_frame = tk.Frame(root, bg="lightblue", padx=10, pady=10)
top_frame.pack(fill="x", padx=20, pady=10)

# 在顶部框架中添加标签
top_label = tk.Label(top_frame, text="这是顶部框架", font=("Arial", 14), bg="lightblue")
top_label.pack()

# 创建一个左侧框架
left_frame = tk.Frame(root, bg="lightgreen", width=200, height=200, padx=10, pady=10)
left_frame.pack(side="left", fill="y", padx=20, pady=10)

# 在左侧框架中添加按钮
left_button = tk.Button(left_frame, text="左侧按钮", font=("Arial", 12))
left_button.pack(pady=20)

# 创建一个右侧框架
right_frame = tk.Frame(root, bg="lightyellow", width=300, height=200, padx=10, pady=10)
right_frame.pack(side="right", fill="both", expand=True, padx=20, pady=10)

# 在右侧框架中添加标签和输入框
right_label = tk.Label(right_frame, text="请输入文本：", font=("Arial", 12), bg="lightyellow")
right_label.pack(pady=10)

right_entry = tk.Entry(right_frame, font=("Arial", 12), width=20)
right_entry.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("滚动条示例")
root.geometry("500x400")

# 创建一个文本框
text = tk.Text(root, width=40, height=10, font=("Arial", 12))
text.pack(side="left", fill="both", expand=True, padx=20, pady=20)

# 创建一个垂直滚动条，并与文本框关联
scrollbar = tk.Scrollbar(root, command=text.yview)
scrollbar.pack(side="right", fill="y", pady=20)

# 将文本框与滚动条关联
text.config(yscrollcommand=scrollbar.set)

# 向文本框中添加大量文本
for i in range(100):
    text.insert("end", f"这是第{i+1}行文本\n")

root.mainloop()

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("分隔符示例")
root.geometry("500x300")

# 创建一个标签
label1 = tk.Label(root, text="上方区域", font=("Arial", 14))
label1.pack(pady=20)

# 创建一个水平分隔符
horizontal_separator = ttk.Separator(root, orient="horizontal")
horizontal_separator.pack(fill="x", padx=20, pady=10)

# 创建另一个标签
label2 = tk.Label(root, text="下方区域", font=("Arial", 14))
label2.pack(pady=20)

# 创建一个框架用于演示垂直分隔符
split_frame = tk.Frame(root, width=400, height=100)
split_frame.pack(pady=20)
split_frame.pack_propagate(False)  # 防止框架大小被内部组件改变

# 创建左侧标签
left_label = tk.Label(split_frame, text="左侧", font=("Arial", 12))
left_label.pack(side="left", fill="both", expand=True, padx=10, pady=10)

# 创建一个垂直分隔符
vertical_separator = ttk.Separator(split_frame, orient="vertical")
vertical_separator.pack(side="left", fill="y", pady=10)

# 创建右侧标签
right_label = tk.Label(split_frame, text="右侧", font=("Arial", 12))
right_label.pack(side="left", fill="both", expand=True, padx=10, pady=10)

root.mainloop()

import tkinter as tk
from tkinter import colorchooser

root = tk.Tk()
root.title("颜色选择器示例")
root.geometry("500x300")

# 定义打开颜色选择器的函数
def choose_color():
    # 打开颜色选择器对话框，返回选中的颜色和RGB值
    color_code = colorchooser.askcolor(title="选择颜色")
    if color_code[1]:  # 确保用户没有点击取消按钮
        # 更新标签的背景色和文本
        color_label.config(bg=color_code[1], text=f"选中的颜色: {color_code[1]}")

# 创建一个按钮用于打开颜色选择器
color_button = tk.Button(root, text="选择颜色", command=choose_color, font=("Arial", 12))
color_button.pack(pady=20)

# 创建一个标签用于显示选中的颜色
color_label = tk.Label(root, text="请选择一个颜色", font=("Arial", 14), width=30, height=5)
color_label.pack(pady=20)

root.mainloop()

import tkinter as tk
from tkinter import filedialog

root = tk.Tk()
root.title("文件对话框示例")
root.geometry("600x400")

# 定义打开文件对话框的函数
def open_file():
    # 打开文件选择对话框
    file_path = filedialog.askopenfilename(
        title="选择文件",
        filetypes=[("文本文件", "*.txt"), ("Python文件", "*.py"), ("所有文件", "*.*")]
    )
    if file_path:  # 确保用户没有点击取消按钮
        # 更新标签的文本
        file_label.config(text=f"选中的文件: {file_path}")

# 定义保存文件对话框的函数
def save_file():
    # 打开保存文件对话框
    file_path = filedialog.asksaveasfilename(
        title="保存文件",
        defaultextension=".txt",
        filetypes=[("文本文件", "*.txt"), ("Python文件", "*.py"), ("所有文件", "*.*")]
    )
    if file_path:  # 确保用户没有点击取消按钮
        # 更新标签的文本
        file_label.config(text=f"保存的文件: {file_path}")

# 定义选择目录对话框的函数
def select_directory():
    # 打开目录选择对话框
    dir_path = filedialog.askdirectory(title="选择目录")
    if dir_path:  # 确保用户没有点击取消按钮
        # 更新标签的文本
        file_label.config(text=f"选中的目录: {dir_path}")

# 创建按钮
open_button = tk.Button(root, text="打开文件", command=open_file, font=("Arial", 12))
open_button.pack(pady=10)

save_button = tk.Button(root, text="保存文件", command=save_file, font=("Arial", 12))
save_button.pack(pady=10)

dir_button = tk.Button(root, text="选择目录", command=select_directory, font=("Arial", 12))
dir_button.pack(pady=10)

# 创建一个标签用于显示选中的文件或目录
file_label = tk.Label(root, text="请选择文件或目录", font=("Arial", 12), wraplength=500)
file_label.pack(pady=20)

root.mainloop()

import tkinter as tk
from tkinter import simpledialog

root = tk.Tk()
root.title("简单对话框示例")
root.geometry("500x300")

# 定义打开输入对话框的函数
def open_input_dialog():
    # 打开输入对话框
    user_input = simpledialog.askstring("输入框", "请输入您的姓名：", parent=root)
    if user_input:  # 确保用户没有点击取消按钮
        # 更新标签的文本
        dialog_label.config(text=f"您的姓名: {user_input}")

# 定义打开整数输入对话框的函数
def open_integer_dialog():
    # 打开整数输入对话框
    user_input = simpledialog.askinteger("整数输入框", "请输入您的年龄：", parent=root, minvalue=0, maxvalue=120)
    if user_input is not None:  # 确保用户没有点击取消按钮
        # 更新标签的文本
        dialog_label.config(text=f"您的年龄: {user_input}")

# 定义打开浮点数输入对话框的函数
def open_float_dialog():
    # 打开浮点数输入对话框
    user_input = simpledialog.askfloat("浮点数输入框", "请输入您的身高（米）：", parent=root, minvalue=0.5, maxvalue=2.5)
    if user_input is not None:  # 确保用户没有点击取消按钮
        # 更新标签的文本
        dialog_label.config(text=f"您的身高: {user_input}米")

# 创建按钮
input_button = tk.Button(root, text="打开输入对话框", command=open_input_dialog, font=("Arial", 12))
input_button.pack(pady=10)

integer_button = tk.Button(root, text="打开整数输入对话框", command=open_integer_dialog, font=("Arial", 12))
integer_button.pack(pady=10)

float_button = tk.Button(root, text="打开浮点数输入对话框", command=open_float_dialog, font=("Arial", 12))
float_button.pack(pady=10)

# 创建一个标签用于显示对话框的结果
dialog_label = tk.Label(root, text="请点击按钮打开对话框", font=("Arial", 14))
dialog_label.pack(pady=20)

root.mainloop()

import tkinter as tk
from tkinter import messagebox

root = tk.Tk()
root.title("消息对话框示例")
root.geometry("500x300")

# 定义显示信息对话框的函数
def show_info():
    messagebox.showinfo("信息", "这是一个信息对话框")

# 定义显示警告对话框的函数
def show_warning():
    messagebox.showwarning("警告", "这是一个警告对话框")

# 定义显示错误对话框的函数
def show_error():
    messagebox.showerror("错误", "这是一个错误对话框")

# 定义显示询问对话框的函数
def show_question():
    result = messagebox.askquestion("询问", "你确定要继续吗？")
    if result == "yes":
        result_label.config(text="你选择了：是")
    else:
        result_label.config(text="你选择了：否")

# 定义显示确认对话框的函数
def show_ok_cancel():
    result = messagebox.askokcancel("确认", "你确定要执行此操作吗？")
    if result:
        result_label.config(text="你选择了：确定")
    else:
        result_label.config(text="你选择了：取消")

# 定义显示重试取消对话框的函数
def show_retry_cancel():
    result = messagebox.askretrycancel("重试", "操作失败，是否重试？")
    if result:
        result_label.config(text="你选择了：重试")
    else:
        result_label.config(text="你选择了：取消")

# 定义显示是/否/取消对话框的函数
def show_yes_no_cancel():
    result = messagebox.askyesnocancel("选择", "请选择一个选项：")
    if result is None:
        result_label.config(text="你选择了：取消")
    elif result:
        result_label.config(text="你选择了：是")
    else:
        result_label.config(text="你选择了：否")

# 创建按钮
info_button = tk.Button(root, text="显示信息对话框", command=show_info, font=("Arial", 10))
info_button.pack(pady=5)

warning_button = tk.Button(root, text="显示警告对话框", command=show_warning, font=("Arial", 10))
warning_button.pack(pady=5)

error_button = tk.Button(root, text="显示错误对话框", command=show_error, font=("Arial", 10))
error_button.pack(pady=5)

question_button = tk.Button(root, text="显示询问对话框", command=show_question, font=("Arial", 10))
question_button.pack(pady=5)

ok_cancel_button = tk.Button(root, text="显示确认对话框", command=show_ok_cancel, font=("Arial", 10))
ok_cancel_button.pack(pady=5)

retry_cancel_button = tk.Button(root, text="显示重试取消对话框", command=show_retry_cancel, font=("Arial", 10))
retry_cancel_button.pack(pady=5)

yes_no_cancel_button = tk.Button(root, text="显示是/否/取消对话框", command=show_yes_no_cancel, font=("Arial", 10))
yes_no_cancel_button.pack(pady=5)

# 创建一个标签用于显示对话框的结果
result_label = tk.Label(root, text="请点击按钮打开对话框", font=("Arial", 14))
result_label.pack(pady=20)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("控件属性示例")
root.geometry("600x500")

# 创建一个带有各种属性的标签
label = tk.Label(
    root,
    text="这是一个带有多种属性的标签",
    font=("Arial", 16, "bold italic"),  # 字体：Arial，大小16，粗体斜体
    bg="lightblue",  # 背景色：浅蓝色
    fg="darkblue",  # 前景色（文本颜色）：深蓝色
    width=30,  # 宽度
    height=3,  # 高度
    padx=20,  # 水平内边距
    pady=10,  # 垂直内边距
    bd=5,  # 边框宽度
    relief="solid",  # 边框样式：实线
    cursor="hand2",  # 光标样式：手形
    justify="center",  # 文本对齐方式：居中
    anchor="center"  # 内容锚点：居中
)
label.pack(pady=20)

# 创建一个带有各种属性的按钮
button = tk.Button(
    root,
    text="这是一个按钮",
    font=("Arial", 14),  # 字体：Arial，大小14
    bg="green",  # 背景色：绿色
    fg="white",  # 前景色（文本颜色）：白色
    width=20,  # 宽度
    height=2,  # 高度
    padx=10,  # 水平内边距
    pady=5,  # 垂直内边距
    bd=3,  # 边框宽度
    relief="raised",  # 边框样式：凸起
    cursor="plus",  # 光标样式：加号
)
button.pack(pady=10)

# 创建一个禁用的按钮
disabled_button = tk.Button(
    root,
    text="这是一个禁用的按钮",
    font=("Arial", 14),
    state="disabled"  # 状态：禁用
)
disabled_button.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Entry控件特定属性示例")
root.geometry("500x300")

# 创建一个普通的输入框
normal_entry = tk.Entry(
    root,
    font=("Arial", 12),
    width=30
)
normal_entry.pack(pady=10)

# 创建一个密码输入框
password_entry = tk.Entry(
    root,
    font=("Arial", 12),
    width=30,
    show="*"  # 设置显示为星号
)
password_entry.pack(pady=10)

# 创建一个带有自定义光标和选中样式的输入框
custom_entry = tk.Entry(
    root,
    font=("Arial", 12),
    width=30,
    insertbackground="red",  # 光标颜色：红色
    insertwidth=3,  # 光标宽度
    selectbackground="yellow",  # 选中背景色：黄色
    selectforeground="black"  # 选中前景色：黑色
)
custom_entry.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Text控件特定属性示例")
root.geometry("500x400")

# 创建一个带有自定义属性的文本框
text = tk.Text(
    root,
    width=40,
    height=10,
    font=("Arial", 12),
    wrap="word",  # 单词级换行
    undo=True,  # 启用撤销功能
    maxundo=100,  # 最大撤销次数：100
    spacing1=5,  # 第一行垂直间距
    spacing2=2,  # 其他行垂直间距
    spacing3=8  # 文本块之间垂直间距
)
text.pack(pady=20)

# 向文本框中插入一些文本
text.insert("end", "这是第一行文本\n")
text.insert("end", "这是第二行包含一个很长很长很长很长很长很长很长很长很长很长很长很长的单词\n")
text.insert("end", "这是第三行文本\n")

# 创建一个按钮用于演示撤销功能
def undo():
    try:
        text.edit_undo()
    except tk.TclError:
        pass

def redo():
    try:
        text.edit_redo()
    except tk.TclError:
        pass

undo_button = tk.Button(root, text="撤销", command=undo, font=("Arial", 12))
undo_button.pack(side="left", padx=20, pady=10)

redo_button = tk.Button(root, text="重做", command=redo, font=("Arial", 12))
redo_button.pack(side="right", padx=20, pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Listbox控件特定属性示例")
root.geometry("500x400")

# 创建一个带有水平滚动条的框架
frame = tk.Frame(root)
frame.pack(pady=20, fill="both", expand=True)

# 创建一个水平滚动条
scrollbar = tk.Scrollbar(frame, orient="horizontal")
scrollbar.pack(side="bottom", fill="x")

# 创建一个列表框，设置选择模式为扩展模式
listbox = tk.Listbox(
    frame,
    width=40,
    height=10,
    font=("Arial", 12),
    selectmode="extended",  # 扩展选择模式
    xscrollcommand=scrollbar.set  # 关联水平滚动条
)
listbox.pack(side="left", fill="both", expand=True)

# 配置滚动条
scrollbar.config(command=listbox.xview)

# 向列表框中添加选项
for i in range(20):
    listbox.insert("end", f"这是一个很长很长很长很长很长很长的选项 {i+1}")

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Scale控件特定属性示例")
root.geometry("500x400")

# 定义显示滑块值的函数
def show_value(value):
    label.config(text=f"滑块值：{value}")

# 创建一个标签
label = tk.Label(root, text="请拖动滑块", font=("Arial", 14))
label.pack(pady=20)

# 创建一个带有自定义属性的水平滑块
horizontal_scale = tk.Scale(
    root,
    from_=0,  # 最小值
    to=100,  # 最大值
    orient="horizontal",  # 水平方向
    length=400,  # 长度
    resolution=5,  # 分辨率（步长）
    tickinterval=20,  # 刻度间隔
    sliderlength=30,  # 滑块长度
    command=show_value,
    font=("Arial", 12)
)
horizontal_scale.pack(pady=20)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("Canvas控件特定属性示例")
root.geometry("600x500")

# 创建一个框架，用于放置画布和滚动条
frame = tk.Frame(root)
frame.pack(fill="both", expand=True, padx=20, pady=20)

# 创建一个垂直滚动条
vscrollbar = tk.Scrollbar(frame, orient="vertical")
vscrollbar.pack(side="right", fill="y")

# 创建一个水平滚动条
hscrollbar = tk.Scrollbar(frame, orient="horizontal")
hscrollbar.pack(side="bottom", fill="x")

# 创建一个画布，设置背景色和可滚动区域
canvas = tk.Canvas(
    frame,
    width=500,
    height=400,
    bg="white",
    cursor="crosshair",
    scrollregion=(0, 0, 1000, 800),  # 设置可滚动区域（x1, y1, x2, y2）
    yscrollcommand=vscrollbar.set,
    xscrollcommand=hscrollbar.set
)
canvas.pack(side="left", fill="both", expand=True)

# 配置滚动条
vscrollbar.config(command=canvas.yview)
hscrollbar.config(command=canvas.xview)

# 在画布上绘制一些图形
# 绘制一个大矩形
canvas.create_rectangle(50, 50, 950, 750, outline="black", width=2)

# 绘制一些小矩形
for i in range(10):
    for j in range(8):
        x1 = 100 + i * 80
        y1 = 100 + j * 70
        x2 = x1 + 60
        y2 = y1 + 50
        canvas.create_rectangle(x1, y1, x2, y2, fill=f"#{i*20:02x}{j*30:02x}ff", outline="black")

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("事件绑定示例")
root.geometry("500x300")

# 定义鼠标点击事件处理函数
def on_mouse_click(event):
    label.config(text=f"鼠标点击位置：({event.x}, {event.y})")

# 定义键盘按键事件处理函数
def on_key_press(event):
    label.config(text=f"按下的键：{event.char}")

# 定义鼠标移动事件处理函数
def on_mouse_move(event):
    position_label.config(text=f"鼠标位置：({event.x}, {event.y})")

# 创建一个标签用于显示事件信息
label = tk.Label(root, text="请点击窗口或按下键盘按键", font=("Arial", 14))
label.pack(pady=20)

# 创建一个标签用于显示鼠标位置
position_label = tk.Label(root, text="鼠标位置：(0, 0)", font=("Arial", 12))
position_label.pack(pady=10)

# 绑定鼠标点击事件
root.bind("<Button-1>", on_mouse_click)  # <Button-1>表示鼠标左键点击

# 绑定键盘按键事件
root.bind("<Key>", on_key_press)

# 绑定鼠标移动事件
root.bind("<Motion>", on_mouse_move)

# 让窗口获得焦点，以便能够捕获键盘事件
root.focus_set()

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("鼠标事件示例")
root.geometry("500x400")

# 创建一个画布用于演示鼠标事件
canvas = tk.Canvas(root, width=400, height=300, bg="white")
canvas.pack(pady=20)

# 创建一个标签用于显示事件信息
label = tk.Label(root, text="请在画布上进行鼠标操作", font=("Arial", 14))
label.pack(pady=10)

# 定义鼠标点击事件处理函数
def on_click(event):
    label.config(text=f"鼠标点击：位置=({event.x}, {event.y}), 按钮={event.num}")

# 定义鼠标双击事件处理函数
def on_double_click(event):
    label.config(text=f"鼠标双击：位置=({event.x}, {event.y})")
    # 在双击位置绘制一个圆形
    canvas.create_oval(event.x-10, event.y-10, event.x+10, event.y+10, fill="red")

# 定义鼠标释放事件处理函数
def on_release(event):
    label.config(text=f"鼠标释放：位置=({event.x}, {event.y}), 按钮={event.num}")

# 定义鼠标移动事件处理函数
def on_motion(event):
    position_label.config(text=f"鼠标位置：({event.x}, {event.y})")

# 定义按住鼠标左键移动事件处理函数
def on_drag(event):
    # 在移动路径上绘制线段
    canvas.create_line(event.x-2, event.y-2, event.x+2, event.y+2, fill="blue", width=2)

# 定义鼠标进入事件处理函数
def on_enter(event):
    label.config(text="鼠标进入画布")
    canvas.config(bg="lightyellow")

# 定义鼠标离开事件处理函数
def on_leave(event):
    label.config(text="鼠标离开画布")
    canvas.config(bg="white")

# 定义鼠标滚轮事件处理函数
def on_mousewheel(event):
    # 在Windows上，event.delta表示滚轮滚动的距离，正数表示向上滚动，负数表示向下滚动
    # 在macOS上，需要使用其他方式处理
    if event.delta > 0:
        label.config(text="鼠标滚轮向上滚动")
    else:
        label.config(text="鼠标滚轮向下滚动")

# 创建一个标签用于显示鼠标位置
position_label = tk.Label(root, text="鼠标位置：(0, 0)", font=("Arial", 12))
position_label.pack(pady=5)

# 绑定鼠标事件
canvas.bind("<Button-1>", on_click)  # 鼠标左键点击
canvas.bind("<Button-2>", on_click)  # 鼠标中键点击
canvas.bind("<Button-3>", on_click)  # 鼠标右键点击
canvas.bind("<Double-Button-1>", on_double_click)  # 鼠标左键双击
canvas.bind("<ButtonRelease-1>", on_release)  # 鼠标左键释放
canvas.bind("<Motion>", on_motion)  # 鼠标移动
canvas.bind("<B1-Motion>", on_drag)  # 按住鼠标左键移动
canvas.bind("<Enter>", on_enter)  # 鼠标进入
canvas.bind("<Leave>", on_leave)  # 鼠标离开
canvas.bind("<MouseWheel>", on_mousewheel)  # 鼠标滚轮（Windows）

# 对于Linux系统，使用不同的事件绑定鼠标滚轮
# canvas.bind("<Button-4>", on_mousewheel)  # 鼠标滚轮向上（Linux）
# canvas.bind("<Button-5>", on_mousewheel)  # 鼠标滚轮向下（Linux）

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("键盘事件示例")
root.geometry("500x300")

# 创建一个标签用于显示事件信息
label = tk.Label(root, text="请按下键盘按键", font=("Arial", 14))
label.pack(pady=20)

# 创建一个文本框用于输入
entry = tk.Entry(root, font=("Arial", 12), width=30)
entry.pack(pady=10)

# 定义键盘按键事件处理函数
def on_key_press(event):
    # event.char表示按下的字符，event.keysym表示按下的键名
    label.config(text=f"按下的键：字符='{event.char}', 键名='{event.keysym}', 键码={event.keycode}")

# 定义键盘释放事件处理函数
def on_key_release(event):
    # 这里我们只是简单地打印信息，可以根据需要进行其他操作
    pass

# 定义回车键事件处理函数
def on_return(event):
    label.config(text=f"你输入的是：{entry.get()}")

# 定义ESC键事件处理函数
def on_escape(event):
    entry.delete(0, "end")
    label.config(text="输入框已清空")

# 定义方向键事件处理函数
def on_arrow_key(event):
    if event.keysym == "Up":
        label.config(text="你按下了上方向键")
    elif event.keysym == "Down":
        label.config(text="你按下了下方向键")
    elif event.keysym == "Left":
        label.config(text="你按下了左方向键")
    elif event.keysym == "Right":
        label.config(text="你按下了右方向键")

# 定义组合键事件处理函数
def on_control_s(event):
    label.config(text="你按下了Ctrl+S组合键")
    # 在这里可以添加保存操作的代码
    return "break"  # 阻止事件继续传播

# 让窗口获得焦点，以便能够捕获键盘事件
root.focus_set()

# 绑定键盘事件
root.bind("<KeyPress>", on_key_press)  # 按下任意键
root.bind("<KeyRelease>", on_key_release)  # 释放任意键
entry.bind("<Return>", on_return)  # 回车键
root.bind("<Escape>", on_escape)  # ESC键
root.bind("<Up>", on_arrow_key)  # 上方向键
root.bind("<Down>", on_arrow_key)  # 下方向键
root.bind("<Left>", on_arrow_key)  # 左方向键
root.bind("<Right>", on_arrow_key)  # 右方向键
root.bind("<Control-s>", on_control_s)  # Ctrl+S组合键

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("窗口事件示例")
root.geometry("500x300")

# 创建一个标签用于显示事件信息
label = tk.Label(root, text="尝试调整窗口大小或位置", font=("Arial", 14))
label.pack(pady=20)

# 创建一个标签用于显示窗口大小和位置
size_label = tk.Label(root, text="窗口大小：500x300", font=("Arial", 12))
size_label.pack(pady=10)

# 定义窗口配置事件处理函数
def on_configure(event):
    # event.width和event.height表示窗口的新宽度和高度
    size_label.config(text=f"窗口大小：{event.width}x{event.height}")

# 定义窗口销毁事件处理函数
def on_destroy():
    print("窗口即将被销毁")
    # 在这里可以添加清理操作的代码

# 绑定窗口配置事件
root.bind("<Configure>", on_configure)

# 绑定窗口销毁事件
root.protocol("WM_DELETE_WINDOW", on_destroy)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("事件对象示例")
root.geometry("500x300")

# 创建一个文本框，用于显示事件对象的详细信息
text = tk.Text(root, width=50, height=10, font=("Arial", 10))
text.pack(pady=20)

# 定义鼠标点击事件处理函数
def on_mouse_click(event):
    # 清空文本框
    text.delete("1.0", "end")
    # 显示事件对象的属性
    text.insert("end", "鼠标点击事件对象属性：\n")
    text.insert("end", f"x坐标: {event.x}\n")
    text.insert("end", f"y坐标: {event.y}\n")
    text.insert("end", f"按钮编号: {event.num}\n")
    text.insert("end", f"控件: {event.widget}\n")
    text.insert("end", f"类型: {event.type}\n")

# 定义键盘按键事件处理函数
def on_key_press(event):
    # 清空文本框
    text.delete("1.0", "end")
    # 显示事件对象的属性
    text.insert("end", "键盘按键事件对象属性：\n")
    text.insert("end", f"字符: '{event.char}'\n")
    text.insert("end", f"键名: {event.keysym}\n")
    text.insert("end", f"键码: {event.keycode}\n")
    text.insert("end", f"控件: {event.widget}\n")
    text.insert("end", f"类型: {event.type}\n")

# 创建一个按钮
button = tk.Button(root, text="点击我", font=("Arial", 12))
button.pack(pady=10)

# 绑定事件
root.bind("<Button-1>", on_mouse_click)  # 绑定窗口的鼠标点击事件
button.bind("<Button-1>", on_mouse_click)  # 绑定按钮的鼠标点击事件
root.bind("<Key>", on_key_press)  # 绑定键盘按键事件

# 让窗口获得焦点
root.focus_set()

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("事件传播示例")
root.geometry("500x300")

# 创建一个框架
frame = tk.Frame(root, width=300, height=200, bg="lightblue")
frame.pack(pady=50)
frame.pack_propagate(False)  # 防止框架大小被内部组件改变

# 创建一个按钮
button = tk.Button(frame, text="点击我", font=("Arial", 12))
button.place(relx=0.5, rely=0.5, anchor="center")

# 定义按钮的点击事件处理函数
def on_button_click(event):
    label.config(text="按钮被点击了！")
    # 返回"break"阻止事件继续传播
    # 如果注释掉下面这行，你会看到框架的点击事件也会被触发
    # return "break"

# 定义框架的点击事件处理函数
def on_frame_click(event):
    label.config(text="框架被点击了！")

# 定义窗口的点击事件处理函数
def on_root_click(event):
    label.config(text="窗口被点击了！")

# 创建一个标签用于显示信息
label = tk.Label(root, text="请点击按钮、框架或窗口", font=("Arial", 14))
label.pack(pady=10)

# 绑定事件
button.bind("<Button-1>", on_button_click)
frame.bind("<Button-1>", on_frame_click)
root.bind("<Button-1>", on_root_click)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("虚拟事件示例")
root.geometry("500x300")

# 定义虚拟事件处理函数
def on_custom_event(event):
    label.config(text=f"接收到虚拟事件：{event.widget.name}")

# 创建两个框架，分别表示"红灯"和"绿灯"
red_frame = tk.Frame(root, width=100, height=100, bg="red")
red_frame.name = "红灯"
red_frame.pack(side="left", padx=50, pady=50)

# 绑定自定义虚拟事件到框架
root.bind("<<TrafficLightChange>>", on_custom_event)

# 定义按钮点击事件处理函数
def on_button_click():
    # 生成虚拟事件
    root.event_generate("<<TrafficLightChange>>", widget=red_frame)

# 创建一个标签用于显示信息
label = tk.Label(root, text="点击按钮触发虚拟事件", font=("Arial", 14))
label.pack(pady=10)

# 创建一个按钮
button = tk.Button(root, text="触发事件", command=on_button_click, font=("Arial", 12))
button.pack(pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("事件回调函数示例")
root.geometry("500x300")

# 定义回调函数
def on_button_click():
    label.config(text="按钮被点击了！")

# 创建一个标签用于显示信息
label = tk.Label(root, text="请点击按钮", font=("Arial", 14))
label.pack(pady=20)

# 创建一个按钮，设置command属性为回调函数
button = tk.Button(root, text="点击我", command=on_button_click, font=("Arial", 12))
button.pack(pady=10)

root.mainloop()

import tkinter as tk
from functools import partial

root = tk.Tk()
root.title("带参数的回调函数示例")
root.geometry("500x300")

# 定义带参数的回调函数
def on_button_click(button_id):
    label.config(text=f"按钮{button_id}被点击了！")

# 创建一个标签用于显示信息
label = tk.Label(root, text="请点击按钮", font=("Arial", 14))
label.pack(pady=20)

# 使用lambda表达式传递参数
button1 = tk.Button(root, text="按钮1", command=lambda: on_button_click(1), font=("Arial", 12))
button1.pack(pady=5)

# 使用functools.partial传递参数
button2 = tk.Button(root, text="按钮2", command=partial(on_button_click, 2), font=("Arial", 12))
button2.pack(pady=5)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("pack布局管理器示例")
root.geometry("500x400")

# 创建一个顶部标签
header_label = tk.Label(root, text="这是顶部标签", font=("Arial", 16), bg="lightblue", width=30)
header_label.pack(side="top", pady=10)

# 创建一个框架，用于放置左侧和右侧的按钮
content_frame = tk.Frame(root, bg="white", width=400, height=300)
content_frame.pack(fill="both", expand=True, padx=20, pady=10)
content_frame.pack_propagate(False)  # 防止框架大小被内部组件改变

# 创建左侧按钮
left_button = tk.Button(content_frame, text="左侧按钮", font=("Arial", 12), width=15)
left_button.pack(side="left", padx=20, pady=20, fill="y")

# 创建右侧按钮
right_button = tk.Button(content_frame, text="右侧按钮", font=("Arial", 12), width=15)
right_button.pack(side="right", padx=20, pady=20, fill="y")

# 创建中间按钮
center_button = tk.Button(content_frame, text="中间按钮", font=("Arial", 12), width=15)
center_button.pack(side="top", pady=100, expand=True)  # expand=True表示扩展以填充额外的空间

# 创建一个底部标签
footer_label = tk.Label(root, text="这是底部标签", font=("Arial", 16), bg="lightgreen", width=30)
footer_label.pack(side="bottom", pady=10)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("grid布局管理器示例")
root.geometry("500x400")

# 创建标签和输入框，用于构建一个简单的表单
name_label = tk.Label(root, text="姓名：", font=("Arial", 12))
name_label.grid(row=0, column=0, padx=10, pady=10, sticky="e")

name_entry = tk.Entry(root, font=("Arial", 12), width=20)
name_entry.grid(row=0, column=1, padx=10, pady=10)

age_label = tk.Label(root, text="年龄：", font=("Arial", 12))
age_label.grid(row=1, column=0, padx=10, pady=10, sticky="e")

age_entry = tk.Entry(root, font=("Arial", 12), width=20)
age_entry.grid(row=1, column=1, padx=10, pady=10)

email_label = tk.Label(root, text="邮箱：", font=("Arial", 12))
email_label.grid(row=2, column=0, padx=10, pady=10, sticky="e")

email_entry = tk.Entry(root, font=("Arial", 12), width=20)
email_entry.grid(row=2, column=1, padx=10, pady=10)

# 创建一个跨越两列的文本框
comment_label = tk.Label(root, text="留言：", font=("Arial", 12))
comment_label.grid(row=3, column=0, padx=10, pady=10, sticky="ne")

comment_text = tk.Text(root, font=("Arial", 12), width=30, height=5)
comment_text.grid(row=3, column=1, padx=10, pady=10)

# 创建按钮，跨越两列
submit_button = tk.Button(root, text="提交", font=("Arial", 12), width=15)
submit_button.grid(row=4, column=0, columnspan=2, pady=20)  # columnspan=2表示跨越两列

# 配置行和列的权重，使它们能够在窗口大小改变时相应地扩展或收缩
root.grid_rowconfigure(3, weight=1)  # 设置第3行的权重为1
root.grid_columnconfigure(1, weight=1)  # 设置第1列的权重为1

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("place布局管理器示例")
root.geometry("500x400")

# 使用绝对坐标放置控件
absolute_button = tk.Button(root, text="绝对位置按钮", font=("Arial", 12))
absolute_button.place(x=50, y=50, width=150, height=50)  # 在(50, 50)位置放置一个宽150、高50的按钮

# 使用相对坐标放置控件
relative_button = tk.Button(root, text="相对位置按钮", font=("Arial", 12))
relative_button.place(relx=0.5, rely=0.5, relwidth=0.3, relheight=0.1, anchor="center")  # 在窗口中心放置一个占窗口宽度30%、高度10%的按钮

# 创建一个框架，使用place布局
frame = tk.Frame(root, bg="lightblue")
frame.place(relx=0.1, rely=0.3, relwidth=0.8, relheight=0.2)  # 放置一个占窗口宽度80%、高度20%的框架

# 在框架中放置标签
frame_label = tk.Label(frame, text="这是框架中的标签", font=("Arial", 14), bg="lightblue")
frame_label.place(relx=0.5, rely=0.5, anchor="center")  # 在框架中心放置标签

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("布局管理器组合示例")
root.geometry("600x500")

# 创建顶部区域，使用pack布局
header_frame = tk.Frame(root, bg="lightblue", height=80)
header_frame.pack(fill="x", padx=10, pady=10)
header_frame.pack_propagate(False)

# 在顶部区域添加标题
header_label = tk.Label(header_frame, text="Tkinter布局管理器示例", font=("Arial", 20), bg="lightblue")
header_label.pack(pady=20)

# 创建中间区域，使用pack布局
content_frame = tk.Frame(root, bg="white", height=300)
content_frame.pack(fill="both", expand=True, padx=10, pady=10)

# 在中间区域中创建左侧和右侧面板，使用pack布局
left_panel = tk.Frame(content_frame, bg="lightgreen", width=150)
left_panel.pack(side="left", fill="y", padx=10, pady=10)
left_panel.pack_propagate(False)

right_panel = tk.Frame(content_frame, bg="lightyellow")
right_panel.pack(side="right", fill="both", expand=True, padx=10, pady=10)

# 在左侧面板中添加按钮，使用pack布局
for i in range(5):
    button = tk.Button(left_panel, text=f"按钮{i+1}", font=("Arial", 12), width=10)
    button.pack(pady=10)

# 在右侧面板中创建一个表单，使用grid布局
name_label = tk.Label(right_panel, text="姓名：", font=("Arial", 12), bg="lightyellow")
name_label.grid(row=0, column=0, padx=10, pady=10, sticky="e")

name_entry = tk.Entry(right_panel, font=("Arial", 12), width=20)
name_entry.grid(row=0, column=1, padx=10, pady=10)

age_label = tk.Label(right_panel, text="年龄：", font=("Arial", 12), bg="lightyellow")
age_label.grid(row=1, column=0, padx=10, pady=10, sticky="e")

age_entry = tk.Entry(right_panel, font=("Arial", 12), width=20)
age_entry.grid(row=1, column=1, padx=10, pady=10)

# 创建底部区域，使用pack布局
footer_frame = tk.Frame(root, bg="lightgray", height=50)
footer_frame.pack(fill="x", padx=10, pady=10)
footer_frame.pack_propagate(False)

# 在底部区域中添加状态标签，使用place布局
status_label = tk.Label(footer_frame, text="就绪", font=("Arial", 12), bg="lightgray")
status_label.place(relx=0.5, rely=0.5, anchor="center")

root.mainloop()

import tkinter as tk
from tkinter import filedialog, messagebox, simpledialog
import os

class NotepadApp:
    def __init__(self, root):
        self.root = root
        self.root.title("记事本")
        self.root.geometry("800x600")
        
        # 设置窗口图标（可选）
        # self.root.iconbitmap("icon.ico")
        
        # 当前文件路径
        self.current_file = ""
        
        # 创建文本编辑区
        self.text_widget = tk.Text(
            root,
            font=("Arial", 12),
            wrap="word",
            undo=True,
            maxundo=100
        )
        self.text_widget.pack(fill="both", expand=True, padx=5, pady=5)
        
        # 创建滚动条
        self.scrollbar = tk.Scrollbar(self.text_widget, command=self.text_widget.yview)
        self.scrollbar.pack(side="right", fill="y")
        self.text_widget.config(yscrollcommand=self.scrollbar.set)
        
        # 创建状态栏
        self.status_bar = tk.Label(root, text="就绪", anchor="w", font=("Arial", 10))
        self.status_bar.pack(side="bottom", fill="x")
        
        # 创建菜单栏
        self.create_menu()
        
        # 绑定事件
        self.bind_events()
        
        # 更新状态栏
        self.update_status_bar()
    
    def create_menu(self):
        # 创建菜单栏
        self.menu_bar = tk.Menu(self.root)
        
        # 创建文件菜单
        self.file_menu = tk.Menu(self.menu_bar, tearoff=0)
        self.file_menu.add_command(label="新建", command=self.new_file, accelerator="Ctrl+N")
        self.file_menu.add_command(label="打开", command=self.open_file, accelerator="Ctrl+O")
        self.file_menu.add_command(label="保存", command=self.save_file, accelerator="Ctrl+S")
        self.file_menu.add_command(label="另存为", command=self.save_as_file, accelerator="Ctrl+Shift+S")
        self.file_menu.add_separator()
        self.file_menu.add_command(label="退出", command=self.exit_app, accelerator="Ctrl+Q")
        self.menu_bar.add_cascade(label="文件", menu=self.file_menu)
        
        # 创建编辑菜单
        self.edit_menu = tk.Menu(self.menu_bar, tearoff=0)
        self.edit_menu.add_command(label="撤销", command=self.undo, accelerator="Ctrl+Z")
        self.edit_menu.add_command(label="重做", command=self.redo, accelerator="Ctrl+Y")
        self.edit_menu.add_separator()
        self.edit_menu.add_command(label="剪切", command=self.cut, accelerator="Ctrl+X")
        self.edit_menu.add_command(label="复制", command=self.copy, accelerator="Ctrl+C")
        self.edit_menu.add_command(label="粘贴", command=self.paste, accelerator="Ctrl+V")
        self.edit_menu.add_separator()
        self.edit_menu.add_command(label="查找", command=self.find, accelerator="Ctrl+F")
        self.menu_bar.add_cascade(label="编辑", menu=self.edit_menu)
        
        # 创建帮助菜单
        self.help_menu = tk.Menu(self.menu_bar, tearoff=0)
        self.help_menu.add_command(label="关于", command=self.show_about)
        self.menu_bar.add_cascade(label="帮助", menu=self.help_menu)
        
        # 设置菜单栏
        self.root.config(menu=self.menu_bar)
    
    def bind_events(self):
        # 绑定键盘快捷键
        self.root.bind("<Control-n>", lambda event: self.new_file())
        self.root.bind("<Control-o>", lambda event: self.open_file())
        self.root.bind("<Control-s>", lambda event: self.save_file())
        self.root.bind("<Control-Shift-S>", lambda event: self.save_as_file())
        self.root.bind("<Control-q>", lambda event: self.exit_app())
        self.root.bind("<Control-z>", lambda event: self.undo())
        self.root.bind("<Control-y>", lambda event: self.redo())
        self.root.bind("<Control-x>", lambda event: self.cut())
        self.root.bind("<Control-c>", lambda event: self.copy())
        self.root.bind("<Control-v>", lambda event: self.paste())
        self.root.bind("<Control-f>", lambda event: self.find())
        
        # 绑定文本变化事件，更新状态栏
        self.text_widget.bind("<KeyRelease>", lambda event: self.update_status_bar())
        
        # 绑定窗口关闭事件
        self.root.protocol("WM_DELETE_WINDOW", self.exit_app)
    
    def new_file(self):
        # 检查是否需要保存当前文件
        if self.text_widget.edit_modified():
            result = messagebox.askyesnocancel("保存", "是否保存当前文件？")
            if result is None:  # 取消操作
                return
            if result:  # 保存文件
                if not self.save_file():
                    return
        
        # 创建新文件
        self.text_widget.delete("1.0", "end")
        self.current_file = ""
        self.root.title("记事本")
        self.text_widget.edit_modified(False)
        self.update_status_bar()
    
    def open_file(self):
        # 检查是否需要保存当前文件
        if self.text_widget.edit_modified():
            result = messagebox.askyesnocancel("保存", "是否保存当前文件？")
            if result is None:  # 取消操作
                return
            if result:  # 保存文件
                if not self.save_file():
                    return
        
        # 打开文件对话框
        file_path = filedialog.askopenfilename(
            title="打开文件",
            filetypes=[("文本文件", "*.txt"), ("所有文件", "*.*")]
        )
        
        if file_path:
            try:
                # 读取文件内容
                with open(file_path, "r", encoding="utf-8") as file:
                    content = file.read()
                
                # 显示文件内容
                self.text_widget.delete("1.0", "end")
                self.text_widget.insert("end", content)
                
                # 更新当前文件路径和窗口标题
                self.current_file = file_path
                self.root.title(f"记事本 - {os.path.basename(file_path)}")
                self.text_widget.edit_modified(False)
                self.update_status_bar()
            except Exception as e:
                messagebox.showerror("错误", f"无法打开文件：{str(e)}")
    
    def save_file(self):
        if self.current_file:
            try:
                # 保存文件内容
                with open(self.current_file, "w", encoding="utf-8") as file:
                    content = self.text_widget.get("1.0", "end-1c")
                    file.write(content)
                
                self.text_widget.edit_modified(False)
                self.update_status_bar()
                return True
            except Exception as e:
                messagebox.showerror("错误", f"无法保存文件：{str(e)}")
                return False
        else:
            return self.save_as_file()
    
    def save_as_file(self):
        # 打开保存文件对话框
        file_path = filedialog.asksaveasfilename(
            title="另存为",
            defaultextension=".txt",
            filetypes=[("文本文件", "*.txt"), ("所有文件", "*.*")]
        )
        
        if file_path:
            self.current_file = file_path
            self.root.title(f"记事本 - {os.path.basename(file_path)}")
            return self.save_file()
        else:
            return False
    
    def exit_app(self):
        # 检查是否需要保存当前文件
        if self.text_widget.edit_modified():
            result = messagebox.askyesnocancel("保存", "是否保存当前文件？")
            if result is None:  # 取消操作
                return
            if result:  # 保存文件
                if not self.save_file():
                    return
        
        # 退出应用程序
        self.root.destroy()
    
    def undo(self):
        try:
            self.text_widget.edit_undo()
        except tk.TclError:
            pass
    
    def redo(self):
        try:
            self.text_widget.edit_redo()
        except tk.TclError:
            pass
    
    def cut(self):
        self.text_widget.event_generate("<<Cut>>")
        self.update_status_bar()
    
    def copy(self):
        self.text_widget.event_generate("<<Copy>>")
    
    def paste(self):
        self.text_widget.event_generate("<<Paste>>")
        self.update_status_bar()
    
    def find(self):
        # 获取要查找的文本
        target = simpledialog.askstring("查找", "请输入要查找的文本：")
        
        if target:
            # 获取当前光标位置
            current_pos = self.text_widget.index(tk.INSERT)
            # 查找文本
            pos = self.text_widget.search(target, current_pos, "end")
            
            if pos:
                # 计算文本结束位置
                end_pos = f"{pos}+{len(target)}c"
                # 选中找到的文本
                self.text_widget.tag_remove("search", "1.0", "end")
                self.text_widget.tag_add("search", pos, end_pos)
                self.text_widget.tag_config("search", background="yellow")
                # 移动光标到找到的文本位置
                self.text_widget.mark_set(tk.INSERT, end_pos)
                self.text_widget.see(pos)
            else:
                messagebox.showinfo("查找", f"未找到 '{target}'")
    
    def show_about(self):
        messagebox.showinfo(
            "关于记事本",
            "Tkinter记事本\n\n版本：1.0\n\n这是一个使用Python Tkinter创建的简单记事本应用程序。"
        )
    
    def update_status_bar(self):
        # 获取文本的行数和字符数
        content = self.text_widget.get("1.0", "end-1c")
        lines = content.count("\n") + 1
        chars = len(content)
        
        # 更新状态栏
        status = f"行数: {lines}, 字符数: {chars}"
        if self.text_widget.edit_modified():
            status += " (已修改)"
        
        self.status_bar.config(text=status)

# 创建应用程序
if __name__ == "__main__":
    root = tk.Tk()
    app = NotepadApp(root)
    root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("中文显示示例")
root.geometry("500x300")

# 明确指定支持中文的字体
label = tk.Label(root, text="这是中文显示示例", font=("SimHei", 16))
label.pack(pady=20)

# 或者使用系统默认字体
default_font = tk.font.nametofont("TkDefaultFont")
# 尝试设置字体为支持中文的字体
for font_name in ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]:
    try:
        default_font.configure(family=font_name)
        break
    except tk.TclError:
        continue

# 使用默认字体创建控件
text = tk.Text(root, font=default_font)
text.pack(pady=10, fill="both", expand=True)
text.insert("end", "这是使用默认字体的中文显示示例。")

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("窗口大小和位置示例")

# 设置窗口大小和位置（宽度x高度+x坐标+y坐标）
root.geometry("800x600+200+100")

# 禁止用户调整窗口大小（width, height）
# root.resizable(False, False)

# 只允许用户调整窗口宽度
# root.resizable(True, False)

# 只允许用户调整窗口高度
# root.resizable(False, True)

root.mainloop()

import tkinter as tk
import threading
import time

class ThreadingExample:
    def __init__(self, root):
        self.root = root
        self.root.title("多线程示例")
        self.root.geometry("500x300")
        
        # 创建一个标签用于显示进度
        self.progress_label = tk.Label(root, text="准备就绪", font=("Arial", 14))
        self.progress_label.pack(pady=20)
        
        # 创建一个按钮用于启动耗时操作
        self.start_button = tk.Button(root, text="开始耗时操作", command=self.start_long_task, font=("Arial", 12))
        self.start_button.pack(pady=10)
        
        # 创建一个按钮用于取消操作
        self.cancel_button = tk.Button(root, text="取消", command=self.cancel_task, font=("Arial", 12), state="disabled")
        self.cancel_button.pack(pady=10)
        
        # 标志变量，用于取消线程
        self.running = False
    
    def start_long_task(self):
        # 禁用开始按钮，启用取消按钮
        self.start_button.config(state="disabled")
        self.cancel_button.config(state="normal")
        
        # 设置运行标志
        self.running = True
        
        # 创建并启动线程
        self.thread = threading.Thread(target=self.long_task)
        self.thread.daemon = True  # 设置为守护线程，主线程结束时自动终止
        self.thread.start()
        
        # 检查线程是否完成
        self.check_thread()
    
    def long_task(self):
        # 模拟耗时操作
        for i in range(1, 11):
            if not self.running:
                break
            # 更新进度
            progress = f"进度：{i}0%"
            # 使用事件循环更新界面
            self.root.event_generate("<<UpdateProgress>>", when="tail", data=progress)
            # 等待一段时间
            time.sleep(1)
        
        # 任务完成或取消
        result = "任务完成" if self.running else "任务取消"
        self.root.event_generate("<<TaskComplete>>", when="tail", data=result)
    
    def check_thread(self):
        # 检查线程是否仍在运行
        if self.thread.is_alive():
            # 继续检查
            self.root.after(100, self.check_thread)
    
    def cancel_task(self):
        # 设置运行标志为False，取消线程
        self.running = False

# 创建应用程序
if __name__ == "__main__":
    root = tk.Tk()
    app = ThreadingExample(root)
    
    # 定义事件处理函数
    def update_progress(event):
        app.progress_label.config(text=event.data)
    
    def task_complete(event):
        app.progress_label.config(text=event.data)
        app.start_button.config(state="normal")
        app.cancel_button.config(state="disabled")
    
    # 绑定自定义事件
    root.bind("<<UpdateProgress>>", update_progress)
    root.bind("<<TaskComplete>>", task_complete)
    
    root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("界面优化示例")
root.geometry("800x600")

# 技巧1：使用Canvas绘制大量相似的元素，而不是创建大量的控件
canvas = tk.Canvas(root, width=700, height=500, bg="white")
canvas.pack(pady=20)

# 绘制1000个小圆点
for i in range(100):
    for j in range(10):
        x = 50 + i * 6
        y = 50 + j * 40
        canvas.create_oval(x-2, y-2, x+2, y+2, fill="blue")

# 技巧2：使用update_idletasks()而不是update()来更新界面
def update_interface():
    # 执行一些操作
    # ...
    # 使用update_idletasks()更新界面
    root.update_idletasks()

# 技巧3：使用ttk控件代替tk控件，ttk控件通常更高效
from tkinter import ttk

# 创建一个ttk按钮
style = ttk.Style()
# 配置ttk按钮的样式
style.configure("TButton", font=("Arial", 12))

button = ttk.Button(root, text="ttk按钮")
button.pack(pady=10)

# 技巧4：延迟加载非关键组件
def load_heavy_component():
    # 加载耗时的组件
    pass

# 使用after()方法延迟加载
root.after(1000, load_heavy_component)

root.mainloop()

import tkinter as tk

root = tk.Tk()
root.title("窗口置顶示例")
root.geometry("500x300")

# 设置窗口置顶
root.wm_attributes("-topmost", 1)

# 创建一个按钮用于切换窗口置顶状态
def toggle_topmost():
    current_state = root.wm_attributes("-topmost")
    new_state = 0 if current_state else 1
    root.wm_attributes("-topmost", new_state)
    button.config(text="取消置顶" if new_state else "置顶")

# 创建一个标签
label = tk.Label(root, text="这是一个可以置顶的窗口", font=("Arial", 14))
label.pack(pady=20)

# 创建一个按钮
button = tk.Button(root, text="取消置顶", command=toggle_topmost, font=("Arial", 12))
button.pack(pady=10)

root.mainloop()

import tkinter as tk
from tkinter import ttk

class CustomDialog:
    def __init__(self, parent, title="自定义对话框"):
        self.parent = parent
        self.dialog = tk.Toplevel(parent)
        self.dialog.title(title)
        self.dialog.geometry("400x300")
        # 设置对话框为模态窗口
        self.dialog.transient(parent)  # 设置为主窗口的子窗口
        self.dialog.grab_set()  # 抓取焦点
        
        # 居中显示对话框
        self.dialog.update_idletasks()
        width = self.dialog.winfo_width()
        height = self.dialog.winfo_height()
        x = (self.parent.winfo_width() // 2) - (width // 2) + self.parent.winfo_x()
        y = (self.parent.winfo_height() // 2) - (height // 2) + self.parent.winfo_y()
        self.dialog.geometry(f"{width}x{height}+{x}+{y}")
        
        # 创建对话框内容
        self.create_widgets()
        
        # 存储对话框的结果
        self.result = None
    
    def create_widgets(self):
        # 创建一个标签
        label = ttk.Label(self.dialog, text="这是一个自定义对话框", font=("Arial", 14))
        label.pack(pady=20)
        
        # 创建一个框架用于放置按钮
        button_frame = ttk.Frame(self.dialog)
        button_frame.pack(side="bottom", pady=20)
        
        # 创建确定按钮
        ok_button = ttk.Button(button_frame, text="确定", command=self.on_ok)
        ok_button.pack(side="left", padx=10)
        
        # 创建取消按钮
        cancel_button = ttk.Button(button_frame, text="取消", command=self.on_cancel)
        cancel_button.pack(side="right", padx=10)
    
    def on_ok(self):
        self.result = "ok"
        self.dialog.destroy()
    
    def on_cancel(self):
        self.result = "cancel"
        self.dialog.destroy()
    
    def show(self):
        # 显示对话框并等待其关闭
        self.parent.wait_window(self.dialog)
        # 返回对话框的结果
        return self.result

# 使用自定义对话框的示例
root = tk.Tk()
root.title("自定义对话框示例")
root.geometry("500x400")

# 定义显示自定义对话框的函数
def show_custom_dialog():
    dialog = CustomDialog(root, "我的自定义对话框")
    result = dialog.show()
    label.config(text=f"对话框结果：{result}")

# 创建一个标签
label = ttk.Label(root, text="请点击按钮显示对话框", font=("Arial", 14))
label.pack(pady=20)

# 创建一个按钮
button = ttk.Button(root, text="显示对话框", command=show_custom_dialog)
button.pack(pady=10)

root.mainloop()