import tkinter as tk
class Window(tk.Tk):
def __init__(self):
super(Window, self).__init__()
self.var=tk.IntVar()
self.rad=tk.Radiobutton(self,text='one',variable=self.var,value=1)
self.rad2=tk.Radiobutton(self,text='two',variable=self.var,value=2)
self.rad3=tk.Radiobutton(self,text='three',variable=self.var,value=3)
self.btn=tk.Button(self,text='click',command=self.slot_fun)
#布局
for i in [self.rad,self.rad2,self.rad3,self.btn]:
i.pack(side=tk.LEFT,padx=30,pady=30,ipadx=10,ipady=10)
def slot_fun(self):
print(self.var.get())
if __name__ == '__main__':
win=Window()
win.geometry("500x500")
win.config(bg='lightblue')
win.mainloop()
import tkinter as tk
langs=[
('python',1),
('c++',2),
('c#',3),
('delphi',4)
]
class Window(tk.Tk):
def __init__(self):
super(Window, self).__init__()
self.var=tk.IntVar(value=1)
for i,index in langs:
rad=tk.Radiobutton(self,text=i,variable=self.var,value=index,font=("宋体",18))
rad.pack(side=tk.LEFT,padx=30,pady=10,ipadx=10,ipady=10)
self.btn=tk.Button(self,text='click',command=self.btn_click,anchor=tk.W)
self.btn.pack(side=tk.BOTTOM,padx=10,pady=40)
def btn_click(self):
index=self.var.get()
print(langs[index-1][0])
if __name__ == '__main__':
win=Window()
win.geometry("500x500")
win.config(bg='lightblue')
win.mainloop()
import tkinter as tk
class Window(tk.Tk):
def __init__(self):
super(Window, self).__init__()
self.title("文本控件学习")
self.text=tk.Text(self,width=30,height=20,bg='lightblue')
self.text.pack(side=tk.LEFT,anchor=tk.NW,pady=10,padx=10)
self.btn=tk.Button(self,text='获取数据')
self.btn2=tk.Button(self,text='插入数据')
self.btn3=tk.Button(self,text='删除数据')
self.btn4=tk.Button(self,text='获取光标位置')
#布局
self.layout()
#绑定槽函数
self.bind_slots()
def layout(self):
for btn in [self.btn,self.btn2,self.btn3,self.btn4]:
btn.pack(side=tk.BOTTOM,pady=20,anchor=tk.W)
def bind_slots(self):
self.btn.config(command=self.get_text)
self.btn2.config(command=self.insert_text)
self.btn3.config(command=self.delete_text)
self.btn4.config(command=self.text_cursor)
def get_text(self):
data=self.text.get(0.0,tk.END)
print(data)
def insert_text(self):
data='9999'
self.text.insert('1.2',data)
def delete_text(self):
self.text.delete(1.0,'1.end')
def text_cursor(self):
pass
if __name__ == '__main__':
win=Window()
win.geometry("500x500")
win.mainloop()
菜单栏
class Window(tk.Tk):
def __init__(self):
super(Window, self).__init__()
self.title("菜单栏")
#创建一个菜单栏
menu=tk.Menu(self)
#给菜单栏添加一级选项
menu.add_command(label="新建",command=lambda :print('new file'))
menu.add_command(label="设置",command=lambda :print('set'))
menu.add_command(label='退出',command=lambda :print('退出'))
#给root配置菜单栏
self.config(menu=menu)
if __name__ == '__main__':
win=Window()
win.geometry("500x500")
win.mainloop()
二级菜单
import tkinter as tk
class Window(tk.Tk):
def __init__(self):
super(Window, self).__init__()
self.title("二级菜单栏")
#1.0创建一个菜单栏
menu=tk.Menu(self)
#1.2使用一级菜单栏创建二级菜单栏
file_menu=tk.Menu(menu)
#1.3给二级菜单栏添加选项
file_menu.add_command(label="新建",command=lambda :print('new file'))
file_menu.add_command(label="设置",command=lambda :print('set'))
file_menu.add_command(label='退出',command=lambda :print('退出'))
#1.4将二级菜单栏绑定到一级菜单栏
menu.add_cascade(label="文件",menu=file_menu)
#给root配置菜单栏
self.config(menu=menu)
if __name__ == '__main__':
win=Window()
win.geometry("500x500")
win.mainloop()
多选按钮用法
import tkinter as tk
def func():
select_options=[]
for option,var in options.items():
if var.get()==1:
select_options.append(var.get())
print('select_options',select_options)
root=tk.Tk()
root.geometry("500x400")
options={
"option 1":tk.IntVar(),
"option 2":tk.IntVar(),
"option 3":tk.IntVar(),
"option 4":tk.IntVar(),
}
for option,var in options.items():
checkbutton=tk.Checkbutton(root,text=option,variable=var)
checkbutton.pack(pady=10)
btn=tk.Button(root,text='click',command=func)
btn.pack(pady=10)
root.mainloop()combox用法
# ComboBox 在 tkinter 中有以下常用的事件：
#
# 1. `<FocusIn>`：当 ComboBox 获得焦点时触发的事件。
# 2. `<FocusOut>`：当 ComboBox 失去焦点时触发的事件。
# 3. `<Button-1>`：当用户单击 ComboBox 时触发的事件。
# 4. `<Return>`：当用户在 ComboBox 中按下回车键时触发的事件。
# 5. `<Down>`：当用户按下下箭头键时触发的事件。
# 6. `<KeyRelease>`：当用户释放任何键时触发的事件。
#
# 您可以使用 `bind()` 方法将这些事件与相应的处理函数绑定，以便在事件发生时执行特定的操作。
#
# 以下是一个示例代码，演示了如何绑定 ComboBox 的事件：
import tkinter as tk
from tkinter import ttk
def on_focus_in(event):
print("ComboBox gained focus")
def on_focus_out(event):
print("ComboBox lost focus")
def on_click(event):
print("ComboBox clicked")
def on_return(event):
print("Return key pressed")
def on_down(event):
print("Down arrow key pressed")
def on_key_release(event):
# print("Key released")
print(combo_box.get())
root = tk.Tk()
combo_values = ["Option 1", "Option 2", "Option 3"]
combo_box = tk.ttk.Combobox(root, values=combo_values)
combo_box.pack()
combo_box.bind("<FocusIn>", on_focus_in)
combo_box.bind("<FocusOut>", on_focus_out)
combo_box.bind("<Button-1>", on_click)
combo_box.bind("<Return>", on_return)
combo_box.bind("<Down>", on_down)
combo_box.bind("<KeyRelease>", on_key_release)
root.mainloop()
#
# 在上述代码中，我们定义了几个处理函数，分别对应不同的 ComboBox 事件。我们通过 `bind()` 方法将每个事件与相应的处理函数绑定。
#
# 当 ComboBox 获得焦点、失去焦点、单击、按下回车键、按下下箭头键或释放任何键时，将分别调用相应的处理函数。
#
# 希望这个示例能帮助您了解 ComboBox 的事件和如何绑定它们。 当用户在下拉框中选择了一个选项时，可以通过绑定事件来处理选择事件。
在 tkinter 中，下拉框的选择事件是 `<ComboboxSelected>`。要绑定该事件，可以使用 `bind()` 方法，如下所示：
```python
combobox.bind("<<ComboboxSelected>>", on_select)
```
在上述代码中，我们通过 `bind()` 方法将 `on_select()` 函数绑定到下拉框的选择事件上。当用户在下拉框中选择了一个选项时，将自动调用 `on_select()` 函数。
下面是一个完整的示例代码，演示了如何在下拉框选择事件发生时触发处理函数：
```python
import tkinter as tk
from tkinter import ttk
def on_select(event):
selected_option = combobox.get()
print("Selected option:", selected_option)
root = tk.Tk()
options = ["Option 1", "Option 2", "Option 3"]
combobox = ttk.Combobox(root, values=options)
combobox.bind("<<ComboboxSelected>>", on_select)
combobox.pack()
root.mainloop()
```
在上述代码中，我们定义了一个 `on_select()` 函数，该函数将在下拉框选择事件发生时被调用。在函数中，我们获取当前选择的选项，并打印出来。
然后，我们创建了一个下拉框 `combobox`，并通过 `bind()` 方法将 `on_select()` 函数绑定到下拉框的选择事件上。最后，我们将下拉框添加到窗口中并进入主循环。
希望这个示例能帮助您理解如何在 tkinter 中处理下拉框的选择事件。
import tkinter as tk
from tkinter import ttk
def func():
selection=var.get()
print(selection)
def on_selected(event):
data=combox.get() #注意，pack()写在一行会出错，因为返回值为None,所以要单独pack()布局
print(data)
root=tk.Tk()
root.geometry("500x400")
options=['option1','option2','option3','option4']
var=tk.StringVar()
var.set(options[1])
combox=ttk.Combobox(root,textvariable=var,values=options)
combox.pack()
combox.bind('<<ComboboxSelected>>',on_selected) #注意这里是双尖括号《》
btn=ttk.Button(root,text='click',command=func).pack()
root.mainloop()Spinbox
import tkinter as tk
from tkinter import ttk
def func():
selection=spinbox.get()
print(selection)
root=tk.Tk()
root.geometry("500x400")
var=tk.IntVar()
spinbox=tk.Spinbox(root,from_=1,to=10,textvariable=var)
spinbox.pack()
btn=ttk.Button(root,text='click',command=func).pack()
root.mainloop()# Spinbox 在 tkinter 中有以下常用的事件：
#
# 1. `<FocusIn>`：当 Spinbox 获得焦点时触发的事件。
# 2. `<FocusOut>`：当 Spinbox 失去焦点时触发的事件。
# 3. `<Return>`：当用户在 Spinbox 中按下回车键时触发的事件。
# 4. `<Up>`：当用户按下上箭头键时触发的事件。
# 5. `<Down>`：当用户按下下箭头键时触发的事件。
# 6. `<Button-1>`：当用户单击 Spinbox 时触发的事件。
#
# 您可以使用 `bind()` 方法将这些事件与相应的处理函数绑定，以便在事件发生时执行特定的操作。
#
# 以下是一个示例代码，演示了如何绑定 Spinbox 的事件：
import tkinter as tk
def on_focus_in(event):
print("Spinbox gained focus")
def on_focus_out(event):
print("Spinbox lost focus")
def on_return(event):
print("Return key pressed")
def on_up(event):
print("Up arrow key pressed")
def on_down(event):
print("Down arrow key pressed")
def on_click(event):
print("Spinbox clicked")
root = tk.Tk()
spinbox = tk.Spinbox(root)
spinbox.pack()
spinbox.bind("<FocusIn>", on_focus_in)
spinbox.bind("<FocusOut>", on_focus_out)
spinbox.bind("<Return>", on_return)
spinbox.bind("<Up>", on_up)
spinbox.bind("<Down>", on_down)
spinbox.bind("<Button-1>", on_click)
root.mainloop()
#
# 在上述代码中，我们定义了几个处理函数，分别对应不同的 Spinbox 事件。我们通过 `bind()` 方法将每个事件与相应的处理函数绑定。
#
# 当 Spinbox 获得焦点、失去焦点、按下回车键、按下上下箭头键或点击 Spinbox 时，将分别调用相应的处理函数。
# ''' Progressbar用法
import tkinter as tk
from tkinter import ttk
def start_progress():
progress_bar.start()
def stop_progress():
progress_bar.stop()
root = tk.Tk()
progress_bar = ttk.Progressbar(root, mode='indeterminate')
progress_bar.pack()
start_button = tk.Button(root, text="Start", command=start_progress)
start_button.pack()
stop_button = tk.Button(root, text="Stop", command=stop_progress)
stop_button.pack()
root.mainloop()在 tkinter 中，Progressbar 控件没有内置的事件。它通常用于显示任务的进度，而不需要与用户进行交互。
然而，您可以使用其他控件（如 Button、Canvas 等）与 Progressbar 结合使用，并为这些控件绑定事件。以下是一些常见的控件事件：
1. `<Button-1>`：当用户单击鼠标左键时触发的事件。
2. `<Button-2>`：当用户单击鼠标中键（滚轮）时触发的事件。
3. `<Button-3>`：当用户单击鼠标右键时触发的事件。
4. `<Double-Button-1>`：当用户双击鼠标左键时触发的事件。
5. `<Enter>`：当鼠标进入控件区域时触发的事件。
6. `<Leave>`：当鼠标离开控件区域时触发的事件。
7. `<Key>`：当用户按下任意键盘按键时触发的事件。
8. `<Return>`：当用户按下回车键时触发的事件。
9. `<FocusIn>`：当控件获得焦点时触发的事件。
10. `<FocusOut>`：当控件失去焦点时触发的事件。
您可以使用 `bind()` 方法将这些事件与相应的处理函数绑定，以便在事件发生时执行特定的操作。
在上述代码中，我们创建了一个按钮，并使用 `bind()` 方法将 `<Button-1>` 事件与 `button_clicked` 函数绑定。当用户单击按钮时，将执行 `button_clicked` 函数。