S čím potřebuješ pomoct?
< Všechna témata
Tisk

Návrh uživatelského rozhraní pomocí CustomTkinter

Vloženo
Aktualizováno
VložilLukáš Pospíšil
Zobrazeno138

Doposud jsme si v Pythonu vytvářeli programy, které běžely v konzoli. Na příkazové řádce jsme vypisovali text, přijímali vstupy a občas i počítali výsledky. Takové programy ale nejsou pro běžného uživatele moc přívětivé.

Když uživatel spustí program, očekává okno, tlačítka, vstupní pole, barvy a příjemné prostředí. Právě proto existuje GUI – Graphical User Interface, česky grafické uživatelské rozhraní.

V předchozí kapitole jsme poznali Tkinter, což je jednoduchá knihovna pro tvorbu GUI, která je součástí Pythonu. Tkinter je skvělý na pochopení principů – naučí nás, co je to „okno“, jak do něj vložit tlačítko, textové pole a jak reagovat na kliknutí. Jeho jedinou nevýhodou je, že vzhled je zastaralý.

Aby aplikace vypadaly moderně, vznikla knihovna CustomTkinter. Je založena na Tkinteru, ale přidává moderní vzhled, zaoblené rohy, podporu tmavého i světlého režimu, a umožňuje vytvářet aplikace, které vypadají profesionálně.

Instalace

Protože CustomTkinter není součástí Pythonu, musíme ho nejprve nainstalovat.
Použijeme k tomu standardní nástroj pip.

pip install customtkinter

Po instalaci můžeme knihovnu naimportovat příkazem

import customtkinter as ctk

Tím říkáme, že v kódu budeme knihovnu oslovovat zkratkou ctk.
Je to jen pro zjednodušení – abychom nemuseli psát dlouhé customtkinter.CTkButton, ale jen ctk.CTkButton.

První okno

import customtkinter as ctk   # načteme knihovnu

# Nastavení vzhledu celé aplikace
ctk.set_appearance_mode("System")     # může být "Light", "Dark" nebo "System"
ctk.set_default_color_theme("blue")   # barevné téma aplikace

# Vytvoření hlavního okna
okno = ctk.CTk()
okno.title("Moje první aplikace v CTk")
okno.geometry("400x250")

# Přidáme popisek
popisek = ctk.CTkLabel(okno, text="Vítej v CustomTkinteru", font=("Arial", 18))
popisek.pack(pady=20)

# Přidáme tlačítko
def stisknuto():
    print("Tlačítko bylo stisknuto!")

tlacitko = ctk.CTkButton(okno, text="Klikni na mě", command=stisknuto)
tlacitko.pack(pady=10)

# Spustíme hlavní smyčku aplikace
okno.mainloop()
  • Načítáme knihovnu customtkinter a dáváme jí přezdívku ctk.
  • Nastavíme vzhled
    • set_appearance_mode("System") – aplikace se přizpůsobí systému (světlý/tmavý režim).
    • set_default_color_theme("blue") – výchozí barvy (může být i "green" nebo "dark-blue").
  • Vytvoříme okno
    • ctk.CTk() vytvoří hlavní okno.
    • title() nastaví název okna (zobrazí se v záhlaví).
    • geometry("400x250") určuje velikost okna (šířka x výška v pixelech).
  • Přidáme textový popisek
    • CTkLabel zobrazí text.
    • pady=20 znamená 20 pixelů volného místa nahoře a dole.
  • Přidáme tlačítko (button)
    • command=stisknuto určuje, co se stane, když na tlačítko klikneš.
    • Funkce stisknuto() vypíše text do konzole.
  • Použijeme hlavní smyčku
    • mainloop() udržuje okno „naživu“. Program běží, dokud ho uživatel nezavře.

Základní stavební prvky (widgety)

„Widget“ je jakýkoli ovládací prvek v okně – tlačítko, textové pole, popisek, posuvník apod.
V CustomTkinteru jsou všechny widgety pojmenované stejně jako v Tkinteru, jen mají předponu CTk.

