[100 Tage Python-Kenntnisse] Tag 35: GUI-Schnittstellenprogrammierung _ Beherrschen Sie die grundlegende Funktionsweise von Tkinter in einem Artikel

Bei der GUI-Programmierung (Graphical User Interface) handelt es sich um eine Technik zur Erstellung einer grafischen Benutzeroberfläche, die es einem Benutzer ermöglicht, über grafische Elemente wie Fenster, Schaltflächen, Textfelder usw. mit einem Programm zu interagieren.

Eine GUI (Graphical User Interface) ist eine Möglichkeit zur Interaktion mit einem Computerprogramm über grafische Elemente wie Fenster, Schaltflächen, Textfelder, Bilder usw. GUIs ermöglichen Benutzern die visuelle Kommunikation mit Anwendungen, ohne sich komplexe Befehle oder Syntax merken zu müssen. Die grafische Benutzeroberfläche kann das Benutzererlebnis erheblich verbessern und es Benutzern ermöglichen, Anwendungen intuitiver und bequemer zu bedienen.

1.1 Warum benötigen Sie eine GUI?

Benutzerfreundlichkeit : Die grafische Benutzeroberfläche erleichtert die Verwendung der Anwendung, sodass Sie sich keine Befehlszeilenparameter oder Codes merken müssen. Benutzer können Vorgänge intuitiv über eine grafische Oberfläche ausführen.

Visualisierung : Durch grafische Elemente können Benutzer Informationen, Daten und Betriebsergebnisse direkt auf der Oberfläche sehen und so die Funktionen der Anwendung leichter verstehen.

Interaktivität : Die GUI ermöglicht Benutzern die Interaktion mit Anwendungen über Maus, Tastatur, Berührung usw., um so mehr Arten von Vorgängen zu erreichen.

Erhöhte Effizienz : GUI-Tools bieten eine vereinfachte Benutzeroberfläche für komplexe Aufgaben, sodass Benutzer Aufgaben schneller ausführen und dadurch die Produktivität steigern können.

Plattformübergreifend : Viele GUI-Bibliotheken und -Tools unterstützen mehrere Betriebssysteme, sodass Entwickler ähnliche Benutzererlebnisse auf verschiedenen Plattformen schaffen können.

1.2 Gängige GUI-Programmiertools und Bibliotheken :

Tkinter : Pythons Standard-GUI-Bibliothek, geeignet für einfache GUI-Anwendungen, leicht zu erlernen und zu verwenden.

Qt : Eine plattformübergreifende GUI-Bibliothek mit umfangreichen Funktionen und professionellem Erscheinungsbild, die mehrere Programmiersprachen wie C++ und Python unterstützt.

wxWidgets : Eine weitere plattformübergreifende GUI-Bibliothek, die ein natives Erscheinungsbild für viele Programmiersprachen bietet.

GTK : Ein Open-Source-GUI-Toolkit zum Erstellen von Anwendungen unter Linux- und UNIX-Systemen.

PyQt : Qt-Bindungen für Python, die Qt-Funktionalität in die Python-Welt bringen und erweiterte Funktionen und Anpassungsoptionen bereitstellen.

Kivy : Eine Python-Bibliothek zur Entwicklung mobiler Anwendungen und anderer Multi-Touch-Schnittstellen, die mehrere Plattformen unterstützt.

1.3 Aufbau und Architektur der GUI-Anwendung :

Fenstermanager : Verantwortlich für die Verwaltung und Anzeige der Fenster der Anwendung, einschließlich der Größe, Position und Darstellung des Fensters.

Elemente der Benutzeroberfläche : einschließlich Schaltflächen, Textfelder, Beschriftungen, Menüs, Symbolleisten usw. werden für die Interaktion zwischen Benutzer und Programm verwendet.

Ereignisverarbeitung : Reagieren Sie auf Benutzeraktionen (z. B. Klicken auf Schaltflächen, Eingeben von Text usw.) und führen Sie entsprechende Vorgänge aus, um die Interaktion zwischen Benutzern und Anwendungen zu realisieren.

