[100 Tage Python-Kenntnisse] Tag 36: GUI-Schnittstellenprogrammierung_Tkinter erweiterte Funktionsoperationen und Beispiele

Inhaltsverzeichnis

 Spaltenführer 

1. Erweiterte GUI-Funktionen

1 Passen Sie Themen und Stile an

2 Implementieren Sie die Drag-and-Drop-Funktion

 3 Multithreading und asynchrone Programmierung

2. Praktische Projekte

1. To-do-Bewerbung

2. Bildbetrachter

3. Texteditor

4 Animationen und Übergänge hinzufügen

 5 Multi-Interface- und Multi-Threading-Beispiel  

---

 Spaltenführer 

Adresse des Kolumnenabonnements: https://blog.csdn.net/qq_35831906/category_12375510.html

---

1. Erweiterte GUI-Funktionen

1 Passen Sie Themen und Stile an

        Benutzerdefinierte Designs und Stile können Ihrer GUI-Anwendung ein großartiges Aussehen verleihen. Sie können Bibliotheken verwenden, um bei der Verwendung von Tkinter ttkthemesverschiedene Themen und Stile anzuwenden .

pip install ttkthemes

Probieren Sie als Nächstes den folgenden Beispielcode aus, um verschiedene Themen und Stile anzuwenden: 

import tkinter as tk
from tkinter import ttk
from ttkthemes import ThemedStyle

def change_theme():
    selected_theme = theme_var.get()
    style.set_theme(selected_theme)

root = tk.Tk()
root.title("Custom Theme Example")

style = ThemedStyle(root)

# 创建一个下拉框，用于选择主题
theme_var = tk.StringVar()
theme_var.set(style.theme_use())  # 默认选中当前主题

theme_dropdown = ttk.Combobox(root, textvariable=theme_var, values=style.theme_names())
theme_dropdown.pack()

# 创建一个按钮，用于应用选定的主题
apply_button = ttk.Button(root, text="Apply Theme", command=change_theme)
apply_button.pack()

label = ttk.Label(root, text="Custom Theme Example")
label.pack(padx=20, pady=20)

root.mainloop()

Der Ausgabeeffekt ist wie folgt: 

        In diesem Beispiel erstellen wir eine Dropdown-Box, die es dem Benutzer ermöglicht, ein anderes Thema auszuwählen. Wenn der Benutzer ein Thema auswählt und auf die Schaltfläche „Thema anwenden“ klickt, wendet die Anwendung die entsprechenden Stile entsprechend dem ausgewählten Thema an.

        Wenn Sie die verschiedenen Designeffekte nach der Ausführung dieses Beispiels immer noch nicht sehen können, stellen Sie bitte sicher, dass sowohl Ihr Betriebssystem als auch Ihre Python-Umgebung die „ttkthemes“-Bibliothek ordnungsgemäß unterstützen. Manchmal funktionieren bestimmte Themen in bestimmten Umgebungen möglicherweise nicht richtig. In diesem Fall können Sie versuchen, das Beispiel in einer anderen Umgebung auszuführen, um zu sehen, ob die verschiedenen Designs korrekt angezeigt werden.

2 Implementieren Sie die Drag-and-Drop-Funktion

        Mit der Drag-and-Drop-Funktion können Benutzer ein Steuerelement von einem Ort an einen anderen ziehen. Hier ist ein Beispiel für Drag & Drop mit Tkinter:

import tkinter as tk

def on_drag_start(event):
    event.widget.start_x = event.x
    event.widget.start_y = event.y

def on_drag_motion(event):
    delta_x = event.x - event.widget.start_x
    delta_y = event.y - event.widget.start_y
    event.widget.place(x=event.widget.winfo_x() + delta_x, y=event.widget.winfo_y() + delta_y)
    event.widget.start_x = event.x
    event.widget.start_y = event.y

root = tk.Tk()

label = tk.Label(root, text="Drag me!")
label.place(x=50, y=50)
label.bind("<Button-1>", on_drag_start)
label.bind("<B1-Motion>", on_drag_motion)

root.mainloop()

Die Ausgabe ist wie folgt: 

 3 Multithreading und asynchrone Programmierung

         Bei der GUI-Programmierung sind Multithreading und asynchrone Programmierung von entscheidender Bedeutung, um eine reaktionsfähige und reibungslose Anwendungsschnittstelle sicherzustellen. Verwenden Sie Multithreading, um zeitaufwändige Vorgänge im Hintergrund abzuwickeln, und asynchrone Programmierung, um in einigen Fällen ein Blockieren der Benutzeroberfläche zu vermeiden. Lassen Sie mich diese beiden Konzepte im Detail erläutern und Beispielcode für Sie bereitstellen.

Multithreading

threadingMultithreading kann in Python-Anwendungen         mithilfe von Modulen erreicht werden. Dies ist nützlich, um einige zeitaufwändige Vorgänge (z. B. Netzwerkanfragen oder Berechnungen) im Hintergrund auszuführen, um die GUI-Schnittstelle nicht zu blockieren.