TkinterCustomTkinter
LabelCTkLabel
ButtonCTkButton
EntryCTkEntry
TextCTkTextbox
FrameCTkFrame
CheckbuttonCTkCheckBox
RadiobuttonCTkRadioButton

CTkLabel – popisek

Popisek slouží ke zobrazení textu nebo informací.

popisek = ctk.CTkLabel(okno, text="Toto je popisek", font=("Arial", 16, "bold"), text_color="white", fg_color="darkblue")
popisek.pack(pady=10)
  • text – co se má zobrazit
  • font – písmo (název, velikost, styl)
  • text_color – barva textu
  • fg_color – barva pozadí

Pokud nechceme mít žádné pozadí, necháme fg_color=None

CTkButton – tlačítko

Tlačítko může spustit funkci, když na něj uživatel klikne.

def klik():
    print("Klik!")

tlacitko = ctk.CTkButton(okno, text="Klikni na mě", command=klik, fg_color="green", hover_color="darkgreen")
tlacitko.pack(pady=10)
  • command=klik říká, že se má po kliknutí spustit funkce klik()
  • Barvy fg_color a hover_color určují barvu tlačítka a jeho barvu při najetí myší.

CTkEntry – jednořádkové textové pole

Slouží k zadávání textu od uživatele.

vstup = ctk.CTkEntry(okno, placeholder_text="Zadej své jméno...")
vstup.pack(pady=10)

def odeslat():
    jmeno = vstup.get()
    print(f"Ahoj, {jmeno}!")

ctk.CTkButton(okno, text="Odeslat", command=odeslat).pack(pady=10)
  • get() vrací text, který uživatel zadal.
  • placeholder_text je šedý text, který zmizí po kliknutí do pole.

CTkTextbox – víceřádkové pole

Pro delší text, např. poznámky nebo zprávy.

text = ctk.CTkTextbox(okno, width=300, height=100)
text.insert("1.0", "Sem můžeš napsat libovolný text.")
text.pack(pady=10)
  • "1.0" znamená první řádek, první znak.
  • insert() vloží text.

CTkCheckBox – zaškrtávací políčko

Umožňuje vybrat ANO/NE, zapnuto/vypnuto.

souhlas = ctk.BooleanVar()

check = ctk.CTkCheckBox(okno, text="Souhlasím s podmínkami", variable=souhlas)
check.pack(pady=5)

def kontrola():
    print("Souhlas:", souhlas.get())

ctk.CTkButton(okno, text="Zkontroluj", command=kontrola).pack(pady=5)
  • BooleanVar() ukládá True nebo False

Když uživatel políčko zaškrtne, proměnná se automaticky změní.

CTkRadioButton – výběr jedné možnosti

Umožňuje zvolit jednu z několika možností.

volba = ctk.StringVar(value="")

r1 = ctk.CTkRadioButton(okno, text="Pes", variable=volba, value="pes")
r2 = ctk.CTkRadioButton(okno, text="Kočka", variable=volba, value="kočka")
r1.pack()
r2.pack()

def zobraz():
    print("Vybráno:", volba.get())

ctk.CTkButton(okno, text="Zobraz volbu", command=zobraz).pack(pady=10)
  • StringVar() ukládá textovou hodnotu vybrané možnosti

Při kliknutí na tlačítko se z volba.get() zjistí aktuální výběr.

CTkSlider – posuvník hodnot

def zmena(value):
    print("Aktuální hodnota:", round(value, 1))

slider = ctk.CTkSlider(okno, from_=0, to=100, command=zmena)
slider.pack(pady=10)
  • Parametr from_ a to určuje rozsah posuvníku
  • Funkce command se volá vždy, když se posuvník pohne

CTkProgressBar – indikátor průběhu

progress = ctk.CTkProgressBar(okno)
progress.pack(pady=10)
progress.set(0.5)   # 50 %
  • Hodnota set(0.5) znamená 50 %

CtKOptionMenu – rozbalovací nabídka

vyber = ctk.StringVar(value="Modrá")  # výchozí hodnota

menu = ctk.CTkOptionMenu(okno, values=["Modrá", "Zelená", "Červená"], variable=vyber)
menu.pack(pady=10)