Layoutverwaltung : Anordnen und Organisieren der Position und Größe von Schnittstellenelementen, um eine konsistente Schnittstelle über verschiedene Bildschirmgrößen und Auflösungen hinweg darzustellen.

Grafische Zeichnung und Anzeige : Zeigen Sie Bilder, Diagramme und Diagramme zur Präsentation von Daten und Grafiken an.

Dateninteraktion : Kommunikation mit Back-End-Logik, Erfassung, Verarbeitung und Anzeige von Daten.

Ereignisschleife : GUI-Anwendungen sind normalerweise ereignisgesteuert. Sie überwachen Benutzervorgänge und Systemereignisse kontinuierlich und führen dann entsprechende Vorgänge aus.

Hauptschleife : Verantwortlich für die Überwachung und Verteilung von Ereignissen sowie für die Verwaltung der Anzeige und Aktualisierung von Fenstern.

Benutzererfahrung : Bieten Sie eine gute Benutzererfahrung, einschließlich einer benutzerfreundlichen Oberfläche, Feedback und Fehlerbehandlung.

Zusammenfassend lässt sich sagen, dass es sich bei GUI um eine Technologie zur Erstellung einer grafischen Benutzeroberfläche handelt, die die Interaktion und Benutzerfreundlichkeit zwischen Benutzern und Anwendungen erheblich verbessern kann. Verschiedene GUI-Bibliotheken und -Tools bieten unterschiedliche Ebenen an Funktionalität und Flexibilität, und Sie können die passende GUI-Entwicklungslösung entsprechend Ihren Projektanforderungen auswählen.

2 GUI-Programmierung mit der Tkinter-Bibliothek

Tkinter ist die Standard-GUI-Bibliothek von Python, mit der Fenster und verschiedene GUI-Komponenten wie Beschriftungen, Schaltflächen, Textfelder usw. erstellt werden können. Es handelt sich um ein leichtes und benutzerfreundliches Tool, das sich zum Erstellen kleiner bis mittlerer Desktop-Anwendungen eignet.

2.1 Grundlegender Ablauf der GUI-Programmierung mit der Tkinter-Bibliothek

Importieren Sie die Tkinter-Bibliothek : Zuerst müssen Sie die Tkinter-Bibliothek importieren. Wird im Allgemeinen zur Vereinfachung von Anrufen verwendet import tkinter as tk.

Hauptfenster erstellen : Verwenden Sie Tk()diese Funktion, um ein Hauptfensterobjekt zu erstellen, das die Hauptschnittstelle der Anwendung darstellt.

GUI-Komponenten hinzufügen : Fügen Sie verschiedene GUI-Komponenten wie Beschriftung, Schaltfläche, Eintrag usw. über verschiedene Tkinter-Klassen hinzu. Layoutkomponenten mit Methoden wie .pack(), .grid() usw.

Definieren Sie Ereignisbehandlungsfunktionen : Wenn Sie auf Komponentenereignisse reagieren müssen, z. B. auf Schaltflächenklickereignisse, müssen Sie entsprechende Ereignisbehandlungsfunktionen definieren.

Layoutverwaltung : Verwenden Sie Layoutmanager (z. B. .pack(), .grid(), .place()), um Komponenten anzuordnen und zu platzieren, um sicherzustellen, dass die Benutzeroberfläche übersichtlich angeordnet ist.

Starten Sie die Hauptschleife : Verwenden Sie die Methode .mainloop(), um die Hauptschleife der GUI-Anwendung zu starten, sodass die Anwendung weiter ausgeführt wird und auf Benutzeroperationen wartet.

2.2 GUI-Programmierung mit der Tkinter-Bibliothek

2.2.1 Tkinter-Bibliothek importieren

Importieren Sie zunächst die Tkinter-Bibliothek und erstellen Sie das Hauptfensterobjekt.

import tkinter as tk

# 创建主窗口
root = tk.Tk()
root.title("GUI Application")



root.mainloop()  #启动主循环

2.2.2 Beschriftungen und Schaltflächen hinzufügen

Verwenden Sie die Klassen „Label“ und „Button“, um Beschriftungs- und Schaltflächenkomponenten hinzuzufügen.

# 添加标签
label = tk.Label(root, text="Welcome to GUI Programming!")
label.pack()

