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.
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.
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()
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.
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.
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.
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.
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.
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.
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.
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()
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 rechtsright: Bild rechts, Text linkstop: Bild oben, Text untenbottom: Bild unten, Text obencenter: Bild über dem Text, Text wird über das Bild gelegtnone: Standard - Bild oder Text (nicht beides)
Hier ein Beispiel mit left.
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()
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.
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()
fg/foreground Parameter
Dieser Parameter ist dafür verantwortlich die Schriftfarbe zu bestimmen.
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.
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.
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.
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
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.
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.
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()
height Parameter
Analog zum width Parameter gibt es den height Parameter. Die Kalkulation in Abhängigkeit von Schrift oder Bild ist die gleiche.
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()
Nun gehen wir wieder den Weg und definieren ein paar Höhen-Werte vor und lassen und in einer Schleife die Widgets bauen.
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.
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.
nw n ne
\ | /
\ | /
+-------+
w --> |center | --> e
+-------+
/ | \
/ | \
sw s seDie 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.
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()
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)
Dies ist ein sehr langer Text,
der über mehrere Zeilen
verteilt ist.2 justify="center"
Dies ist ein sehr langer Text,
der über mehrere Zeilen
verteilt ist.3 justify="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.
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()
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.
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()
Was zeigt dieses Beispiel?
Dieses Beispiel demonstriert 5 verschiedenen Relief-Stile in Tkinter.
flat: Kein sichtbarer Rahmen - das Widget erscheint flach ohne 3D-Effektraised: Widget erscheint erhöht - wie ein Button, der nicht gedrückt istsunken: Widget erscheint vertieft - typisch für Eingabefeldergroove: Eingeritzte Linie um das Widgetridge: Erhabene Linie um das Widget (umgekehrter Groove-Effekt)
bd/borderwidth Parameter
Dieser Parameter bestimmt die Rahmenstärke eines Widgets in Pixeln.
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()
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 Widgetsipadx= Padding innerhalb des Widgets (zwischen Rahmen und Inhalt)
+-------------------------------+
| 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:
final_width = content_width + (2 * ipadx) + (2 * padx)Schauen wir uns nun ein Beispiel für symmetrisches Padding.
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.
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.
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()
Label mit dynamischem Text
Steigen wir mit einem Beispiel ein und schauen danach, was dieses Beispiel in sich an Informationen führt.
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.
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 Variabletime_var.set("neuer_wert")- Ändert Text ohnelabel.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