def zobraz_vyber():
    print("Vybral jsi:", vyber.get())

ctk.CTkButton(okno, text="Zobraz výběr", command=zobraz_vyber).pack(pady=10)
  • CTkOptionMenu vytváří rozbalovací nabídku.
  • values určuje seznam možností, které se zobrazí.
  • variable (typicky StringVar) uchovává právě zvolenou hodnotu.
  • value=“Modrá“ nastaví výchozí zobrazenou položku.
  • Pomocí vyber.get() zjistíš aktuální výběr.

Rozvržení prvků (layout)

Když vytváříme aplikaci, musíme říct, kam se mají jednotlivé prvky umístit.
Tkinter (a tím pádem i CustomTkinter) nám nabízí tři základní způsoby rozmístění, tzv. layouty:

Název metodyJak fungujeKdy ji použít
.pack()Umísťuje prvky pod sebe nebo vedle sebe podle pořadípro jednoduché okna
.grid()Rozděluje okno na tabulku (mřížku) řádků a sloupcůpro formuláře, přihlašování, kalkulačky
.place()Umísťuje prvky přesně podle souřadnic (x, y)pro přesné rozmístění nebo speciální efekty

Layout PACK

pack() je nejjednodušší způsob rozložení.
Představ si ho jako lepení prvků pod sebe nebo vedle sebe.

Každý prvek, který použiješ s .pack(), se přidá do okna podle pořadí, v jakém ho napíšeš.
První prvek nahoře, další pod ním, a tak dále.

import customtkinter as ctk

app = ctk.CTk()
app.title("Ukázka layoutu PACK")
app.geometry("300x250")

tlacitko1 = ctk.CTkButton(app, text="Horní tlačítko")
tlacitko1.pack(side="top", pady=10)

tlacitko2 = ctk.CTkButton(app, text="Spodní tlačítko")
tlacitko2.pack(side="bottom", pady=10)

tlacitko3 = ctk.CTkButton(app, text="Vlevo")
tlacitko3.pack(side="left", padx=10, pady=10)

tlacitko4 = ctk.CTkButton(app, text="Vpravo")
tlacitko4.pack(side="right", padx=10, pady=10)

app.mainloop()
  • side="top" – prvek se přilepí k hornímu okraji (výchozí nastavení)
  • side="bottom" – přilepí se k dolnímu okraji
  • side="left" – k levé straně
  • side="right" – k pravé straně
  • padx, pady – mezery kolem prvku
  • ipadx, ipady – vnitřní odsazení uvnitř prvku (rozšíří ho)
  • fill="x" – prvek se roztáhne do šířky
  • expand=True – prvek se roztáhne, pokud je v okně volné místo

Tlačítko přes celou šířku: 

tlacitko = ctk.CTkButton(app, text="Vyplň šířku", fg_color="darkblue")
tlacitko.pack(fill="x", padx=20, pady=10)

Layout GRID

Když chceš prvky umístit přesněji, použij metodu grid().
Ta rozdělí okno do řádků a sloupců, podobně jako tabulka v Excelu.

Každý prvek umístíš do určité buňky podle čísel:

  • první řádek má číslo 0
  • první sloupec má číslo 0
  • buňka v levém horním rohu je tedy (row=0, column=0)
import customtkinter as ctk

app = ctk.CTk()
app.title("Přihlašovací formulář")
app.geometry("350x200")

# Popisky
ctk.CTkLabel(app, text="Uživatelské jméno:").grid(row=0, column=0, padx=5, pady=5, sticky="e")
ctk.CTkLabel(app, text="Heslo:").grid(row=1, column=0, padx=5, pady=5, sticky="e")

# Vstupní pole
entry_jmeno = ctk.CTkEntry(app, placeholder_text="např. pospisill")
entry_jmeno.grid(row=0, column=1, padx=5, pady=5)

entry_heslo = ctk.CTkEntry(app, show="*")
entry_heslo.grid(row=1, column=1, padx=5, pady=5)

# Tlačítko
tlacitko = ctk.CTkButton(app, text="Přihlásit se", command=lambda: print("Přihlášeno!"))
tlacitko.grid(row=2, column=0, columnspan=2, pady=10)