# 添加按钮
def button_clicked():
    label.config(text="Button Clicked!")

button = tk.Button(root, text="Click Me", command=button_clicked)
button.pack()

2.2.3 Textfeld hinzufügen

Verwenden Sie die Entry-Klasse, um Textfelder hinzuzufügen.

# 添加文本框
entry = tk.Entry(root)
entry.pack()

2.2.4 Layoutverwaltung

Verwenden Sie die Methode pack(), um Komponenten anzuordnen.

label.pack()
button.pack()
entry.pack()

2.2.5 Ereignisbehandlung

Definieren Sie die Rückruffunktion für das Schaltflächenklickereignis.

def button_clicked():
    label.config(text="Hello, " + entry.get())

button = tk.Button(root, text="Submit", command=button_clicked)
button.pack()

2.2.6 Starten Sie die Hauptschleife

Starten Sie die Hauptschleife der GUI über die Methode mainloop().

root.mainloop()

3 Detaillierte Verwendung von Tkinter-Komponenten

3.1 Layoutverwaltung

3.1.1 Absolutes Layout vs. automatisches Layout

Absolutes Layout bezieht sich auf die genaue Positionierung der Position jeder Komponente anhand von Pixelkoordinaten. Das absolute Layout kann jedoch zu Instabilität und Fehlausrichtung der Benutzeroberfläche führen, wenn sich die Fenstergröße ändert. Daher wird es in den meisten Fällen nicht empfohlen. Das automatische Layout verwendet Layout-Manager, um Komponenten automatisch anzupassen und anzuordnen, um sie an Änderungen der Fenstergröße anzupassen, wodurch die Benutzeroberfläche reaktionsfähiger und anpassungsfähiger wird.

3.1.2 Verwendung des Grid-Layouts und des Pack-Layouts

Tkinter bietet zwei gängige Layout-Manager: .grid()und .pack(). .grid()Layouten Sie Komponenten mithilfe von Zeilen und Spalten und .pack()ordnen Sie die Komponenten automatisch in der Reihenfolge an, in der sie hinzugefügt wurden.

import tkinter as tk

root = tk.Tk()
root.title("Layout Example")

# 使用Grid布局
label1 = tk.Label(root, text="Label 1")
label2 = tk.Label(root, text="Label 2")
label1.grid(row=0, column=0)
label2.grid(row=1, column=1)

# 使用Pack布局
button1 = tk.Button(root, text="Button 1")
button2 = tk.Button(root, text="Button 2")
button1.pack()
button2.pack()

root.mainloop()

3.1.3 Gruppieren von Komponenten mithilfe von Frame und LabelFrame

Frame und LabelFrame sind Containerkomponenten in Tkinter, die zum Gruppieren und Organisieren anderer Komponenten verwendet werden können.

frame = tk.Frame(root)
frame.pack()

label_frame = tk.LabelFrame(root, text="Group")
label_frame.pack()

3.2 Ereignisbehandlung

Die Ereignisverarbeitung ist ein wichtiges Konzept in der GUI-Programmierung, das die Interaktion zwischen dem Benutzer und der Schnittstelle umfasst, z. B. Mausklick, Tastenklick, Tastatureingabe usw. Im Folgenden finden Sie detaillierte Erklärungen und Beispiele zur Ereignisbehandlung, damit Sie besser verstehen, wie Sie mit verschiedenen Ereignistypen in Tkinter umgehen.

Bei der GUI-Programmierung lösen Benutzeroperationen und -aktionen unterschiedliche Ereignisse aus, und das Programm reagiert auf diese Ereignisse über Ereignisverarbeitungsfunktionen. Ereignisse können Mausklicks, Tastenanschläge, Fensterschließungen usw. sein.

3.2.1 Bindungsereignisse und Rückruffunktionen

In Tkinter können Sie .bind()Methoden verwenden, um Ereignisse und entsprechende Rückruffunktionen miteinander zu verbinden. Wenn ein Ereignis eintritt, wird die daran gebundene Funktion aufgerufen.

import tkinter as tk

def button_clicked(event):
    label.config(text="Button Clicked!")

root = tk.Tk()
root.title("Event Handling Example")

