Tkinter OptionMenu Tutorial

1 Einführung in Tkinter OptionMenu

OptionMenu in Tkinter erstellt eine Dropdown-Liste, die an eine Variable gebunden ist. Es ist praktisch für Auswahlmöglichkeiten wie Themen, Sprachen oder jede endliche Menge von Optionen. Intern speichert es den ausgewählten Wert in einer Variable und kann eine Funktion aufrufen, wann immer der Benutzer ein neues Element auswählt.

Am Ende dieser Anleitung erstellen Sie eine lauffähige Theme-Selektor-App, die einen Vorschau-Bereich aktualisiert und eine Meldung mit dem ausgewählten Theme anzeigt.

2 Voraussetzungen: Python und Tkinter

Sie benötigen Python 3.7+. Tkinter ist bei den meisten Python-Installationen unter macOS und Windows enthalten. Wenn Sie unter Linux arbeiten, installieren Sie das Paket tk:

# Debian/Ubuntu
sudo apt-get install python3-tk

Überprüfen Sie, ob Tkinter verfügbar ist:

python -m tkinter

Wenn ein kleines Fenster geöffnet wird, funktioniert Tkinter.

3 Minimales OptionMenu: Die Kernstücke

Sie benötigen drei Bausteine: eine Tkinter-Variable (normalerweise StringVar), eine Liste von Optionen und ein OptionMenu, das mit der Variable verbunden ist.

import tkinter as tk

root = tk.Tk()
root.title("Minimal OptionMenu")

# 1) Variable zum Speichern der aktuellen Auswahl
choice = tk.StringVar(value="A")

# 2) Erstellen Sie das OptionMenu und übergeben Sie die Variable und die Optionen
menu = tk.OptionMenu(root, choice, "A", "B", "C")
menu.pack(padx=20, pady=20)

root.mainloop()

StringVar hält den aktuellen Wert synchron mit dem Dropdown.
value="A" setzt den Standardwert; ohne diese Option ist normalerweise die erste Option ausgewählt.
Wenn Sie choice.set("B") aktualisieren, wird die Auswahl des OptionMenu programmatisch geändert.

4 Auf Änderungen reagieren: Callback hinzufügen

Übergeben Sie eine Funktion an das Argument command. Tkinter ruft sie mit dem neu ausgewählten Wert auf.

import tkinter as tk
from tkinter import messagebox

def on_select(value):
    messagebox.showinfo("Auswahl", f"Sie haben gewählt: {value}")

root = tk.Tk()
choice = tk.StringVar(value="Ocean")
menu = tk.OptionMenu(root, choice, "Ocean", "Forest", "Sunset", command=on_select)
menu.pack(padx=20, pady=20)

root.mainloop()

Verwenden Sie Callbacks, um andere Widgets zu synchronisieren, Validierungen auszulösen oder ein Informationsfeld zu aktualisieren.

5 Live-Vorschau erstellen (wie unser Beispiel)

Speichern Sie Theme-Daten und aktualisieren Sie dann einen Vorschau-Bereich, wenn sich die Auswahl ändert.

import tkinter as tk
from tkinter import messagebox

themes = {
    "Ocean": {"primary": "#1a73e8", "secondary": "#4285f4", "text": "white"},
    "Forest": {"primary": "#2e7d32", "secondary": "#4caf50", "text": "white"},
    "Sunset": {"primary": "#d32f2f", "secondary": "#f44336", "text": "white"},
}

def update_preview(theme_name):
    t = themes[theme_name]
    preview.configure(bg=t["primary"])
    title.configure(bg=t["primary"], fg=t["text"])
    button.configure(bg=t["secondary"], fg=t["text"], activebackground=t["primary"], activeforeground=t["text"])

root = tk.Tk()
choice = tk.StringVar(value="Ocean")
menu = tk.OptionMenu(root, choice, *themes.keys(), command=lambda v: update_preview(v))
menu.pack(padx=20, pady=10)

preview = tk.Frame(root, width=220, height=120, relief="raised", bd=2)
preview.pack(pady=10)