app.mainloop()
  • row = číslo řádku (od 0)
  • column = číslo sloupce (od 0)
  • columnspan=2 = prvek zabere dva sloupce
  • sticky="e" = zarovná doprava (east)
    • n (nahoře) – north
    • s (dole) – south
    • e (vpravo) – east
    • w (vlevo) – west
    • nsew – roztáhne prvek do všech směrů
  • padx, pady = mezery kolem prvku

Responzivní grid

Můžeš říct, které řádky a sloupce se mají roztahovat při změně velikosti okna.

app.grid_rowconfigure(0, weight=1)
app.grid_rowconfigure(1, weight=1)
app.grid_columnconfigure(0, weight=1)
app.grid_columnconfigure(1, weight=2)

weight určuje, jak moc se prvek roztáhne – větší číslo = víc prostoru

Layout PLACE

place() je nejpřesnější, ale také nejnáročnější.
Používá souřadnice x a y nebo relativní pozice (v procentech).

ctk.CTkLabel(app, text="Nadpis", font=("Arial", 18)).place(x=100, y=30)
ctk.CTkButton(app, text="Start").place(x=120, y=100)
  • (x=100, y=30) znamená, že prvek začíná 100 pixelů od levého okraje a 30 pixelů od horního.

Relativní pozice:

ctk.CTkButton(app, text="Uprostřed").place(relx=0.5, rely=0.5, anchor="center")
  • relx=0.5 a rely=0.5 = střed okna
  • anchor="center" určuje, že se střed tlačítka zarovná na tuto pozici

Rámečky (CTkFrame)

Rámeček (frame) je něco jako vnořené okno – kontejner, do kterého můžeš umístit další prvky.
Umožňuje rozdělit okno na části (např. levé menu a pravý obsah).

import customtkinter as ctk

app = ctk.CTk()
app.title("Rámečky v aplikaci")
app.geometry("500x300")

# Levý rámec (menu)
levy = ctk.CTkFrame(app, width=150, fg_color="#99ccff")
levy.pack(side="left", fill="y")

# Pravý rámec (obsah)
pravy = ctk.CTkFrame(app, fg_color="#e0e0e0")
pravy.pack(side="right", fill="both", expand=True)

# Prvky v levém rámu
ctk.CTkLabel(levy, text="Menu", font=("Arial", 14, "bold")).pack(pady=10)
ctk.CTkButton(levy, text="Domů").pack(pady=5)
ctk.CTkButton(levy, text="Nastavení").pack(pady=5)

# Prvky v pravém rámu
ctk.CTkLabel(pravy, text="Zde se bude měnit obsah...").pack(pady=20)

app.mainloop()
  • Máme dvě části okna – levé menu a pravý obsah.
  • Každý frame má vlastní barvu a může používat svůj layout (pack, grid nebo place).
  • Uvnitř každého rámce můžeš vytvářet libovolné widgety, aniž by se „překřížily“ s těmi v druhém rámu.

Interaktivita

V tuto chvíli už umíme vytvořit okno, umístit do něj tlačítka, popisky i vstupní pole.
Ale zatím všechno jen „stojí“ – nic se neděje, dokud to sami nenaprogramujeme.

Teď si ukážeme, jak aplikaci oživit.

Změna obsahu pomocí funkce a command=

Každé tlačítko může spustit nějakou funkci.

import customtkinter as ctk

app = ctk.CTk()
app.title("Změna textu")
app.geometry("300x200")

# Popisek (bude se měnit)
popisek = ctk.CTkLabel(app, text="Původní text", font=("Arial", 16))
popisek.pack(pady=20)

# Funkce, která změní text
def zmen_text():
    popisek.configure(text="MěSOŠ, škola jak se patří", text_color="green")

# Tlačítko
tlacitko = ctk.CTkButton(app, text="Změň text", command=zmen_text)
tlacitko.pack(pady=10)

