Tkinter to standardowa biblioteka Pythona do tworzenia prostych aplikacji okienkowych. Dzięki niej możesz zbudować interfejs graficzny bez instalowania dodatkowych frameworków. To dobry wybór na start, jeśli chcesz stworzyć własne narzędzie z przyciskami, polami tekstowymi, etykietami, formularzami i prostą obsługą zdarzeń.

Interfejs graficzny przydaje się wtedy, gdy nie chcesz uruchamiać programu wyłącznie z terminala. Możesz przygotować aplikację do wpisywania danych, konwerter plików, prosty kalkulator, formularz kontaktowy, narzędzie do automatyzacji zadań albo mały panel do obsługi skryptów Python.

W tym artykule poznasz podstawy Tkintera: tworzenie okna, dodawanie etykiet, przycisków, pól tekstowych, pól wyboru oraz układanie elementów za pomocą pack, grid i place.

Czym jest Tkinter?

Tkinter to biblioteka GUI dostępna w standardowej bibliotece Pythona. GUI oznacza Graphical User Interface, czyli graficzny interfejs użytkownika. Zamiast wpisywać komendy w terminalu, użytkownik może kliknąć przycisk, wpisać tekst w pole, zaznaczyć opcję lub wybrać wartość z listy.

Największą zaletą Tkintera jest prostota. Nie trzeba instalować dodatkowych pakietów, aby rozpocząć pracę. Wystarczy mieć zainstalowanego Pythona i zaimportować moduł:

Python
Kopiuj
1
import tkinter as tk

Tkinter sprawdzi się szczególnie w małych i średnich aplikacjach desktopowych, narzędziach pomocniczych, projektach edukacyjnych oraz prostych programach do automatyzacji pracy.

Jak zacząć z Tkinterem?

Podstawowa aplikacja Tkinter składa się z kilku elementów:

1. utworzenia głównego okna,
2. dodania widgetów, np. etykiet i przycisków,
3. ustawienia układu elementów,
4. uruchomienia pętli głównej mainloop().

Najprostszy przykład wygląda tak:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
import tkinter as tk

root = tk.Tk()
root.title("Moja pierwsza aplikacja")
root.geometry("400x300")

label = tk.Label(root, text="Witaj w aplikacji Tkinter!")
label.pack()

root.mainloop()

Po uruchomieniu kodu pojawi się okno z prostym napisem. To minimalna aplikacja okienkowa w Pythonie.

Okno główne aplikacji

Każda aplikacja Tkinter zaczyna się od utworzenia głównego okna. Służy do tego tk.Tk().

Python
Kopiuj
1
2
3
4
5
6
7
8
import tkinter as tk

root = tk.Tk()
root.title("Moja aplikacja")
root.geometry("400x300")
root.resizable(False, False)

root.mainloop()

W tym przykładzie:

• title() ustawia tytuł okna,
• geometry() ustawia rozmiar okna,
• resizable(False, False) blokuje zmianę rozmiaru.

Możesz też ustawić większe okno, np.:

Python
Kopiuj
1
root.geometry("800x600")

Format oznacza szerokość i wysokość w pikselach.

Etykieta, czyli Label

Etykieta służy do wyświetlania tekstu lub obrazu w oknie aplikacji. To jeden z najprostszych widgetów w Tkinterze.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
import tkinter as tk

root = tk.Tk()
root.title("Przykład Label")
root.geometry("400x200")

label = tk.Label(root, text="Witaj w aplikacji!", font=("Arial", 16))
label.pack(pady=20)

root.mainloop()

Parametr font pozwala ustawić krój i rozmiar tekstu, a pady dodaje odstęp w pionie.

Etykiety przydają się do nagłówków, opisów pól formularza, komunikatów i wyników działania programu.

Przycisk, czyli Button

Przycisk pozwala użytkownikowi wykonać akcję po kliknięciu. Do przycisku przypisuje się funkcję przez parametr command.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
import tkinter as tk

def on_click():
    print("Przycisk został kliknięty")

root = tk.Tk()
root.title("Przykład Button")
root.geometry("400x200")

button = tk.Button(root, text="Kliknij mnie", command=on_click)
button.pack(pady=20)

root.mainloop()

Ważne: w parametrze command podajesz nazwę funkcji bez nawiasów. Poprawnie:

Python
Kopiuj
1
command=on_click

Niepoprawnie:

Python
Kopiuj
1
command=on_click()

Drugi zapis uruchomi funkcję od razu podczas tworzenia przycisku, a nie po kliknięciu.

Pole tekstowe, czyli Entry

Entry pozwala użytkownikowi wpisać krótki tekst, np. imię, nazwę pliku, adres e-mail albo liczbę.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import tkinter as tk

def show_input():
    value = entry.get()
    result_label.config(text=f"Wprowadzono: {value}")

root = tk.Tk()
root.title("Przykład Entry")
root.geometry("400x250")

entry = tk.Entry(root, width=30)
entry.pack(pady=10)