title = tk.Label(preview, text="Theme Preview")
title.pack(pady=6)

button = tk.Button(preview, text="OK", command=lambda: messagebox.showinfo("Theme", f"{choice.get()}"))
button.pack(pady=6)

update_preview(choice.get())
root.mainloop()

6 Optionen ändern und Elemente deaktivieren

OptionMenu bietet keine integrierte API zum Hinzufügen/Entfernen. Der übliche Ansatz ist, das Menü mit den aktualisierten Optionen neu zu erstellen und die aktuelle Auswahl beizubehalten.

def rebuild_options(new_options, keep_value=True):
    current = choice.get() if keep_value else new_options[0]
    menu["menu"].delete(0, "end")
    for opt in new_options:
        menu["menu"].add_command(label=opt, command=lambda v=opt: choice.set(v))
    choice.set(current)

# Beginnen Sie mit diesen
choices = ["A", "B", "C"]
choice = tk.StringVar(value="B")

menu = tk.OptionMenu(root, choice, *choices)
menu.pack(padx=20, pady=20)

# Später "B" entfernen
rebuild_options([opt for opt in choices if opt != "B"])

Um ein bestimmtes Element zu deaktivieren, umschließen Sie es in ein Kaskaden-Untermenü und verwenden Sie state="disabled". Das Entfernen oder Neuordnen ist mit einem Neuaufbau einfacher.

7 Styling und Layout: Das Aussehen zähmen

Verwenden Sie configure(width=...), um die Breite zu steuern. Für Schriftarten und Farben setzen Sie Attribute für das Menü und sein internes Menü-Widget. Die Kombination von ttk.Frame mit tk.OptionMenu kann Abstände ordnen.

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
frame = ttk.Frame(root, padding=16)
frame.pack()

choice = tk.StringVar(value="Ocean")
menu = tk.OptionMenu(frame, choice, "Ocean", "Forest", "Sunset")
menu.configure(width=14, font=("Helvetica", 11))
menu["menu"].configure(font=("Helvetica", 11))

ttk.Label(frame, text="Wählen Sie ein Theme:").pack(anchor="w", pady=(0, 6))
menu.pack(anchor="w")

root.mainloop()

8 Häufige Fallstricke und Stolpersteine

Wenn Sie keinen Anfangswert festlegen, kann dies zu einer leeren Auswahl führen.
Callbacks erhalten den neuen Wert, nicht die Variable. Verwenden Sie die Variable, wenn Sie einen breiteren Zustand benötigen.
OptionMenu hat keine direkte API zum „Entfernen von Optionen“ – erstellen Sie neu über das innere menu Widget.
Das Mischen von tk und ttk kann zu subtilen Stilunterschieden führen.
Auf einigen Systemen hat das Ändern von Schriftarten im inneren Menü aufgrund der plattformspezifischen Darstellung keine Auswirkung.

9 Übung: Optionen hinzufügen und entfernen

Erweitern Sie das minimale Beispiel: Fügen Sie ein Eingabefeld und eine Schaltfläche hinzu, die die eingegebene Option in das Menü einfügt (falls nicht vorhanden) und sie auswählt. Fügen Sie dann eine weitere Schaltfläche hinzu, um die aktuell ausgewählte Option zu entfernen.

import tkinter as tk

root = tk.Tk()
choice = tk.StringVar(value="A")
options = ["A", "B", "C"]

menu = tk.OptionMenu(root, choice, *options)
menu.pack(padx=16, pady=16)

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

def add_option():
    val = entry.get().strip()
    if not val or val in options:
        return
    options.append(val)
    menu["menu"].add_command(label=val, command=lambda v=val: choice.set(val))
    choice.set(val)

def remove_selected():
    val = choice.get()
    if val not in options:
        return
    options.remove(val)
    rebuild_options()

tk.Button(root, text="Hinzufügen", command=add_option).pack(pady=6)
tk.Button(root, text="Ausgewähltes entfernen", command=remove_selected).pack(pady=6)