app.mainloop()
  • configure() umožňuje změnit vlastnosti prvku za běhu (např. text, barvu, velikost).
  • Kliknutím na tlačítko se zavolá funkce zmen_text(), která:
    • přepíše text v popisku (text="...")
    • změní barvu (text_color="green")

Přepínání textu – přepínač

Někdy chceme, aby se prvek střídal mezi dvěma stavy (např. „Zapnuto / Vypnuto“).

import customtkinter as ctk

app = ctk.CTk()
app.title("Světlo")
app.geometry("300x200")

stav = False  # výchozí stav

def prepni():
    global stav
    if stav:
        popisek.configure(text="Světlo zhasnuto", text_color="gray")
    else:
        popisek.configure(text="Světlo rozsvíceno", text_color="yellow")
    stav = not stav  # přepne hodnotu True/False

popisek = ctk.CTkLabel(app, text="Světlo zhasnuto")
popisek.pack(pady=20)

ctk.CTkButton(app, text="Přepni světlo", command=prepni).pack(pady=10)

app.mainloop()

Získávání vstupu od uživatele – .get()

Interakce není jen o klikání – často potřebujeme, aby uživatel něco napsal.
Používáme k tomu widget Entry, který známe z dřívějška.

import customtkinter as ctk

app = ctk.CTk()
app.title("Světlo")
app.geometry("300x200")

stav = False  # výchozí stav

def prepni():
    global stav
    if stav:
        popisek.configure(text="Světlo zhasnuto", text_color="gray")
    else:
        popisek.configure(text="Světlo rozsvíceno", text_color="yellow")
    stav = not stav  # přepne hodnotu True/False

popisek = ctk.CTkLabel(app, text="Světlo zhasnuto")
popisek.pack(pady=20)

ctk.CTkButton(app, text="Přepni světlo", command=prepni).pack(pady=10)

app.mainloop()
  • .get() = načtení dat z textového pole
  • .configure() = úprava textu podle potřeby

Události (events) a metoda .bind()

Metoda bind() umožňuje reagovat na konkrétní události:

  • pohyb myši,
  • kliknutí,
  • stisk klávesy,
  • dvojklik atd.

Každý widget (např. tlačítko, popisek nebo okno) může poslouchat určité události a spustit při nich funkci.

widget.bind("<událost>", funkce)
  • Funkce musí přijímat jeden parametr – tzv. event object, který obsahuje informace o události (např. jaká klávesa byla stisknuta, kde je myš…).
import customtkinter as ctk

app = ctk.CTk()
app.geometry("400x250")
app.title("Sledování pohybu myši")

popisek = ctk.CTkLabel(app, text="Pohybuj myší nad oknem")
popisek.pack(pady=40)

def pohyb(event):
    popisek.configure(text=f"x={event.x}, y={event.y}")

# celá aplikace reaguje na pohyb myši
app.bind("<Motion>", pohyb)

app.mainloop()
  • Co dělá event.x a event.y
    • x a y jsou souřadnice myši v aktuálním okně
    • po každém pohybu se zavolá funkce pohyb(), která přepíše text v popisku

Reakce na klávesnici

Zachytávání kláves funguje podobně – opět pomocí .bind().

import customtkinter as ctk

app = ctk.CTk()
app.title("Zachycení kláves")
app.geometry("400x200")

label = ctk.CTkLabel(app, text="Stiskni libovolnou klávesu...")
label.pack(pady=40)

def klavesa(event):
    label.configure(text=f"Stiskl jsi: {event.keysym}")

app.bind("<KeyPress>", klavesa)
app.mainloop()
  • "<KeyPress>" = jakmile se stiskne jakákoli klávesa
  • event.keysym = obsahuje název klávesy (např. „a“, „Shift“, „Return“)

Práce s více okny

Doteď jsme tvořili jednoduché aplikace, které měly jen jedno okno – například formulář nebo tlačítka.
Ale co když chceme, aby uživatel mohl přejít na další obrazovku (např. z přihlašování do hlavní nabídky)?
Nebo otevřít nové okno se zvláštním obsahem?

To už potřebujeme dvě různé věci:

  1. CTkToplevel – vytvoří nové samostatné okno (např. „O aplikaci“).
  2. Frame přepínání – umožní měnit obsah hlavního okna bez otevírání nového.

