tk(tkinter)操作

1.输入文本 

#encoding:gbk
import tkinter.messagebox
import tkinter  # 导入TKinter模块

ytm = tkinter.Tk()  # 创建Tk对象
ytm.title("文本")  # 设置窗口标题
# ytm.geometry("200x200")  # 设置窗口尺寸
screen_width = ytm.winfo_screenwidth()  # 获得屏幕宽度
screen_height = ytm.winfo_screenheight()  # 获得屏幕高度
# ytm.resizable(False, False)#让高宽都固定
ytm.update_idletasks()  # 刷新GUI
ytm.withdraw()  # 暂时不显示窗口来移动位置
ytm.geometry('%dx%d+%d+%d' % (
    ytm.winfo_width(), ytm.winfo_height(), (screen_width - ytm.winfo_width()) / 2,
    (screen_height - ytm.winfo_height()) / 2))  # center window on desktop
ytm.deiconify()

l1 = tkinter.Label(ytm, text="请输入传入的文本")  # 标签
l1.pack()  # 指定包管理器放置组件
user_text = tkinter.Entry()  # 创建文本框
# print(user_text)
user_text.pack()


# ytm.destroy()

def getuser():
    global get_text
    get_text = user_text.get()  # 获取文本框内容
    #
    if not get_text.strip():
        tkinter.messagebox.showwarning('警告', '输入内容为空')
        return
    print(get_text)


    if get_text:
        ytm.destroy()


def eventhandler(event):
    if event.keysym == 'Return':
        print('按下了确定')
        getuser()
    elif event.keysym == 'Right':
        print('按下了方向键右键！')


buttton = tkinter.Button(ytm, text="确定", command=getuser)  # command绑定获取文本框内容方法
buttton.bind_all('<Return>', eventhandler)
buttton.pack()
ytm.mainloop()  # 进入主循环

print("get_text=", get_text)

2.根据不同时间点击按钮，设置默认按钮

1. 创建了一个包含4个按钮的窗口界面，每个按钮都有对应的点击函数。
2. 设定了一个默认按钮，根据当前时间确定默认按钮的编号。
3. 倒计时标签显示了倒计时的剩余时间，默认为30秒，并根据剩余时间的变化更新标签的文本内容。
4. 当倒计时结束时，如果30秒内没有点击任何按钮，则自动点击默认按钮。
5. 启动了一个定时器，在每秒钟更新一次倒计时标签和检查按钮点击的状态。
6. 用户点击按钮时，执行相应的按钮点击函数，同时销毁倒计时标签和取消定时器。
7. 窗口设置为置顶，并居中显示在屏幕上。

通过以上功能，代码实现了一个简单的窗口应用程序，其中的按钮点击函数和逻辑处理可以根据实际需求进行扩展和修改。

import tkinter as tk
import time