label = tk.Label(root, text="Click the Button")
label.pack()

button = tk.Button(root, text="Click Me")
button.bind("<Button-1>", button_clicked)  # 绑定鼠标左键点击事件
button.pack()

root.mainloop()

Wenn in diesem Beispiel mit der linken Maustaste auf die Schaltfläche geklickt wird, button_clicked()wird die Funktion aufgerufen und der Inhalt der Beschriftung aktualisiert.

3.2.2 Gemeinsame Ereignisse

Neben Schaltflächenklick-Ereignissen gibt es viele andere häufige Ereignisse, wie z. B. Mausereignisse und Tastaturereignisse. Sie können diese Ereignisse mithilfe verschiedener Ereignisdeskriptoren binden.

def mouse_enter(event):
    label.config(text="Mouse Entered!")

def key_pressed(event):
    label.config(text="Key Pressed: " + event.char)

label.bind("<Enter>", mouse_enter)  # 鼠标进入事件
label.bind("<KeyPress>", key_pressed)  # 键盘按键事件

mouse_enter()In diesem Beispiel wird die Funktion aufgerufen, wenn die Maus den Beschriftungsbereich betritt ; wenn die Tastatur gedrückt wird, key_pressed()wird die Funktion aufgerufen und die gedrückte Taste angezeigt.

3.2.3 Ereignisobjekt

Wenn ein Ereignis auftritt, wird automatisch ein Ereignisobjekt erstellt, das im Ereignishandler verwendet werden kann, um Informationen über das Ereignis abzurufen.

def mouse_clicked(event):
    x = event.x  # 获取鼠标点击位置的x坐标
    y = event.y  # 获取鼠标点击位置的y坐标
    label.config(text=f"Mouse Clicked at ({x}, {y})")

label.bind("<Button-1>", mouse_clicked)  # 鼠标左键点击事件

In diesem Beispiel wird beim Klicken mit der linken Maustaste mouse_clicked()die Funktion aufgerufen und die Koordinaten des Mausklicks angezeigt.

Durch das Verständnis der grundlegenden Konzepte der Ereignisbehandlung, der Bindung verschiedener Ereignisse und der Verwendung von Ereignisobjekten können Sie GUI-Anwendungen mehr Interaktivität und Reaktionsfähigkeit verleihen und so die Interaktion zwischen Benutzern und der Schnittstelle umfassender und in Echtzeit gestalten.

3.3 Benutzereingabe und -ausgabe

3.3.1 Den Inhalt des Textfelds abrufen und festlegen

Sie können .get()die .insert()Methoden und verwenden, um den Inhalt des Textfelds abzurufen und festzulegen.

entry = tk.Entry(root)
entry.pack()
text = entry.get()  # 获取文本框内容
entry.insert(0, "Hello")  # 在光标处插入文本

3.3.2 Behandlung des Schaltflächenklickereignisses

Die Verarbeitung des Schaltflächenklickereignisses kann durch Binden der Rückruffunktion realisiert werden.

import tkinter as tk

def button_clicked():
    label.config(text="Button Clicked!")

root = tk.Tk()
root.title("Button Click Event Example")

label = tk.Label(root, text="Click the Button")
label.pack()

button = tk.Button(root, text="Click Me", command=button_clicked)  # 绑定回调函数
button.pack()

root.mainloop()

In diesem Beispiel erstellen wir eine Schaltfläche ( button) und binden über commandeinen Parameter button_clickedeine Funktion als Callback-Funktion der Schaltfläche . Wenn auf die Schaltfläche geklickt wird, button_clickedwird die Funktion automatisch aufgerufen und der Inhalt des Etiketts aktualisiert.

Auf diese Weise werden die Bedienung und Funktion der Schaltfläche von der Rückruffunktion entkoppelt, wodurch der Code modularer und klarer wird. In der Rückruffunktion können verschiedene Vorgänge ausgeführt werden, z. B. das Aktualisieren der Schnittstelle, das Durchführen von Berechnungen, das Anzeigen von Informationen usw.

3.3.3 Popup-Dialoge und Meldungsfelder erstellen