button = tk.Button(root, text="Pokaż tekst", command=show_input)
button.pack(pady=10)

result_label = tk.Label(root, text="")
result_label.pack(pady=10)

root.mainloop()

Metoda entry.get() pobiera tekst wpisany przez użytkownika. Metoda config() zmienia właściwości istniejącego widgetu, np. tekst etykiety.

Pole wyboru, czyli Checkbutton

Checkbutton służy do zaznaczania opcji typu tak/nie. Do przechowywania stanu używa się zmiennej Tkintera, np. IntVar.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import tkinter as tk

def show_status():
    if agreement_var.get() == 1:
        status_label.config(text="Zgoda została zaznaczona.")
    else:
        status_label.config(text="Zgoda nie została zaznaczona.")

root = tk.Tk()
root.title("Przykład Checkbutton")
root.geometry("400x250")

agreement_var = tk.IntVar()

checkbutton = tk.Checkbutton(
    root,
    text="Wyrażam zgodę",
    variable=agreement_var
)
checkbutton.pack(pady=10)

button = tk.Button(root, text="Sprawdź", command=show_status)
button.pack(pady=10)

status_label = tk.Label(root, text="")
status_label.pack(pady=10)

root.mainloop()

Jeśli pole jest zaznaczone, agreement_var.get() zwraca 1. Jeśli nie jest zaznaczone, zwraca 0.

Układ elementów w Tkinterze

Tkinter oferuje trzy główne sposoby rozmieszczania elementów:

• pack() — układa elementy automatycznie, zwykle jeden pod drugim,
• grid() — układa elementy w siatce wierszy i kolumn,
• place() — pozwala ustawić dokładne współrzędne elementu.

W jednej sekcji okna nie powinno się mieszać pack() i grid(). Może to prowadzić do problemów z układem.

Układ za pomocą pack

pack() jest najprostszy i dobry do małych aplikacji.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
import tkinter as tk

root = tk.Tk()
root.title("Układ pack")
root.geometry("300x200")

tk.Label(root, text="Nagłówek").pack(pady=10)
tk.Button(root, text="Przycisk 1").pack(pady=5)
tk.Button(root, text="Przycisk 2").pack(pady=5)

root.mainloop()

To szybki sposób na rozmieszczenie kilku elementów jeden pod drugim.

Układ za pomocą grid

grid() daje większą kontrolę i dobrze sprawdza się przy formularzach.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import tkinter as tk

root = tk.Tk()
root.title("Formularz grid")
root.geometry("400x200")

tk.Label(root, text="Imię:").grid(row=0, column=0, padx=10, pady=10, sticky="e")
name_entry = tk.Entry(root)
name_entry.grid(row=0, column=1, padx=10, pady=10)

tk.Label(root, text="E-mail:").grid(row=1, column=0, padx=10, pady=10, sticky="e")
email_entry = tk.Entry(root)
email_entry.grid(row=1, column=1, padx=10, pady=10)

submit_button = tk.Button(root, text="Wyślij")
submit_button.grid(row=2, column=0, columnspan=2, pady=10)

root.mainloop()

Parametry row i column określają pozycję elementu w siatce. padx i pady dodają odstępy, a sticky ustawia wyrównanie.

Układ za pomocą place

place() pozwala ustawić element w konkretnym miejscu okna.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
import tkinter as tk

root = tk.Tk()
root.title("Układ place")
root.geometry("400x250")

label = tk.Label(root, text="Dokładna pozycja")
label.place(x=100, y=50)

button = tk.Button(root, text="Przycisk")
button.place(x=100, y=100)

root.mainloop()

place() daje precyzję, ale jest mniej elastyczny przy zmianie rozmiaru okna. Do większości aplikacji lepszy będzie grid() lub pack().

Prosta aplikacja Tkinter — formularz kontaktowy

Poniżej znajduje się kompletny przykład prostej aplikacji z formularzem. Użytkownik wpisuje imię i e-mail, a program wyświetla wynik.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import tkinter as tk

def submit_form():
    name = name_entry.get().strip()
    email = email_entry.get().strip()

    if not name or not email:
        result_label.config(text="Uzupełnij wszystkie pola.", fg="red")
        return

    result_label.config(
        text=f"Dane zapisane: {name}, {email}",
        fg="green"
    )

root = tk.Tk()
root.title("Formularz kontaktowy")
root.geometry("400x250")

tk.Label(root, text="Imię:").grid(row=0, column=0, padx=10, pady=10, sticky="e")
name_entry = tk.Entry(root, width=30)
name_entry.grid(row=0, column=1, padx=10, pady=10)

tk.Label(root, text="E-mail:").grid(row=1, column=0, padx=10, pady=10, sticky="e")
email_entry = tk.Entry(root, width=30)
email_entry.grid(row=1, column=1, padx=10, pady=10)

submit_button = tk.Button(root, text="Zapisz", command=submit_form)
submit_button.grid(row=2, column=0, columnspan=2, pady=10)

result_label = tk.Label(root, text="")
result_label.grid(row=3, column=0, columnspan=2, pady=10)