Nové samostatné okno – CTkToplevel

Zkusme si vytvořit program, který má hlavní okno a tlačítko „O aplikaci“.
Po kliknutí se otevře nové malé okno s informacemi.

import customtkinter as ctk

app = ctk.CTk()
app.title("Více oken - CTkToplevel")
app.geometry("400x250")

def otevri_okno():
    nove_okno = ctk.CTkToplevel(app)
    nove_okno.title("O aplikaci")
    nove_okno.geometry("300x150")

    ctk.CTkLabel(nove_okno, text="Tato aplikace byla vytvořena\nv CustomTkinteru.", justify="center").pack(pady=20)
    ctk.CTkButton(nove_okno, text="Zavřít", command=nove_okno.destroy).pack(pady=10)

ctk.CTkLabel(app, text="Hlavní okno").pack(pady=30)
ctk.CTkButton(app, text="O aplikaci", command=otevri_okno).pack()

app.mainloop()
  • CTkToplevel(app) – vytvoří nové okno, které je „nadřazené“ hlavnímu.
  • destroy() – zavře dané okno.
  • Můžeš mít libovolný počet oken. Každé funguje samostatně.

Přepínání obrazovek v jednom okně – CTkFrame

Otevírat nové okno není vždy ideální – někdy je lepší měnit obsah v tom stejném okně.
Například po přihlášení nechceš, aby se otevřelo nové okno, ale aby se prostě změnil obsah na „hlavní menu“.

Toho dosáhneme pomocí rámců (CTkFrame) – každý frame představuje jednu „obrazovku“ aplikace.
Stačí zobrazit ten správný a ostatní skrýt.

import customtkinter as ctk

app = ctk.CTk()
app.title("Více oken - CTkToplevel")
app.geometry("400x250")

def otevri_okno():
    nove_okno = ctk.CTkToplevel(app)
    nove_okno.title("O aplikaci")
    nove_okno.geometry("300x150")

    ctk.CTkLabel(nove_okno, text="Tato aplikace byla vytvořena\nv CustomTkinteru.", justify="center").pack(pady=20)
    ctk.CTkButton(nove_okno, text="Zavřít", command=nove_okno.destroy).pack(pady=10)

ctk.CTkLabel(app, text="Hlavní okno").pack(pady=30)
ctk.CTkButton(app, text="O aplikaci", command=otevri_okno).pack()

app.mainloop()
  • pack_forget() = prvek (nebo frame) se skryje.
  • pack() = prvek se znovu zobrazí.
  • Díky tomu se dá jednoduše přepínat mezi „obrazovkami“ v jedné aplikaci.

OOP v GUI

Když aplikace roste, stává se kód nepřehledný.
Proto se v praxi GUI často píše pomocí tříd.
Každá část aplikace má svoji vlastní třídu – např. jedna třída pro přihlašovací okno, druhá pro hlavní menu.

import customtkinter as ctk