Tkinter bietet tkinter.messageboxModule zum Erstellen verschiedener Dialogfelder und Meldungsfelder.

import tkinter.messagebox as messagebox

def show_alert():
    messagebox.showinfo("Alert", "This is an alert message!")

button = tk.Button(root, text="Show Alert", command=show_alert)
button.pack()

3.4 Fenster- und Schnittstellendesign

3.4.1 Mehrere Fenster erstellen

In Tkinter können Sie mehrere Fenster erstellen, indem Sie neue Tk-Objekte erstellen. Jedes Tk-Objekt repräsentiert ein Anwendungsfenster. Hier ist ein Beispiel, das zeigt, wie man mehrere Fenster erstellt:

import tkinter as tk

# 创建第一个窗口
root1 = tk.Tk()
root1.title("Window 1")
label1 = tk.Label(root1, text="Window 1")
label1.pack()

# 创建第二个窗口
root2 = tk.Tk()
root2.title("Window 2")
label2 = tk.Label(root2, text="Window 2")
label2.pack()

root1.mainloop()
root2.mainloop()

In diesem Beispiel erstellen wir zwei verschiedene Tk-Objekte ( root1und root2), die jeweils ein Fenster darstellen. mainloop()Ermöglicht den unabhängigen Betrieb zweier Fenster durch den Aufruf ihrer jeweiligen Methoden.

3.4.2 Menüleiste und Symbolleiste hinzufügen

Tkinter unterstützt die Erstellung von Menüleisten und Symbolleisten, um die Funktionalität von GUI-Anwendungen zu verbessern. Hier ist ein Beispiel, das zeigt, wie man eine einfache Menüleiste erstellt:

import tkinter as tk
from tkinter import Menu

def do_something():
    label.config(text="Menu Item Clicked")

root = tk.Tk()
root.title("Menu Example")

# 创建菜单栏
menu_bar = Menu(root)
root.config(menu=menu_bar)

# 创建菜单
file_menu = Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="File", menu=file_menu)
file_menu.add_command(label="New", command=do_something)
file_menu.add_command(label="Open", command=do_something)
file_menu.add_separator()
file_menu.add_command(label="Exit", command=root.quit)

# 添加标签
label = tk.Label(root, text="Menu Example")
label.pack()

root.mainloop()

In diesem Beispiel erstellen wir eine Menüleiste ( menu_bar) und fügen der Menüleiste ein Menü namens „Datei“ hinzu ( file_menu). Das Menü enthält einige Menüelemente. Jedes Menüelement verfügt über einen entsprechenden Befehl ( command), und wenn auf das Menüelement geklickt wird, wird die entsprechende Funktion ausgelöst.

Durch die Erstellung mehrerer Fenster und das Hinzufügen von Menüleisten können Sie komplexere und funktionsreichere GUI-Anwendungen implementieren, die Benutzern eine einfache Bedienung und Interaktion ermöglichen.

3.4.3 Erstellen einer scrollbaren Oberfläche

In Tkinter können Sie mithilfe von Bildlaufleisten (Scrollbar) eine scrollbare Oberfläche implementieren, insbesondere wenn der Inhalt den sichtbaren Bereich überschreitet. Hier ist ein Beispiel, das zeigt, wie man eine scrollbare Schnittstelle in einer Tkinter-Anwendung erstellt:

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Scrollable Interface Example")

# 创建滚动条
scrollbar = tk.Scrollbar(root)
scrollbar.pack(side="right", fill="y")

# 创建文本框并绑定滚动条
text = tk.Text(root, yscrollcommand=scrollbar.set)
text.pack(side="left", fill="both", expand=True)

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

# 添加大量文本
for i in range(100):
    text.insert("end", f"Line {i}\n")

root.mainloop()

In diesem Beispiel erstellen wir ein Textfeld ( text) und verknüpfen es mit einer vertikalen Bildlaufleiste ( scrollbar), um zu scrollen, wenn der Textinhalt den sichtbaren Bereich des Textfelds überschreitet. Durch Setzen des Parameters der Bildlaufleiste commandauf text.yviewwird die Verknüpfung zwischen der Bildlaufleiste und dem Textfeld realisiert.