Das Folgende ist ein Beispiel für die Verwendung eines threadingModuls, bei dem ein Thread den Etiketteninhalt auf der GUI-Schnittstelle aktualisiert:

import tkinter as tk
import threading
import time

def update_label():
    for i in range(100):
        label.config(text=f"Count: {i}")
        time.sleep(1)

root = tk.Tk()

label = tk.Label(root, text="Count: 0")
label.pack()

thread = threading.Thread(target=update_label)
thread.start()

root.mainloop()

 Die Ausgabe ist wie folgt:

         In diesem Beispiel erstellen wir einen neuen Thread, um den Inhalt des Labels zu aktualisieren, ohne die GUI-Ereignisschleife im Hauptthread zu blockieren.

 asynchrone Programmierung

        Die Verwendung asynciovon Modulen ermöglicht die asynchrone Programmierung in Python-Anwendungen und ermöglicht so eine bessere Handhabung gleichzeitiger Aufgaben. Die asynchrone Programmierung eignet sich für Situationen, in denen Sie auf den Abschluss von E/A-Vorgängen (z. B. Netzwerkanforderungen) warten müssen.

        Hier ist ein einfaches Beispiel für die Verwendung eines asyncioModuls, bei dem eine Coroutine eine Weile wartet und dann eine Bezeichnung auf der GUI aktualisiert:

import tkinter as tk
import asyncio

async def update_label():
    for i in range(10):
        label.config(text=f"Count: {i}")
        await asyncio.sleep(1)

root = tk.Tk()

label = tk.Label(root, text="Count: 0")
label.pack()

async def main():
    await update_label()

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

root.mainloop()

        In diesem Beispiel verwenden wir asyncioModule, um eine Coroutine zu erstellen, und verwenden dann eine asynchrone Ereignisschleife, um die Coroutine auszuführen.

        Beachten Sie, dass GUI-Frameworks wie Tkinter möglicherweise einige Einschränkungen hinsichtlich Multithreading und asynchroner Programmierung haben. Stellen Sie sicher, dass Sie bei der Multithread- oder asynchronen Programmierung die relevanten Regeln und Best Practices des Frameworks befolgen, um potenzielle Probleme zu vermeiden.

        Sowohl Multithreading als auch asynchrone Programmierung sollen reaktionsfähige und flüssige GUI-Anwendungen gewährleisten, sodass Sie Aufgaben im Hintergrund ausführen können, ohne die Benutzeroberfläche zu blockieren.

2. Praktische Projekte

1. To-do-Bewerbung

Eine einfache To-Do-Listen-App ermöglicht es Benutzern, Aufgaben hinzuzufügen, zu bearbeiten und zu löschen und sie auf der Benutzeroberfläche anzuzeigen. Hier ist ein Tkinter-basiertes Beispiel:

import tkinter as tk
from tkinter import messagebox

def add_task():
    task = entry.get()
    if task:
        tasks_listbox.insert(tk.END, task)
        entry.delete(0, tk.END)
    else:
        messagebox.showwarning("Warning", "Please enter a task.")

def delete_task():
    selected_task = tasks_listbox.curselection()
    if selected_task:
        tasks_listbox.delete(selected_task)

root = tk.Tk()
root.title("To-Do List")

entry = tk.Entry(root)
entry.pack()

add_button = tk.Button(root, text="Add Task", command=add_task)
add_button.pack()

delete_button = tk.Button(root, text="Delete Task", command=delete_task)
delete_button.pack()

tasks_listbox = tk.Listbox(root)
tasks_listbox.pack()

root.mainloop()

 Ausgabe:

2. Bildbetrachter

Mit einem einfachen Bildbetrachter können Benutzer Bilddateien öffnen und anzeigen. Hier ist ein Tkinter-basiertes Beispiel:

import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

def open_image():
    file_path = filedialog.askopenfilename(filetypes=[("Image files", "*.png *.jpg *.jpeg")])
    if file_path:
        image = Image.open(file_path)
        photo = ImageTk.PhotoImage(image)
        label.config(image=photo)
        label.photo = photo

root = tk.Tk()
root.title("Image Viewer")

open_button = tk.Button(root, text="Open Image", command=open_image)
open_button.pack()

label = tk.Label(root)
label.pack()

root.mainloop()

3. Texteditor

Mit einem einfachen Texteditor können Benutzer Textdateien öffnen, bearbeiten und speichern. Hier ist ein Tkinter-basiertes Beispiel:

import tkinter as tk
from tkinter import filedialog

def open_file():
    file_path = filedialog.askopenfilename(filetypes=[("Text files", "*.txt")])
    if file_path:
        with open(file_path, "r") as file:
            text.delete("1.0", tk.END)
            text.insert(tk.END, file.read())

def save_file():
    file_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files", "*.txt")])
    if file_path:
        with open(file_path, "w") as file:
            file.write(text.get("1.0", tk.END))

root = tk.Tk()
root.title("Text Editor")

open_button = tk.Button(root, text="Open File", command=open_file)
open_button.pack()

save_button = tk.Button(root, text="Save File", command=save_file)
save_button.pack()

text = tk.Text(root)
text.pack()

root.mainloop()