root.mainloop()

To dobry punkt wyjścia do większych aplikacji. Możesz rozbudować formularz o walidację e-maila, zapis do pliku CSV, zapis do bazy danych albo wysyłkę przez API.

Obsługa zdarzeń w Tkinterze

Tkinter działa w oparciu o zdarzenia. Kliknięcie przycisku, wpisanie tekstu, naciśnięcie klawisza czy zamknięcie okna może uruchomić określoną funkcję.

Przykład obsługi klawisza Enter:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import tkinter as tk

def handle_enter(event):
    result_label.config(text=f"Wpisano: {entry.get()}")

root = tk.Tk()
root.title("Obsługa zdarzeń")
root.geometry("400x200")

entry = tk.Entry(root, width=30)
entry.pack(pady=10)

entry.bind("<Return>", handle_enter)

result_label = tk.Label(root, text="")
result_label.pack(pady=10)

root.mainloop()

Metoda bind() przypisuje zdarzenie do funkcji. W tym przypadku naciśnięcie Enter w polu tekstowym wywołuje handle_enter.

Komunikaty dla użytkownika

Tkinter ma wbudowany moduł messagebox, który pozwala wyświetlać komunikaty, ostrzeżenia i pytania.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import tkinter as tk
from tkinter import messagebox

def show_message():
    messagebox.showinfo("Informacja", "Operacja zakończona sukcesem.")

root = tk.Tk()
root.title("Messagebox")
root.geometry("300x150")

button = tk.Button(root, text="Pokaż komunikat", command=show_message)
button.pack(pady=30)

root.mainloop()

Możesz też użyć:

Python
Kopiuj
1
2
messagebox.showwarning("Ostrzeżenie", "Uzupełnij wymagane pola.")
messagebox.showerror("Błąd", "Nie udało się zapisać danych.")

To prosty sposób na poprawę użyteczności aplikacji.

Wybór pliku w Tkinterze

Tkinter umożliwia otwieranie systemowego okna wyboru pliku. Służy do tego filedialog.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import tkinter as tk
from tkinter import filedialog

def choose_file():
    file_path = filedialog.askopenfilename(
        title="Wybierz plik",
        filetypes=[("Pliki tekstowe", "*.txt"), ("Wszystkie pliki", "*.*")]
    )

    if file_path:
        label.config(text=f"Wybrano: {file_path}")

root = tk.Tk()
root.title("Wybór pliku")
root.geometry("500x200")

button = tk.Button(root, text="Wybierz plik", command=choose_file)
button.pack(pady=20)

label = tk.Label(root, text="Nie wybrano pliku")
label.pack(pady=10)

root.mainloop()

To bardzo przydatne, jeśli tworzysz aplikację do przetwarzania plików, np. konwersji PDF, Excela lub CSV.

Uruchomienie aplikacji Tkinter

Aplikacja Tkinter działa dzięki pętli głównej:

Python
Kopiuj
1
root.mainloop()

Ta pętla nasłuchuje zdarzeń użytkownika: kliknięć, wpisywania tekstu, zamykania okna i innych interakcji. Bez mainloop() okno pojawiłoby się tylko na moment albo nie uruchomiłoby się poprawnie.

Zwykle mainloop() znajduje się na końcu programu.

Dobre praktyki przy pracy z Tkinterem

Przy tworzeniu aplikacji okienkowych w Tkinterze warto trzymać się kilku zasad:

• używaj grid() do formularzy,
• nie mieszaj pack() i grid() w tym samym kontenerze,
• dziel kod na funkcje,
• nadawaj widgetom czytelne nazwy,
• waliduj dane wpisywane przez użytkownika,
• pokazuj jasne komunikaty błędów,
• nie blokuj interfejsu długimi operacjami,
• ustawiaj sensowne rozmiary okna,
• testuj aplikację na różnych rozdzielczościach,
• zaczynaj od prostego układu i stopniowo go rozbudowuj.

Jeśli aplikacja wykonuje długie zadania, np. pobiera dane z API albo przetwarza duże pliki, warto rozważyć użycie wątku lub osobnego procesu. Dzięki temu okno nie będzie się zawieszać.

Podsumowanie

Tkinter to prosty i dostępny sposób na tworzenie interfejsów graficznych w Pythonie. Nie wymaga instalowania dodatkowych bibliotek, dlatego dobrze nadaje się do nauki GUI, małych aplikacji desktopowych i narzędzi wspierających automatyzację.

Najważniejsze elementy na start to Tk, Label, Button, Entry, Checkbutton, pack, grid i mainloop. Po ich opanowaniu możesz tworzyć formularze, obsługiwać kliknięcia, pobierać dane od użytkownika i budować praktyczne aplikacje okienkowe.

Jeśli chcesz zacząć praktycznie, zbuduj prosty formularz z dwoma polami tekstowymi, przyciskiem i komunikatem wyniku. Potem rozbuduj go o walidację, wybór pliku i zapis danych do CSV. To dobry pierwszy projekt w Tkinterze.