class AutoClickWindow:
    def __init__(self, master):
        self.master = master
        self.button_labels = ["小时", "日自动", "日按键", '日支', '无需运行流程']
        self.button_count = len(self.button_labels)
        self.waiting_time = 10
        self.flag = 0
        self.default_button = self.calculate_default_button()

        self.create_widgets()
        self.start_time = time.time()
        self.after_id = self.master.after(1000, self.update_timer_label)

    def calculate_default_button(self):
        # 根据当前时间计算默认选择的按钮
        current_hour = time.localtime().tm_hour
        default_button = self.button_labels.index("无需运行流程") + 1

        if current_hour == 4:
            default_button = self.button_labels.index("日自动") + 1
        elif current_hour == 7 or current_hour == 8:
            default_button = self.button_labels.index("日支") + 1
        elif current_hour == 10 or current_hour == 13 or current_hour == 16 or current_hour == 17:
            default_button = self.button_labels.index("小时") + 1
        elif current_hour == 9:
            default_button = self.button_labels.index("日按键") + 1

        return default_button

    def button_click(self, button_number):
        # 按钮点击事件处理函数
        select = self.button_labels[button_number - 1]
        if self.flag == 1:
            self.master.destroy()
            return
        self.flag = 1
        print(f"button_click():按钮 {button_number} 被点击了！！, 进入【{select}】流程")

        popup_window = tk.Toplevel(self.master)
        self.create_popup_window(popup_window, button_number, select)

    def create_popup_window(self, popup_window, button_number, select):
        # 创建弹窗
        popup_window.title("提示")
        popup_window.geometry("500x100")
        popup_window.resizable(False, False)
        popup_window.attributes("-topmost", True)
        popup_window.protocol("WM_DELETE_WINDOW", lambda: None)

        # 弹窗居中显示
        main_window_x = self.master.winfo_rootx()
        main_window_y = self.master.winfo_rooty()
        main_window_width = self.master.winfo_width()
        main_window_height = self.master.winfo_height()
        popup_window_width = popup_window.winfo_width()
        popup_window_height = popup_window.winfo_height()
        x = main_window_x + (main_window_width - popup_window_width) // 2
        y = main_window_y + (main_window_height - popup_window_height) // 2
        popup_window.geometry(f"+{x}+{y}")

        # 弹窗中显示按钮点击信息
        label = tk.Label(popup_window, text=f"按钮 {button_number} 被点击了！\n即将进入【{select}】流程",
                         fg="red", font=("Arial", 20, "bold"))
        label.pack(pady=20)

        # 设置弹窗自动关闭
        popup_window.after(3000, popup_window.destroy)
        self.master.after(3000, self.master.destroy)

    def auto_click_button(self, button_number, remaining_time=1):
        # 自动点击按钮事件处理函数
        self.button_click(button_number)
        try:
            if remaining_time <= 0:
                print(f"{self.waiting_time}秒内无点击，自动点击按钮{button_number}, 进入【{self.button_labels[button_number - 1]}】流程！")
        except Exception as e:
            pass

    def update_timer_label(self):
        # 更新倒计时标签
        current_time = time.localtime()
        elapsed_time = int(time.time() - self.start_time)
        remaining_time = self.waiting_time - elapsed_time

        if remaining_time <= 0:
            self.auto_click_button(self.default_button, remaining_time)
            self.master.after_cancel(self.after_id)
        else:
            self.timer_label.config(
                text=f"倒计时: {remaining_time} 秒, 即将进入[%s]流程" % self.button_labels[self.default_button - 1])
            self.master.after(1000, self.update_timer_label)

    def create_widgets(self):
        # 创建主窗口和控件
        self.master.title("绿色默认选择")
        self.master.attributes('-topmost', True)

        buttons = []
        for i in range(self.button_count):
            button_number = i + 1
            button_label = self.button_labels[i]
            command = lambda num=button_number: self.button_click(num)
            if button_number == self.default_button:
                command = lambda num=button_number: self.auto_click_button(num)
                button = tk.Button(self.master, text=button_label, command=command, bg="green", cursor="hand2")
            else:
                button = tk.Button(self.master, text=button_label, command=command, cursor="hand2")
            button.configure(width=10, height=2)
            button.grid(row=i, pady=10, padx=10, sticky="ew")
            buttons.append(button)

        self.timer_label = tk.Label(self.master, text="倒计时: %s 秒, 即将进入[%s]流程" %
                                                  (self.waiting_time, self.button_labels[self.default_button - 1]),
                                    font=("Arial", 12))
        self.timer_label.grid(row=self.button_count, pady=10, padx=10, sticky="ew")


if __name__ == "__main__":
    root = tk.Tk()
    auto_click_app = AutoClickWindow(root)
    root.mainloop()

3.根据用户选择显示不同的输入字段，用户可以输入字典类型的值，点击确定按钮后获取这些值

import tkinter as tk
from tkinter import messagebox