def rebuild_options():
    current = choice.get()
    menu["menu"].delete(0, "end")
    for opt in options:
        menu["menu"].add_command(label=opt, command=lambda v=opt: choice.set(v))
    if options:
        choice.set(current if current in options else options[0])

root.mainloop()

10 Vollständiges Projekt: Theme-Selektor mit Vorschau

Kopieren Sie dies in eine Datei namens theme_selector.py und führen Sie es mit python theme_selector.py aus.

import tkinter as tk
from tkinter import ttk
from tkinter import messagebox

class ColorThemeSelector(tk.Tk):
    def __init__(self):
        super().__init__()

        # Konfigurieren Sie das Hauptfenster
        self.title("OptionMenu Beispiel")
        self.geometry("400x300")
        self.configure(padx=20, pady=20)

        # Definieren Sie Farbschemata
        self.color_themes = {
            "Ocean": {"primary": "#1a73e8", "secondary": "#4285f4", "text": "white"},
            "Forest": {"primary": "#2e7d32", "secondary": "#4caf50", "text": "white"},
            "Sunset": {"primary": "#d32f2f", "secondary": "#f44336", "text": "white"},
            "Lavender": {"primary": "#7b1fa2", "secondary": "#9c27b0", "text": "white"}
        }

        # Erstellen und konfigurieren Sie einen Frame
        self.main_frame = ttk.Frame(self)
        self.main_frame.pack(expand=True, fill='both')

        # Erstellen Sie eine StringVar zum Speichern der ausgewählten Option
        self.selected_theme = tk.StringVar()
        self.selected_theme.set("Ocean")  # Setzen Sie den Standardwert

        # Erstellen Sie ein Label
        self.label = ttk.Label(
            self.main_frame,
            text="Wählen Sie Ihr Farbschema:",
            font=('Helvetica', 12)
        )
        self.label.pack(pady=10)

        # Erstellen Sie das OptionMenu
        self.theme_menu = tk.OptionMenu(
            self.main_frame,
            self.selected_theme,
            *self.color_themes.keys(),
            command=self.update_preview
        )
        self.theme_menu.configure(width=15)
        self.theme_menu.pack(pady=10)

        # Erstellen Sie einen Vorschaufenster
        self.preview_frame = tk.Frame(
            self.main_frame,
            width=200,
            height=100,
            relief="raised",
            bd=2
        )
        self.preview_frame.pack(pady=20)

        # Erstellen Sie Vorschau-Elemente
        self.preview_title = tk.Label(
            self.preview_frame,
            text="Theme Vorschau",
            font=('Helvetica', 10)
        )
        self.preview_title.pack(pady=5)

        self.preview_button = tk.Button(
            self.preview_frame,
            text="Beispiel-Schaltfläche",
            command=self.show_selection
        )
        self.preview_button.pack(pady=10)

        # Initialisieren Sie die Vorschau
        self.update_preview()

    def update_preview(self, *args):
        """Aktualisieren Sie den Vorschaufenster mit den ausgewählten Theme-Farben"""
        theme = self.color_themes[self.selected_theme.get()]
        
        # Aktualisieren Sie den Hintergrund des Vorschaufensters
        self.preview_frame.configure(bg=theme["primary"])
        self.preview_title.configure(
            bg=theme["primary"],
            fg=theme["text"]
        )
        self.preview_button.configure(
            bg=theme["secondary"],
            fg=theme["text"],
            activebackground=theme["primary"],
            activeforeground=theme["text"]
        )

    def show_selection(self):
        """Zeigen Sie ein Nachrichtenfeld mit der aktuellen Auswahl an"""
        messagebox.showinfo(
            "Ausgewähltes Theme",
            f"Sie haben das {self.selected_theme.get()} Theme ausgewählt!"
        )

if __name__ == "__main__":
    app = ColorThemeSelector()
    app.mainloop()

Führen Sie es aus: python theme_selector.py. Versuchen Sie, Themes zu wechseln – beobachten Sie, wie sich die Vorschau in Echtzeit aktualisiert.