Label

Das Label-Widget von Tkinter bildet die Basis vieler grafischer Oberflächen: Es präsentiert Texte, Icons oder Bilder und strukturiert Informationen übersichtlich. Der Artikel erläutert, wie Labels vielfältig eingesetzt, an Designs angepasst und mithilfe von Variablen oder Styles dynamisiert werden können – inklusive praktischer Beispiele für feststehende Beschriftungen, Statusanzeigen und Layout-Helfer.

Inhaltsverzeichnis

Was ist ein Label?

Ein Label ist das wahrscheinlich am häufigsten verwendete Widget in Tkinter. Es dient zur Anzeige von Text, Bildern oder beidem - aber ist nicht interaktiv (der Nutzer kann nicht darauf klicken oder es bearbeiten). Wobei klicken kann man darauf und bestimmte Aktionen ausführen lassen. Ist aber nicht ein typisches Element dafür.

Man kann sich Label vorstellen wie:

Ein Schild mit Text an einem Geschäft
Ein Foto an der Wand
Eine Überschrift in einem Dokument
Eine Statusanzeige irgendwo im Programm

Label-Parameter

Wichtigste Label-Parameter

Text & Inhalt

Parameter	Typ	Beschreibung	Beispiel	Hinweise
`text`	str	Anzuzeigender Text	`text="Hallo"`	Kann Zeilenumbrüche enthalten (‘\n’)
`textvariable`	Variable	StringVar für dynamischen Text	`textvariable=var`	Text ändert sich automatisch mit Variable
`image`	PhotoImage	Anzuzeigendes Bild	`image=photo`	Referenz muss erhalten bleiben!
`bitmap`	str	Eingebautes Bitmap	`bitmap="info"`	Built-in: error, info, question, warning, etc.
`compound`	str	Text+Bild Position	`compound="left"`	Werte: left, right, top, bottom, center

Schrift und Farbe