class Application(tk.Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.pack()
        self.create_widgets()
        self.value1 = {}
        self.value2 = {}
        self.select = 0

    def create_widgets(self):


        self.var = tk.IntVar()

        self.button1 = tk.Radiobutton(self, text="第一个单选按钮", variable=self.var, value=0, command=self.button1_click)
        self.button1.pack()

        self.label2 = tk.Label(self, text="第1个输入框")
        # self.label2.pack()

        self.button2 = tk.Radiobutton(self, text="第二个单选按钮", variable=self.var, value=1, command=self.button2_click)
        self.button2.pack()

        self.label3 = tk.Label(self, text="第2个输入框")
        # self.label3.pack()
        
        self.button3 = tk.Radiobutton(self, text="第三个单选按钮", variable=self.var, value=2, command=self.button3_click)
        self.button3.pack()

        self.button_ok = tk.Button(self, text="确定", command=self.button_ok_click)
        self.button_ok.pack()
        
    def button1_click(self):
        self.select = 1
        self.label2.pack_forget()
        self.entry2.pack_forget()
        self.label3.pack_forget()
        self.entry3.pack_forget()

    def button2_click(self):
        self.select = 2
        if not hasattr(self, "entry2"):
            self.entry2 = tk.Text(self, height=5)
        self.label2.pack()
        self.entry2.pack()
        self.label3.pack_forget()
        if hasattr(self, "entry3"):
            self.entry3.pack_forget()

        

    def button3_click(self):
        self.select = 3
        self.label2.pack()
        if not hasattr(self, "entry2"):
            self.entry2 = tk.Text(self, height=5)
        self.entry2.pack()
        self.label3.pack()
        if not hasattr(self, "entry3"):
            self.entry3 = tk.Text(self, height=5)
        self.entry3.pack()

    def button_ok_click(self):
        flag = 1
        if hasattr(self, "entry2"):
            self.value1 = self.entry2.get("1.0", "end-1c").strip()

            # print('2', self.value1)
            # print(type())
            try:
                self.value1 = eval(self.value1)
                if isinstance(self.value1, dict):
                    print("字典类型")
            except Exception as e:
                flag = 0
                messagebox.showerror("错误", "非字典类型:\n" + self.value1)
                
        if  hasattr(self, "entry3"):
            self.value2 = self.entry3.get("1.0", "end-1c").strip()
            try:
                self.value2 = eval(self.value2)

                if isinstance(self.value2 , dict):
                    print("字典类型")
            except Exception as e:
                flag = 0
                print("非字典")
                messagebox.showerror("错误", "非字典类型:\n" + self.value2)
        # print(flag)
        if flag:
    
            self.master.destroy()
root = tk.Tk()
app = Application(master=root)
root.eval('tk::PlaceWindow . center')
app.mainloop()
print(app.value1 ,type(app.value1),  app.value2, app.select)

这个Python代码使用Tkinter库创建了一个简单的图形用户界面（GUI），其中包含了单选按钮和输入框。让我们逐步解释代码，说明每个部分的作用：

1. 导入库：
   - `import tkinter as tk`：导入Tkinter库并将其别名为`tk`。
   - `from tkinter import messagebox`：从Tkinter导入`messagebox`模块，用于显示消息框。

2. 类定义：
   - `class Application(tk.Frame)`：定义了一个名为`Application`的类，继承自`tk.Frame`。

3. 初始化方法：
   - `def __init__(self, master=None)`：初始化`Application`类。`master`是对主窗口的引用。
   - `self.value1`和`self.value2`初始化为空字典。
   - `self.select`初始化为0。

4. GUI创建方法：
   - `create_widgets(self)`：定义并在GUI中打包小部件（按钮、标签和输入字段）。
   - 创建了三个单选按钮（`button1`、`button2`和`button3`），带有相关的文本和值。
   - 创建了两个标签（`label2`和`label3`）和两个文本输入字段（`entry2`和`entry3`），但最初未打包。
   - 创建了一个“确定”按钮（`button_ok`）。

5. 单选按钮点击方法：
   - `button1_click`、`button2_click`和`button3_click`是三个单选按钮的回调函数。
   - 它们根据所选的单选按钮处理标签和输入字段的可见性和打包/取消打包。

6. “确定”按钮点击方法：
   - `button_ok_click`：验证并提取文本输入字段（`entry2`和`entry3`）中的值（如果存在）。
   - 使用`eval`检查输入的值是否为有效字典。
   - 如果输入的值不是有效字典，则显示错误消息。
   - 如果所有输入都有效，则销毁主窗口（`self.master.destroy()`）。

7. 创建主窗口并运行应用程序：
   - `root = tk.Tk()`：创建主Tkinter窗口。
   - `app = Application(master=root)`：使用主窗口创建`Application`类的实例。
   - `root.eval('tk::PlaceWindow . center')`：将主窗口居中显示。
   - `app.mainloop()`：启动Tkinter事件循环以运行应用程序。

8. 打印结果：
   - 在主循环之后（`app.mainloop()`），打印`app.value1`、`app.value2`和`app.select`的最终值。

4.允许用户通过复选框选择对应按钮

import tkinter as tk

class USBHubApp:
    def __init__(self, root, usbhub_key):
        self.root = root
        self.root.title("USBHub 字典选择器")
        self.return_value = None
        self.usbhub_key = usbhub_key

        self.checkbox_var_dict = {}
        self.max_columns = 5  # 设置每行最大的列数
        self.current_column = 0
        self.current_row = 0

        for key in self.usbhub_key:
            var = tk.IntVar()
            checkbox = tk.Checkbutton(root, text=key, variable=var)
            checkbox.grid(row=self.current_row, column=self.current_column, sticky="w")
            self.checkbox_var_dict[key] = var

            # 更新行和列
            self.current_column += 1
            if self.current_column == self.max_columns:
                self.current_column = 0
                self.current_row += 1

        self.current_row += 1  # 移动到下一行

        self.confirm_button = tk.Button(root, text="确认选择", command=self.confirm_selection)
        self.confirm_button.grid(row=self.current_row, column=0, columnspan=self.max_columns, sticky="w")

        self.current_row += 1

        # 创建一个标签用于显示选择的银行，设置wraplength属性为适当的值
        self.result_label = tk.Label(root, text="选择的银行：", wraplength=300, justify="left")
        self.result_label.grid(row=self.current_row, column=0, columnspan=self.max_columns, sticky="w")

        self.current_row += 1

        # 添加用于选择日、时、月的单选按钮
        self.selected_time = tk.StringVar(value="日")  # 默认选中"日"
        self.day_radio = tk.Radiobutton(root, text="日", variable=self.selected_time, value="日")
        self.day_radio.grid(row=self.current_row, column=0, sticky="w")

        self.hour_radio = tk.Radiobutton(root, text="时", variable=self.selected_time, value="时")
        self.hour_radio.grid(row=self.current_row, column=1, sticky="w")

        self.month_radio = tk.Radiobutton(root, text="月", variable=self.selected_time, value="month")
        self.month_radio.grid(row=self.current_row, column=2, sticky="w")

    def confirm_selection(self):
        selected_banks = [key for key, var in self.checkbox_var_dict.items() if var.get() == 1]
        selected_dict = {bank: self.usbhub_key[bank] for bank in selected_banks}

        time_unit = self.selected_time.get()
        result_text = f"选择的银行：{', '.join(selected_banks)}，选择的时间单位：{time_unit}"
        self.result_label.config(text=result_text)

        self.return_value = {"selected_dict": selected_dict, "selected_time": time_unit}

        # 启动定时器，在5秒后关闭窗口
        self.root.after(5000, self.close_window)

    def close_window(self):
        self.root.destroy()  # 关闭窗口

if __name__ == "__main__":
    root = tk.Tk()
    
    # 传递usbhub_key到USBHubApp类
    app = USBHubApp(root, {
        "邮政银行8988": "",
        "交通银行0659": "",
        # ... （省略部分字典项）
        "中信银行4033": "",
        "中信银行7567": "",
        "中信银行1743": "",
        "厦门银行2369": "",
    })
    
    root.mainloop()

    returned_value = app.return_value
    print("返回的字典和时间单位：", returned_value)