4 Animationen und Übergänge hinzufügen

        Das Hinzufügen von Animationen und Übergangseffekten in GUI-Anwendungen kann das Benutzererlebnis verbessern und die Anwendung attraktiver machen. Das Folgende ist ein Beispiel, das zeigt, wie man in Tkinter eine einfache GUI-Anwendung erstellt und Animationen und Übergänge hinzufügt.

import tkinter as tk
import time

class AnimatedApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Animated GUI App")

        self.label = tk.Label(root, text="Welcome!", font=("Helvetica", 24))
        self.label.pack(pady=50)

        self.button = tk.Button(root, text="Animate", command=self.animate)
        self.button.pack()

    def animate(self):
        initial_x = self.label.winfo_x()
        target_x = 300  # Target x-coordinate for animation

        while initial_x < target_x:
            initial_x += 5  # Increment x-coordinate
            self.label.place(x=initial_x, y=100)
            self.root.update()  # Update GUI to reflect changes
            time.sleep(0.05)  # Add a short delay for animation effect

        self.label.config(text="Animation Complete!")

root = tk.Tk()
app = AnimatedApp(root)
root.mainloop()

 5 Multi-Interface- und Multi-Threading-Beispiel  

        Der Umgang mit der kombinierten Situation mehrerer Fenster und mehrerer Threads erfordert eine sorgfältige Handhabung, um die Reaktionsfähigkeit der Benutzeroberfläche und die Thread-Sicherheit sicherzustellen. Das folgende Beispiel zeigt, wie man in Tkinter eine Anwendung mit mehreren Fenstern erstellt und mehrere Threads verwendet, um zeitaufwändige Vorgänge auszuführen.

import tkinter as tk
import threading
import time

class MainWindow:
    def __init__(self, root):
        self.root = root
        self.root.title("Multi-Window App")
        self.root.configure(bg="lightblue")  # Set background color

        self.open_button = tk.Button(root, text="Open New Window", command=self.open_new_window)
        self.open_button.pack()

    def open_new_window(self):
        new_window = tk.Toplevel(self.root)
        child_window = ChildWindow(new_window)

class ChildWindow:
    def __init__(self, root):
        self.root = root
        self.root.title("Child Window")
        self.root.configure(bg="lightgreen")  # Set background color

        # Calculate child window position within main window
        main_x = self.root.master.winfo_rootx()
        main_y = self.root.master.winfo_rooty()
        main_width = self.root.master.winfo_width()
        main_height = self.root.master.winfo_height()

        window_width = 300
        window_height = 200

        x_position = main_x + (main_width - window_width) // 2
        y_position = main_y + (main_height - window_height) // 2

        # Ensure the child window is within the main window boundaries
        if x_position < main_x:
            x_position = main_x
        if y_position < main_y:
            y_position = main_y

        self.root.geometry(f"{window_width}x{window_height}+{x_position}+{y_position}")

        self.label = tk.Label(root, text="Child Window", font=("Helvetica", 16), bg="lightgreen", fg="black")  # Set foreground color
        self.label.pack(pady=20)

        self.start_button = tk.Button(root, text="Start Task", command=self.start_task, bg="lightblue")  # Set button color
        self.start_button.pack()

    def start_task(self):
        thread = threading.Thread(target=self.long_running_task)
        thread.start()

    def long_running_task(self):
        self.start_button.config(state=tk.DISABLED)  # Disable the button during task
        for i in range(10):
            print(f"Task running: {i}")
            time.sleep(1)
        self.start_button.config(state=tk.NORMAL)  # Enable the button after task

root = tk.Tk()
app = MainWindow(root)
root.geometry("400x300")  # Set initial main window size

root.mainloop()

        In diesem Beispiel erstellen wir ein Hauptfenster und ein untergeordnetes Fenster. Durch Klicken auf die Schaltfläche „Neues Fenster öffnen“ wird ein neues Unterfenster geöffnet. Im Unterfenster befindet sich die Schaltfläche „Aufgabe starten“. Durch Klicken darauf wird eine Multithread-Aufgabe gestartet (die zeitaufwändige Vorgänge simuliert) und deaktiviert Klicken Sie auf die Schaltfläche, während die Aufgabe ausgeführt wird. Aktivieren Sie die Schaltfläche erneut, wenn die Aufgabe erledigt ist.

Achten Sie auf folgende Punkte:

• ToplevelZum Erstellen untergeordneter Fenster verwenden .
• Verwenden Sie threadingModule, um Multithreading zu implementieren. Die Aufgabe hier ist nur ein einfaches Beispiel für das Warten, in Wirklichkeit kann es sich um jeden zeitaufwändigen Vorgang handeln.
• Da tkinteres nicht Thread-sicher ist, stellen Sie sicher, dass Sie GUI-Elemente im Hauptthread manipulieren und Threads verwenden, um zeitaufwändige Aufgaben auszuführen.

Um Probleme wie Thread-Konflikte und Schnittstelleneinfrierungen zu vermeiden, ist es notwendig, den Lebenszyklus, den Status und die Interaktion der Threads mit der GUI sorgfältig zu verwalten.