Parameter	Typ	Beschreibung	Beispiel	Hinweise
`font`	tuple/str	Schriftart	`font=("Arial", 12, "bold")`	Format: (Familie, Größe, Stil)
`fg` / `foreground`	str	Textfarbe	`fg="blue"`	Farbe als Name oder Hex (#0000FF)
`bg` / `background`	str	Hintergrundfarbe	`bg="yellow"`	Transparent nicht möglich

Größe und Position

Parameter	Typ	Beschreibung	Beispiel	Hinweise
`width`	int	Breite in Zeichen	`width=20`	Bei Bild: Pixel
`height`	int	Höhe in Zeilen	`height=3`	Bei Bild: Pixel
`anchor`	str	Textposition im Widget	`anchor="w"`	Werte: n, ne, e, se, s, sw, w, nw, center
`justify`	str	Mehrzeiliger Text	`justify="left"`	Werte: left, center, right

Label - Text & Inhalt

`text` Parameter

Schauen wir einfache Beispiel zu diesen Parametern an. Fangen wir an mit dem text Parameter.

            Beispiel - text
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x400")

label_one = tk.Label(
    master=root,
    text="Ich bin ein Label"
)
label_one.pack(pady=20, padx=20)

root.mainloop()

Tkinter - Label Parameter - text

`textvariable` Parameter

Im nächsten Beispiel sehen wir uns textvariable Parameter an. Da dieser Parameter für eine dynamisch Aktualisierung des Wertes verwendet wird, brauchen wir auch noch einen Button, mit welchem wir die Aktualisierung auslösen.

            Beispiel - textvariable
        
import tkinter as tk


def click_handler():
    label_one_value.set("Neuer Label-Text")


root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x400")

label_one_value = tk.StringVar(value="Initialer Wert")
label_one = tk.Label(
    master=root,
    textvariable=label_one_value
)
label_one.pack(pady=20, padx=20)

button_one = tk.Button(
    master=root,
    text="Label text ändern",
    command=click_handler
)
button_one.pack(pady=20, padx=20)

root.mainloop()

Wie wir hier sehen können, lässt sich beim Klick auf den Button der Wert des Labels mit Hilfe von textvariable ändern.

Tkinter - Label Parameter - textvariable (1)

Vor dem Klick

Tkinter - Label Parameter - textvariable (2)

Nach dem Klick

`image` Parameter

Im nächsten Beispiel sehen wir uns image Parameter an. Dafür werden wir in dem Ordner, in welchem wir das Programm ausführen (schreiben), ein Bild ablegen, das wir verwenden werden.

In meinem Fall habe ich das Bild mit einem Zahnrad wheel.png in meinem Projekt-Ordner abgelegt. Es würde auch meinem absoluten Pfad zum Bild funktionieren, wenn es gelesen werden kann. Es ist allerdings einfacher das Bild direkt im Ordner abzulegen. Das empfehle ich euch auch.

            Beispiel - image
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x300")

my_img = tk.PhotoImage(file="./wheel.png")

label_one = tk.Label(
    master=root,
    image=my_img
)
label_one.pack()

root.mainloop()

Als Ergebnis kriegen wir ein Programm, in welchem unser Bild direkt angezeigt wird.

Tkinter - Label Parameter - image

Wichtige Information

Bei Verwendung von PhotoImage müssen PhotoImage-Objekte eine Referenz behalten, also auf eine Variable verweisen, das sonst sie durch Garbage Collection aufgeräumt/eleminiert werden.

Hier fast das gleiche Beispiel mit einer kleinen Anpassung. In diesem Beispiel wird PhotoImage direkt am Parameter verwendet. Also kein Verweis auf eine Variable.

            Beispiel - image
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x300")

label_one = tk.Label(
    master=root,
    image=tk.PhotoImage(file="./wheel.png")
)
label_one.pack()

root.mainloop()

Und wenn wir diesen Code ausführen, stellen wir fest, dass gar kein Bild angezeigt wird. Dies verdeutlicht die Wichtigkeit einer Referenz auf ein PhotoImage Objekt.

Tkinter - Label Parameter - image - Fehlende Referenz

`bitmap` Parameter

Das nächste Beispiel zeigt den bitmap Parameter. Tkinter hat dabei einige eingebaute Bitmaps. Man kann aber auch eigene Bitmaps verwenden. Hier schauen wir uns an, wie man die eingebaute Bitmaps verwendet.

            Beispiel - bitmap
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x500")

bitmaps = [
    "error",
    "info",
    "question",
    "warning",
    "hourglass",
    "gray12",
    "gray25",
    "gray50",
    "gray75"
]


for b in bitmaps:
    tk.Label(
        master=root,
        bitmap=b,
        fg="#246990",
    ).pack(pady=10)


root.mainloop()

Tkinter - Label Parameter - bitmap

`compound` Parameter

Und noch ein Parameter - compound, steuert die Anordnung von Text und Bild (egal ob image= oder bitmap=) im selben Label.

Der Parameter compound kann folgende Werte haben:

left: Bild links, Text rechts
right: Bild rechts, Text links
top: Bild oben, Text unten
bottom: Bild unten, Text oben
center: Bild über dem Text, Text wird über das Bild gelegt
none: Standard - Bild oder Text (nicht beides)

Hier ein Beispiel mit left.

            Beispiel - compound
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x300")

my_img = tk.PhotoImage(width=32, height=32)
my_img.put(("#246990",), to=(0, 0, 31, 31))

label = tk.Label(
    master=root,
    text="Hallo",
    image=my_img,
    compound="left",
    padx=10,
    font=("Arial", 14)
)
label.pack(pady=10)

root.mainloop()

Tkinter - Label Parameter - compound

Label - Schrift und Farbe

Im nächsten Abschnitt schauen wir uns Parameter an, welche für Schrift und Farbe zuständig sind.

`font` Parameter

Mit diesem Parameter kann man die Schriftart steuern. Die Größe, die Art und den Typ.

            Beispiel - font
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x300")

label_one = tk.Label(
    master=root,
    text="Normale Schrift"
).pack(pady=10, padx=10)

label_two = tk.Label(
    master=root,
    text="Benutzerdefinierte Schriftart",
    font=("Courier New", 16)
).pack(pady=10, padx=10)

label_three = tk.Label(
    master=root,
    text="Fette Schriftart",
    font=("Courier New", 16, "bold")
).pack(pady=10, padx=10)

label_four = tk.Label(
    master=root,
    text="Große Schriftart",
    font=("Noto Sans", 22)
).pack(pady=10, padx=10)

root.mainloop()

Tkinter - Label Parameter - font

`fg`/`foreground` Parameter

Dieser Parameter ist dafür verantwortlich die Schriftfarbe zu bestimmen.

            Beispiel - fg
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x300")

my_font=("Noto Sans", 16, "bold")

font_colors = [
    ("Farbe eins", "#2c733f",),
    ("Farbe zwei", "#15888c",),
    ("Farbe drei", "#50287a",),
    ("Farbe vier", "#9e7034")
]

for font_color in font_colors:
    tk.Label(
        master=root,
        text=font_color[0],
        font=my_font,
        fg=font_color[1]
    ).pack(pady=10, padx=10)

root.mainloop()

Wie man hier sehen kann, wird die Schrift im Label jeweils in einer anderen, von uns definierten Schrift-Farbe dargestellt.

Tkinter - Label Parameter - fg/foreground

`bg`/`background` Parameter

Analog zu fg, kann man auch den Parameter bg oder background verwenden. Dabei kann man entweder namentliche Farben oder Hex-Code einsetzen.

            Beispiel - bg
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x300")

my_font=("Noto Sans", 16)

font_colors = [
    ("Farbe eins", "#2c733f",),
    ("Farbe zwei", "#15888c",),
    ("Farbe drei", "#50287a",),
    ("Farbe vier", "#9e7034")
]

for font_color in font_colors:
    tk.Label(
        master=root,
        text=font_color[0],
        font=my_font,
        bg=font_color[1]
    ).pack(pady=10, padx=10, fill="x")

root.mainloop()

In der Ausgabe haben wir nun die gefärbten Label.

Tkinter - Label Parameter - bg/background

Label - Größe und Position

Weiter im Verlauf. Nun geht es um Größe und Position. Folgende Parameter sind dabei wichtig.

`width` Parameter

Starten wir an diesem Abschnitt mit dem Parameter width.

Die Breite definiert sich folgendermaßen:

Bei Schrift - In zeichen
Bei Bild - In Pixeln

            Beispiel - width
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x100")

my_font=("Noto Sans", 16)

label_one = tk.Label(
    master=root,
    text="Hallo Python",
    width=20,
    bg="lightgray"
)
label_one.pack()

root.mainloop()

In diesem Beispiel bekommt unser Label die Breite von 20, unabhängig davon, wie lang der Text ist. Bei Breite von 20 sollten 20 Zeichen gewählten Schriftart in der Regel in das Label passen.

Tkinter - Label Parameter - width (1)

Wenn wir also nun her gehen und ein paar Werte für den width Parameter vordefinieren, können wir die unterschiedlichen Breiten visuell uns anzeigen lassen.

            Beispiel - width
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x200")

my_font=("Noto Sans", 16)

label_widths = [10, 20, 30]

for lw in label_widths:
    tk.Label(
        master=root,
        text=f"Breite {lw}",
        font=my_font,
        bg="lightgrey",
        width=lw
    ).pack()

root.mainloop()

Tkinter - Label Parameter - width (2)

`height` Parameter

Analog zum width Parameter gibt es den height Parameter. Die Kalkulation in Abhängigkeit von Schrift oder Bild ist die gleiche.

            Beispiel - height
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x200")

my_font=("Noto Sans", 16)

label_one = tk.Label(
    master=root,
    text="Höhe des Labels",
    height=3,
    bg="lightgrey",
    font=my_font
).pack()

root.mainloop()

Tkinter - Label Parameter - height (1)

Nun gehen wir wieder den Weg und definieren ein paar Höhen-Werte vor und lassen und in einer Schleife die Widgets bauen.

            Beispiel - height
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x400")

my_font=("Noto Sans", 16)
my_heights = [1, 2, 3]

for h in my_heights:
    tk.Label(
        master=root,
        text="Höhe des Labels",
        font=my_font,
        bg="lightgrey",
        height=h
    ).pack(pady=5)

root.mainloop()

Wie man sehen kann, erhöht sich die Höhe des Labels entsprechend dem aktuellen Schleifen-Wert.

Tkinter - Label Parameter - height (2)

`anchor` Parameter

Schauen wir uns den Parameter anchor genauer an. anchor bestimmt, wo der Text innerhalb des Widget-Bereichs positioniert wird.

Folgendes Schema kann man sich hierbei zur Hilfe ziehen.

            Anchor-Positionen
        
   nw     n     ne
    \     |     /
     \    |    /
      +-------+
w --> |center | --> e
      +-------+
     /    |    \
    /     |     \
   sw     s     se

Die 9 Anchor-Werte bedeuten dabei folgendes.

Wert	Position
`n`	oben (north)
`ne`	oben rechts
`e`	rechts
`se`	unten rechts
`s`	unten
`sw`	unten links
`w`	links
`nw`	oben links
`center`	mittig (Standard)

Wir starten mit einem minimalen Beispiel und versuchen den Text in einem Label rechts auszurichten. Wie wir aus der Tabelle entnehmen können, benötigen wir e, um etwas im Label nach rechts auszurichten.

            Beispiel - anchor
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x200")

my_font = ("Noto Sans Mono", 16, "bold")

label = tk.Label(
    master=root,
    text="Hallo",
    width=20,
    height=5,
    anchor="e",
    bg="#246990",
    fg="white",
    font=my_font
)
label.pack()

root.mainloop()

Tkinter - Label Parameter - anchor - e

`justify` Parameter

Als Nächstes werfen wir einen Blick auf den justify Parameter eines Labels.

Was machte justify?

Kontrolliert die Textausrichtung innerhalb jeder Zelle bei mehrzeiligem Text
Wirkt nur bei Text mit Zeilenumbrüchen (\n)
Vergleichbar mit Links-/Rechtsbündigkeit in Word

justify hat drei Modi.

1 justify="left" (Standard)

            Schema - left
        
Dies ist ein sehr langer Text,
der über mehrere Zeilen
verteilt ist.

2 justify="center"

            Schema - center
        
Dies ist ein sehr langer Text,
  der über mehrere Zeilen
      verteilt ist.

3 justify="right"

            Schema - right
        
Dies ist ein sehr langer Text,
       der über mehrere Zeilen
                  verteilt ist.

Ein kleines Beispiel hierzu, in welchem alle drei Modi visuell sichtbar sind.

            Beispiel - left
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("1100x300")

my_font = ("Noto Sans Mono", 12)

my_text = (
    "Das ist ein mehrzeiliger Text,\n"
    "welcher über mehrere Zeilen geht.\n"
    "Das ist alles ein Beispiel."
)

main_frame = tk.Frame(
    master=root
).pack()

label_one = tk.Label(
    master=main_frame,
    text=my_text,
    font=my_font,
    justify="left",
    bg="lightblue"
)
label_one.pack(side="left", padx=5)

label_two = tk.Label(
    master=root,
    text=my_text,
    font=my_font,
    justify="center",
    bg="lightblue"
)
label_two.pack(side="left", padx=5)

label_three = tk.Label(
    master=main_frame,
    text=my_text,
    font=my_font,
    justify="right",
    bg="lightblue"
)
label_three.pack(side="left", padx=5)

root.mainloop()

Tkinter - Label Parameter - justify

Label - Rahmen und Stil

In diesem Abschnitt schauen wir uns an, welche Möglichkeiten uns Tkinter bietet, um Rahmen und Stil unserer Labels zu beeinflussen.

`relief` Parameter

Um die Relief-Stile zu sehen, bauen wir gleich dafür eine App als Beispiel.

            Relief Beispiele
        
import tkinter as tk

root = tk.Tk()
root.title("Relief-Stile")
root.geometry("600x400")

reliefs = [
    "flat",
    "raised",
    "sunken",
    "groove",
    "ridge"
]

tk.Label(
    master=root,
    text="Relief-Stile Übersicht",
    font=("Noto Sans Mono", 16)
).pack(pady=10)

frame = tk.Frame(master=root)
frame.pack(pady=20)

for relief in reliefs:
    tk.Label(
        master=frame,
        text=relief,
        relief=relief,
        borderwidth=3,
        width=15,
        height=3,
        bg="lightblue"
    ).pack(side="left", padx=10)

root.mainloop()

Tkinter - Übersicht von Widget-Reliefs

Was zeigt dieses Beispiel?

Dieses Beispiel demonstriert 5 verschiedenen Relief-Stile in Tkinter.

flat: Kein sichtbarer Rahmen - das Widget erscheint flach ohne 3D-Effekt
raised: Widget erscheint erhöht - wie ein Button, der nicht gedrückt ist
sunken: Widget erscheint vertieft - typisch für Eingabefelder
groove: Eingeritzte Linie um das Widget
ridge: Erhabene Linie um das Widget (umgekehrter Groove-Effekt)

`bd`/`borderwidth` Parameter

Dieser Parameter bestimmt die Rahmenstärke eines Widgets in Pixeln.

            Beispiel - borderwidth
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x200")

my_font = ("Noto Sans Mono", 12)

label_one = tk.Label(
    master=root,
    text="Breite = 0",
    borderwidth=0,
    relief="solid"
)
label_one.pack(pady=5)

label_two = tk.Label(
    master=root,
    text="Breite = 3",
    borderwidth=3,
    relief="solid"
)
label_two.pack(pady=5)

label_three = tk.Label(
    master=root,
    text="Breite = 5",
    borderwidth=5,
    relief="solid"
)
label_three.pack(pady=5)

root.mainloop()

Tkinter - Label Parameter - borderwidth

Wie man am Ergebnis sehen kann, erhalten wir unterschiedlich dicke Rahmen um unsere Labels.

`padx`/`ipadx` Parameter

Dieser Parameter erzeugt horizontalen Außenabstand (links und rechts) beim Platzieren eines Widgets.

Es gibt dabei einen Unterschied zwischen padx (außen) und ipadx (innen).

padx = Abstand außerhalb des Widgets
ipadx = Padding innerhalb des Widgets (zwischen Rahmen und Inhalt)

            Schematische Darstellung
        
+-------------------------------+
|       Außenabstand (padx)     |
|    +---------------------+    |
|    |  Innenabstand       |    |
|    |   (ipadx)           |    |
|    |   Inhalt            |    |
|    +---------------------+    |
+-------------------------------+

Wie wird padx von pack() verarbeitet?

Ein Widget durchläuft bei pack() drei Layout-Schritte:

Natural size bestimmen - basierend auf dem Inhalt
Internal padding (ipadx/ipady) addieren
Outer padding (padx/pady) addieren - hier wirkt der Parameter

Die Formel, welche vom Geometry-Manager verwendet wird, ist folgende:

            Formel
        
final_width = content_width + (2 * ipadx) + (2 * padx)

Schauen wir uns nun ein Beispiel für symmetrisches Padding.

            Beispiel - padx (1)
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x200")

my_font = ("Noto Sans Mono", 12)

# Ohne Padding
label_one = tk.Label(
    master=root,
    font=my_font,
    text="Ohne Padding",
    bg="#f8fad7"
)
label_one.pack()

# Nur inneres Padding
label_two = tk.Label(
    master=root,
    font=my_font,
    text="ipadx=20",
    bg="#d7faeb"
)
label_two.pack(ipadx=20)

# Nur äußeres Padding
label_three = tk.Label(
    master=root,
    font=my_font,
    text="padx=20",
    bg="#ecdaf7"
)
label_three.pack(padx=20)

# Kombination
label_four = tk.Label(
    master=root,
    font=my_font,
    text="ipadx=20, padx=20",
    bg="#d7eafc"
)
label_four.pack(ipadx=20, padx=20)

root.mainloop()

Als Ergebnis haben wir folgendes Programm.

Tkinter - Label Parameter - padx (ipadx)

`pady`/`ipady` Parameter

Der pady und ipady Parameter kontrollieren den vertikalen Abstand (Padding) um den Label-Text.

pady - External Padding

Funktion: Fügt Abstand außerhalb des Label-Rahmens hinzu
Effekt: Vergrößert den Abstand zu anderen Widgets
Werte: Kann ein einzelner Wert (für oben UND unten) oder ein Tupel (oben, unten) sein

ipady - Internal Padding

Funktion: Fügt Abstand innerhalb des Label-Rahmens hinzu
Effekt: Vergrößert die Höhe des Labels selbst
Werte: Ein numerischer Wert, der die vertikale Ausdehnung bestimmt

Schauen wir alles an einem Beispiel an.

            Beispiel - pady / ipady
        
import tkinter as tk

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x200")

# 10 Pixel Abstand nach oben und unten
label_one = tk.Label(
    master=root,
    text="pady=10",
    bg="lightblue"
)
label_one.pack(pady=10)

# Interner Abstand
label_two = tk.Label(
    master=root,
    text="ipady=10",
    bg="lightgreen"
)
label_two.pack(ipady=10)

# Mit beiden Parametern
label_three = tk.Label(
    master=root,
    text="pady=5, ipady=5",
    bg="lightcoral"
)
label_three.pack(pady=5, ipady=5)

# Ohne Padding
label_four = tk.Label(
    master=root,
    text="Kein Padding",
    bg="yellow"
)
label_four.pack()

root.mainloop()

Tkinter - Label Parameter - pady (ipady)

Label mit dynamischem Text

Steigen wir mit einem Beispiel ein und schauen danach, was dieses Beispiel in sich an Informationen führt.

            Beispiel
        
import tkinter as tk
from datetime import datetime

root = tk.Tk()
root.title("Label - Parameter")
root.geometry("500x300")

my_font=("Noto Sans", 14)

time_var = tk.StringVar()
counter_var = tk.IntVar(value=0)

# Uhrzeit-Label
time_label = tk.Label(
    master=root,
    textvariable=time_var,
    font=my_font,
    fg="#a1f799",
    bg="black"
)
time_label.pack(pady=20, ipady=10, ipadx=10)

def update_time():
    """
    Aktualisiert die Uhrzeit
    """

    current_time = datetime.now().strftime("%H:%M:%S")
    time_var.set(current_time)
    root.after(1000, update_time)

update_time()

# Counter-Label
counter_label = tk.Label(
    master=root,
    textvariable=counter_var,
    font=my_font,
    fg="blue"
)
counter_label.pack(pady=20)

def increment():
    counter_var.set(counter_var.get() + 1)

def decrement():
    counter_var.set(counter_var.get() - 1)

def reset():
    counter_var.set(0)

# Button for Counter
button_frame = tk.Frame(master=root)
button_frame.pack(pady=10)

tk.Button(
    master=button_frame,
    text="➖",
    command=decrement,
    width=5
).pack(side="left", padx=5)

tk.Button(
    master=button_frame,
    text="Reset",
    command=reset,
    width=8
).pack(side="left", padx=5)

tk.Button(
    master=button_frame,
    text="➕",
    command=increment,
    width=5
).pack(side="left", padx=5)

root.mainloop()

Wenn wir diesen Code ausführen, erhalten wir folgendes Ergebnis.

Tkinter - Label Parameter - textvariable Beispiel

Zwei wichtige Konzepte

1. StringVar/IntVar - Tkinter-Variablen

time_var = tk.StringVar()
counter_var = tk.IntVar(value=0)

Spezielle Variablen-Typen die Tkinter versteht
Wenn die Variable sich ändert, aktualisiert sich das Widget automatisch
textvariable=time_var - Label zeigt immer den aktuellen Wert der Variable
time_var.set("neuer_wert") - Ändert Text ohne label.configure()
time_var.get() - Liest aktuellen Wert

Warum Tkinter-Variablen?

Automatische UI-Updates - ändert man die Variable, ändert sich das Label
Mehrere Widgets teilen Variable - ein Wert, mehrere Anzeigen
Callbacks möglich - trace_add() führt Code bei Änderungen aus

2. `root.after()` - Timer/Scheduling

# Rufe update_time nach 1000ms auf
root.after(1000, update_time)

Nicht-blockierend - UI bleibt responsive
Zeit in Millisekunden (1000ms = 1 Sekunde)
Kann Funktionen rekursiv aufrufen - Animation/Uhr
Arbeitet im Tkinter-Event-Loop

navigation Navigation

Inhaltsverzeichnis

Label

Inhaltsverzeichnis

Was ist ein Label?

Label-Parameter

Text & Inhalt

Schrift und Farbe

Größe und Position

Label - Text & Inhalt

text Parameter

textvariable Parameter

image Parameter

bitmap Parameter

compound Parameter

Label - Schrift und Farbe

font Parameter

fg/foreground Parameter

bg/background Parameter

Label - Größe und Position

width Parameter

height Parameter

anchor Parameter

justify Parameter

Label - Rahmen und Stil

relief Parameter

bd/borderwidth Parameter

padx/ipadx Parameter

pady/ipady Parameter

Label mit dynamischem Text

Zwei wichtige Konzepte

1. StringVar/IntVar - Tkinter-Variablen

2. root.after() - Timer/Scheduling

`text` Parameter

`textvariable` Parameter

`image` Parameter

`bitmap` Parameter

`compound` Parameter

`font` Parameter

`fg`/`foreground` Parameter

`bg`/`background` Parameter

`width` Parameter

`height` Parameter

`anchor` Parameter

`justify` Parameter

`relief` Parameter

`bd`/`borderwidth` Parameter

`padx`/`ipadx` Parameter

`pady`/`ipady` Parameter

2. `root.after()` - Timer/Scheduling