# --- Třída hlavní aplikace ---
class MojeAplikace(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.title("OOP - Přepínání obrazovek")
        self.geometry("400x250")

        self.frame_login = LoginFrame(self)
        self.frame_main = MainFrame(self)

        self.zobraz_login()

    def zobraz_login(self):
        self.frame_main.pack_forget()
        self.frame_login.pack(fill="both", expand=True)

    def zobraz_main(self):
        self.frame_login.pack_forget()
        self.frame_main.pack(fill="both", expand=True)

# --- Přihlašovací obrazovka ---
class LoginFrame(ctk.CTkFrame):
    def __init__(self, master):
        super().__init__(master)
        ctk.CTkLabel(self, text="Přihlašovací obrazovka").pack(pady=10)
        self.jmeno = ctk.CTkEntry(self, placeholder_text="Jméno")
        self.jmeno.pack(pady=5)
        self.heslo = ctk.CTkEntry(self, placeholder_text="Heslo", show="*")
        self.heslo.pack(pady=5)
        ctk.CTkButton(self, text="Přihlásit se", command=self.prihlasit).pack(pady=10)

    def prihlasit(self):
        # Tady by mohla být kontrola jména a hesla
        self.master.zobraz_main()

# --- Hlavní menu ---
class MainFrame(ctk.CTkFrame):
    def __init__(self, master):
        super().__init__(master)
        ctk.CTkLabel(self, text="Vítej v hlavním menu!", font=("Arial", 16)).pack(pady=20)
        ctk.CTkButton(self, text="Odhlásit se", command=master.zobraz_login).pack(pady=10)

# --- Spuštění aplikace ---
app = MojeAplikace()
app.mainloop()
  • class MojeAplikace(ctk.CTk)
    • hlavní třída, která dědí z hlavního okna CustomTkinteru.
  • self.frame_login a self.frame_main
    • jsou objekty dvou „obrazovek“.
  • zobraz_login() a zobraz_main()
    • metody, které přepínají mezi nimi.
  • LoginFrame a MainFrame
    • každá třída se stará o svou část GUI.

Můžeš si to představit jako dům (aplikaci), který má více místností (frame).
Každá místnost má svůj vlastní nábytek (widgety).
Metoda zobraz_main() jen zavře jedny dveře a otevře druhé — a ty přejdeš do jiné místnosti

Komplexní příklad

import customtkinter as ctk

app = ctk.CTk()
app.title("BMI Kalkulačka")
app.geometry("350x300")

# Nadpis
ctk.CTkLabel(app, text="BMI kalkulačka", font=("Arial", 18, "bold")).pack(pady=10)

# Vstupní pole
ctk.CTkLabel(app, text="Výška (cm):").pack()
vyska = ctk.CTkEntry(app)
vyska.pack(pady=5)

ctk.CTkLabel(app, text="Hmotnost (kg):").pack()
hmotnost = ctk.CTkEntry(app)
hmotnost.pack(pady=5)

# Výsledek
vysledek = ctk.CTkLabel(app, text="", font=("Arial", 14))
vysledek.pack(pady=10)

# Funkce pro výpočet
def spocitej_bmi():
    try:
        v = float(vyska.get()) / 100   # přepočet na metry
        h = float(hmotnost.get())
        bmi = h / (v ** 2)

        if bmi < 18.5:
            stav = "Podváha"
        elif bmi < 25:
            stav = "V normě"
        elif bmi < 30:
            stav = "Nadváha"
        else:
            stav = "Obezita"

        vysledek.configure(text=f"BMI: {bmi:.2f} ({stav})")
    except:
        vysledek.configure(text="Zadej čísla!", text_color="red")

# Tlačítko
ctk.CTkButton(app, text="Vypočítat", command=spocitej_bmi).pack(pady=10)

app.mainloop()
  • .get() načítá hodnoty z polí.
  • Používáme try/except, aby program nespadl při chybném vstupu.
  • .configure() mění text i barvu výsledku.

Zdroje

Seznam zdrojů

itnetwork.cz. Online. Dostupné z: https://www.itnetwork.cz/.

w3schools.com. Online. Dostupné z: https://www.w3schools.com/.

Python 3 documentation. Online. Dostupné z: https://docs.python.org/3/

SMOLKA, Pavel. Programovací jazyk Python [online]. Mendelova univerzita v Brně, 2019. Dostupné z: https://emendelu.publi.cz/book/771-programovaci-jazyk-python-pruvodce-studiem

ŠVEC, Jan. Učebnice jazyka Python (aneb Létající cirkus) [online]. 2002. Dostupné z: https://i.iinfo.cz/files/root/k/Ucebnice_jazyka_Python.pdf

PILGRIM, Mark. Ponořme se do Python(u) 3: Dive into Python 3. CZ.NIC. Praha: CZ.NIC, c2010. ISBN 978-80-904248-2-1.

PECINOVSKÝ, Rudolf. Python: kompletní příručka jazyka pro verzi 3.11. Knihovna programátora (Grada). Praha: Grada Publishing, 2023. ISBN 978-80-271-3891-3.

Další zdroje (Youtube, obrázky) jsou vždy uvedeny.

Obsah
© 2025 Lukáš Pospíšil