Sie können der scrollbaren Benutzeroberfläche nach Bedarf verschiedene Arten von Komponenten hinzufügen, sodass Benutzer große Mengen an Inhalten durchsuchen und anzeigen können, ohne zu viel Platz auf der Benutzeroberfläche zu beanspruchen.

3.5 Grafiken und Bilder

3.5.1 Grundlegende Grafiken in der GUI zeichnen

Komponenten können Canvaszum Zeichnen von Grafiken in der GUI verwendet werden.

canvas = tk.Canvas(root, width=200, height=200)
canvas.pack()
canvas.create_rectangle(50, 50, 150, 150, fill="blue")

3.5.2 Bilddateien anzeigen

PILZur Anzeige von Bilddateien in Tkinter kann eine Bibliothek verwendet werden .

from PIL import Image, ImageTk

image = Image.open("image.png")
photo = ImageTk.PhotoImage(image)
label = tk.Label(root, image=photo)
label.pack()

3.5.3 Diagramm- und Zeichenwerkzeuge

In GUI-Anwendungen können Diagramme, Grafiken und Datenvisualisierungen mithilfe von Zeichenwerkzeugen erstellt werden. Tkinter selbst verfügt nicht über integrierte leistungsstarke Zeichenwerkzeuge, Sie können jedoch andere Bibliotheken kombinieren, um Zeichen- und Diagrammfunktionen zu erhalten. Im Folgenden werden einige häufig verwendete Zeichnungsbibliotheken und Beispiele vorgestellt.

Matplotlib: ist eine weit verbreitete Plotbibliothek zum Erstellen verschiedener Arten von Diagrammen und Grafiken in Python. Es bietet eine Fülle von Zeichenfunktionen, darunter Liniendiagramme, Streudiagramme, Histogramme, Kreisdiagramme usw. Mit Matplotlib können Sie einen Zeichenbereich in eine Tkinter-Anwendung einbetten, um Diagramme in einer GUI-Oberfläche anzuzeigen.
Plotly : zum Erstellen interaktiver Diagramme und Visualisierungen.
Seaborn : Basierend auf Matplotlib, wird zur Erstellung statistischer Diagramme und Datenvisualisierung verwendet.
Kissen : für Bildbearbeitung und Zeichnen.

Sie können entsprechend den Projektanforderungen ein geeignetes Zeichenwerkzeug auswählen und Diagramme und Visualisierungen in Tkinter-Anwendungen einbetten, um eine Datenanzeige und eine interaktive Datenanalyse zu erreichen.

3.6 Interaktive Elemente

3.6.1 Tabellen und Listen erstellen

Mit Komponenten können TreeviewTabellen und Listen erstellt werden.

tree = ttk.Treeview(root, columns=("Name", "Age"))
tree.heading("#1", text="Name")
tree.heading("#2", text="Age")
tree.insert("", "end", values=("Alice", 25))
tree.pack()

3.6.2 Verwendung von Bildlaufleisten und Schiebereglern

Scrollbars und Slider können Scrollbarüber Komponenten hinzugefügt werden.

scrollbar = tk.Scrollbar(root)
scrollbar.pack(side="right", fill="y")

listbox = tk.Listbox(root, yscrollcommand=scrollbar.set)
for i in range(50):
    listbox.insert("end", "Item " + str(i))
listbox.pack(side="left", fill="both")

scrollbar.config(command=listbox.yview)

3.6.3 Kontrollkästchen, Optionsfelder usw. erstellen

Kontrollkästchen und Optionsfelder können mit Checkbuttonund erstellt werden Radiobutton.

check_var = tk.IntVar()
checkbox = tk.Checkbutton(root, text="Check me", variable=check_var)
checkbox.pack()

radio_var = tk.StringVar()
radio_button1 = tk.Radiobutton(root, text="Option 1", variable=radio_var, value="option1")
radio_button2 = tk.Radiobutton(root, text="Option 2", variable=radio_var, value="option2")
radio_button1.pack()
radio_button2.pack()

In Tkinter können Sie Optionen über Komponenten wie Kontrollkästchen (Checkbutton) und Optionsfelder (Radiobutton) auswählen. Hier ist ein Beispielcode, der zeigt, wie Kontrollkästchen und Optionsfelder erstellt werden:

Beispiel zum Erstellen eines Kontrollkästchens:

import tkinter as tk
from tkinter import ttk

def show_selection():
    selected_items = []
    for var, text in zip(check_vars, check_texts):
        if var.get():
            selected_items.append(text)
    selection_label.config(text="Selected Items: " + ", ".join(selected_items))

root = tk.Tk()
root.title("Checkboxes Example")

check_texts = ["Option 1", "Option 2", "Option 3"]
check_vars = [tk.IntVar() for _ in check_texts]

for i, text in enumerate(check_texts):
    check = ttk.Checkbutton(root, text=text, variable=check_vars[i])
    check.pack()

selection_button = ttk.Button(root, text="Show Selection", command=show_selection)
selection_button.pack()

selection_label = tk.Label(root, text="")
selection_label.pack()

root.mainloop()

In diesem Beispiel erstellen wir drei Kontrollkästchen ( check) und IntVarbinden den Status der Kontrollkästchen mit Wenn der Benutzer ein Kontrollkästchen aktiviert oder deaktiviert, IntVarändert sich der entsprechende Wert. Durch Iterieren über all IntVarkönnen wir die vom Benutzer ausgewählten Optionen erhalten.

Beispiel für die Erstellung von Optionsfeldern:

import tkinter as tk
from tkinter import ttk

def show_selection():
    selected_item = radio_var.get()
    selection_label.config(text="Selected Item: " + selected_item)

root = tk.Tk()
root.title("Radiobuttons Example")

radio_texts = ["Option 1", "Option 2", "Option 3"]
radio_var = tk.StringVar()

for text in radio_texts:
    radio = ttk.Radiobutton(root, text=text, variable=radio_var, value=text)
    radio.pack()

selection_button = ttk.Button(root, text="Show Selection", command=show_selection)
selection_button.pack()

selection_label = tk.Label(root, text="")
selection_label.pack()

root.mainloop()

4 Übung: Erstellen Sie eine einfache Taschenrechner-GUI-Anwendung

Hier ist ein Beispielcode zum Erstellen einer einfachen Taschenrechner-GUI-Anwendung mit Tkinter:

import tkinter as tk

# 定义按钮点击事件
def button_click(number):
    current = entry.get()
    entry.delete(0, tk.END)
    entry.insert(0, current + str(number))

def clear():
    entry.delete(0, tk.END)

def calculate():
    try:
        result = eval(entry.get())
        entry.delete(0, tk.END)
        entry.insert(0, str(result))
    except:
        entry.delete(0, tk.END)
        entry.insert(0, "Error")

# 创建主窗口
root = tk.Tk()
root.title("Simple Calculator")

# 创建文本框
entry = tk.Entry(root, font=("Helvetica", 16))
entry.grid(row=0, column=0, columnspan=4)

# 创建按钮
buttons = [
    ("7", 1, 0), ("8", 1, 1), ("9", 1, 2), ("/", 1, 3),
    ("4", 2, 0), ("5", 2, 1), ("6", 2, 2), ("*", 2, 3),
    ("1", 3, 0), ("2", 3, 1), ("3", 3, 2), ("-", 3, 3),
    ("0", 4, 0), (".", 4, 1), ("=", 4, 2), ("+", 4, 3),
]

for (text, row, col) in buttons:
    button = tk.Button(root, text=text, font=("Helvetica", 16), command=lambda t=text: button_click(t))
    button.grid(row=row, column=col, sticky="nsew")

# 清除按钮和等号按钮单独处理
clear_button = tk.Button(root, text="C", font=("Helvetica", 16), command=clear)
clear_button.grid(row=5, column=0, columnspan=2, sticky="nsew")

equal_button = tk.Button(root, text="=", font=("Helvetica", 16), command=calculate)
equal_button.grid(row=5, column=2, columnspan=2, sticky="nsew")

# 设置网格布局权重
for row in range(5):
    root.grid_rowconfigure(row, weight=1)
for col in range(4):
    root.grid_columnconfigure(col, weight=1)

# 启动主循环
root.mainloop()

Die Ausgabe ist wie folgt: