Python darbvirsmas lietotnes: Visaptverošs ceļvedis Tkinter GUI izstrādē

Python ir slavens ar savu daudzpusību, atrodot pielietojumu tīmekļa izstrādē, datu zinātnē un skriptēšanā. Bet vai zinājāt, ka to var izmantot arī, lai radītu pārliecinošas darbvirsmas lietotnes? Tkinter, Python standarta GUI (Grafiskā lietotāja saskarne) bibliotēka, nodrošina vienkāršu, bet jaudīgu veidu, kā veidot starpplatformu darbvirsmas lietotnes. Šis ceļvedis jūs iepazīstinās ar Tkinter pamatiem, sniedzot zināšanas, lai izveidotu savas ar Python darbināmas darbvirsmas lietotnes.

Kāpēc Tkinter?

Pirms iedziļināmies detaļās, sapratīsim, kāpēc Tkinter joprojām ir populāra izvēle Python GUI izstrādē:

• Python standarta bibliotēkas daļa: Tkinter ir iepriekš instalēts vairumā Python distributīvu, novēršot nepieciešamību pēc ārējām instalācijām un vienkāršojot projekta iestatīšanu.
• Starpplatformu saderība: Tkinter lietotnes nevainojami darbojas Windows, macOS un Linux sistēmās, padarot to par lielisku izvēli lietotņu izstrādei ar plašu sasniedzamību.
• Viegli apgūstams: Tkinter salīdzinoši vienkāršais API padara to pieejamu iesācējiem, vienlaikus piedāvājot pietiekamu elastību sarežģītākiem projektiem.
• Liela kopiena un resursi: Plaša tiešsaistes kopiena nodrošina bagātīgu dokumentāciju, apmācības un atbalstu Tkinter izstrādātājiem.
• Ātra prototipēšana: Tkinter ļauj ātri izstrādāt un prototipēt GUI lietotnes.

Darba sākšana ar Tkinter

Lai sāktu veidot Tkinter lietotnes, jūsu sistēmā ir jābūt instalētam Python. Vairums operētājsistēmu nāk ar iepriekš instalētu Python, bet ieteicams lejupielādēt jaunāko versiju no oficiālās Python vietnes (python.org), lai nodrošinātu, ka jums ir visjaunākās funkcijas un drošības ielāpi.

Pamata loga izveide

Sāksim, izveidojot vienkāršu logu. Tas ir jebkuras Tkinter lietotnes pamats.

            import tkinter as tk

# Create the main application window
root = tk.Tk()

# Set the window title
root.title("My First Tkinter Application")

# Set the window size (widthxheight)
root.geometry("400x300")

# Run the main event loop
root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `import tkinter as tk`: Importē Tkinter moduli un piešķir tam aizstājvārdu `tk` īsuma labad.
• `root = tk.Tk()`: Izveido galveno lietotnes logu, ko bieži dēvē par "saknes" (root) logu.
• `root.title("My First Tkinter Application")`: Iestata loga virsrakstu, kas tiks parādīts loga virsrakstjoslā.
• `root.geometry("400x300")`: Iestata loga sākotnējo izmēru uz 400 pikseļiem platumā un 300 pikseļiem augstumā. Šīs vērtības varat pielāgot pēc vajadzības.
• `root.mainloop()`: Sāk Tkinter notikumu ciklu, kas klausās notikumus (piem., pogas klikšķus, taustiņu nospiešanu) un uztur logu atvērtu, līdz lietotājs to aizver. Tas ir būtiski, lai jūsu lietotne būtu interaktīva.

Saglabājiet šo kodu kā Python failu (piem., `my_app.py`) un palaidiet to. Jums vajadzētu redzēt tukšu logu ar virsrakstu "My First Tkinter Application".

Tkinter logrīki: Jūsu GUI pamatelementi

Logrīki ir atsevišķi elementi, kas veido jūsu GUI, piemēram, pogas, etiķetes, teksta lauki un citi. Tkinter nodrošina plašu logrīku klāstu interaktīvu lietotņu veidošanai.

Biežāk sastopamie Tkinter logrīki

• Label (Etiķete): Rāda statisku tekstu vai attēlus.
• Button (Poga): Izsauc darbību, kad uz tās noklikšķina.
• Entry (Ievades lauks): Ļauj lietotājiem ievadīt vienas rindiņas tekstu.
• Text (Teksta lauks): Ļauj lietotājiem ievadīt vairāku rindiņu tekstu.
• Frame (Rāmis): Darbojas kā konteiners citiem logrīkiem, palīdzot ar organizāciju un izkārtojumu.
• Checkbutton (Izvēles rūtiņa): Pārstāv Būla opciju, kuru var ieslēgt vai izslēgt.
• Radiobutton (Radio poga): Ļauj lietotājiem izvēlēties vienu opciju no grupas.
• Listbox (Sarakstlodziņš): Parāda vienumu sarakstu, no kura lietotājs var izvēlēties.
• Combobox (Kombinētais lodziņš): Nolaižamais saraksts, kas ļauj lietotājiem izvēlēties opciju no iepriekš definēta komplekta.
• Canvas (Audekls): Nodrošina zīmēšanas virsmu pielāgotu grafiku un vizualizāciju veidošanai.

Logrīku pievienošana logam

Lai pievienotu logrīkus savam logam, jums jāizveido logrīku klašu instances un pēc tam jāievieto tās logā, izmantojot izkārtojuma pārvaldniekus (paskaidroti nākamajā sadaļā).

            import tkinter as tk

root = tk.Tk()
root.title("Adding Widgets")
root.geometry("400x300")

# Create a Label widget
label = tk.Label(root, text="Hello, Tkinter!")

# Create a Button widget
button = tk.Button(root, text="Click Me!")

# Create an Entry widget
entry = tk.Entry(root)

# Place the widgets in the window
label.pack()
button.pack()
entry.pack()

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `label = tk.Label(root, text="Hello, Tkinter!")`: Izveido Label logrīku ar tekstu "Hello, Tkinter!" un ievieto to `root` logā.
• `button = tk.Button(root, text="Click Me!")`: Izveido Button logrīku ar tekstu "Click Me!" un ievieto to `root` logā.
• `entry = tk.Entry(root)`: Izveido Entry logrīku (teksta ievades lauku) un ievieto to `root` logā.
• `label.pack()`, `button.pack()`, `entry.pack()`: Izmanto `pack()` izkārtojuma pārvaldnieku, lai sakārtotu logrīkus logā. `pack()` pārvaldnieks vienkārši novieto logrīkus vienu pēc otra, vertikāli vai horizontāli.

Izkārtojuma pārvaldnieki: Logrīku kārtošana jūsu GUI

Izkārtojuma pārvaldnieki ir būtiski, lai kontrolētu logrīku pozīciju un izmēru jūsu logā. Tkinter piedāvā trīs galvenos izkārtojuma pārvaldniekus:

• `pack()`: Vienkāršākais izkārtojuma pārvaldnieks, kas sakārto logrīkus bloku veidā, vertikāli vai horizontāli.
• `grid()`: Sakārto logrīkus režģī (rindās un kolonnās), ļaujot precīzāku izvietojumu.
• `place()`: Ļauj norādīt precīzas katra logrīka koordinātas (x, y) un izmēru (platums, augstums), sniedzot vislielāko kontroli pār izvietojumu, bet arī prasot vairāk manuāla darba.

`pack()` izkārtojuma pārvaldnieks

Kā parādīts iepriekšējā piemērā, `pack()` ir visvieglāk lietojamais izkārtojuma pārvaldnieks. Tas ir piemērots vienkāršiem izkārtojumiem, kur logrīkus var sakārtot vienkāršā veidā.

            import tkinter as tk

root = tk.Tk()
root.title("Pack Layout")
root.geometry("400x300")

label1 = tk.Label(root, text="Label 1", bg="red")
label2 = tk.Label(root, text="Label 2", bg="green")
label3 = tk.Label(root, text="Label 3", bg="blue")

label1.pack(fill=tk.X)
label2.pack(side=tk.LEFT, fill=tk.Y)
label3.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `fill=tk.X`: Liek etiķetei aizpildīt visu loga platumu pa X asi.
• `side=tk.LEFT`: Novieto etiķeti loga kreisajā pusē.
• `fill=tk.Y`: Liek etiķetei aizpildīt visu pieejamās vietas augstumu pa Y asi.
• `fill=tk.BOTH`: Liek etiķetei aizpildīt visu pieejamo vietu gan X, gan Y asīs.
• `expand=True`: Ļauj etiķetei izplesties un aizņemt jebkuru atlikušo vietu logā.

`grid()` izkārtojuma pārvaldnieks

`grid()` izkārtojuma pārvaldnieks nodrošina strukturētāku veidu logrīku kārtošanai. Jūs varat norādīt katra logrīka rindu un kolonnu, veidojot režģim līdzīgu izkārtojumu.

            import tkinter as tk

root = tk.Tk()
root.title("Grid Layout")
root.geometry("400x300")

label1 = tk.Label(root, text="Name:")
entry1 = tk.Entry(root)
label2 = tk.Label(root, text="Email:")
entry2 = tk.Entry(root)
button = tk.Button(root, text="Submit")

label1.grid(row=0, column=0, sticky=tk.W)
entry1.grid(row=0, column=1)
label2.grid(row=1, column=0, sticky=tk.W)
entry2.grid(row=1, column=1)
button.grid(row=2, column=1, sticky=tk.E)

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `row=0, column=0`: Novieto logrīku režģa pirmajā rindā un pirmajā kolonnā.
• `sticky=tk.W`: Pielīdzina logrīku tā šūnas rietumu (kreisajai) pusei. Citas opcijas ietver `tk.E` (austrumi/pa labi), `tk.N` (ziemeļi/augšā), `tk.S` (dienvidi/apakšā) un kombinācijas, piemēram, `tk.NW` (ziemeļrietumi/augšā pa kreisi).

`place()` izkārtojuma pārvaldnieks

`place()` izkārtojuma pārvaldnieks sniedz jums visprecīzāko kontroli pār logrīku izvietojumu, ļaujot norādīt precīzas katra logrīka x un y koordinātas, kā arī platumu un augstumu.

            import tkinter as tk

root = tk.Tk()
root.title("Place Layout")
root.geometry("400x300")

label = tk.Label(root, text="Precise Placement", bg="yellow")
button = tk.Button(root, text="Click Here", bg="lightgreen")

label.place(x=50, y=50, width=150, height=30)
button.place(x=200, y=100, width=100, height=40)

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `x=50, y=50`: Novieto logrīka augšējo kreiso stūri koordinātās (50, 50) attiecībā pret loga augšējo kreiso stūri.
• `width=150, height=30`: Iestata logrīka platumu uz 150 pikseļiem un augstumu uz 30 pikseļiem.

Notikumu apstrāde: padariet savu lietotni interaktīvu

Notikumu apstrāde ir process, kurā tiek reaģēts uz lietotāja darbībām, piemēram, pogu klikšķiem, taustiņu nospiešanu un peles kustībām. Tkinter izmanto notikumu piesaistes (event bindings), lai savienotu logrīkus ar konkrētām darbībām.

Notikumu piesaiste logrīkiem

Jūs varat piesaistīt notikumus logrīkiem, izmantojot `bind()` metodi. Šī metode pieņem divus argumentus: notikuma veidu (piem., `` kreisās peles pogas klikšķim) un funkciju, kas jāizsauc, kad notikums notiek.

            import tkinter as tk

def button_clicked(event):
 print("Button clicked!")

root = tk.Tk()
root.title("Event Handling")
root.geometry("300x200")

button = tk.Button(root, text="Click Me")
button.bind("", button_clicked)
button.pack()

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `def button_clicked(event):`: Definē funkciju, kas tiks izsaukta, kad poga tiks noklikšķināta. `event` arguments satur informāciju par notikumu.
• `button.bind("", button_clicked)`: Piesaista kreisās peles pogas klikšķa notikumu (``) funkcijai `button_clicked`.

Biežākie notikumu veidi

• ``: Kreisās peles pogas klikšķis.
• ``: Vidējās peles pogas klikšķis.
• ``: Labās peles pogas klikšķis.
• ``: Jebkura taustiņa nospiešana.
• ``: 'A' taustiņa nospiešana. Aizstājiet 'A' ar jebkuru citu taustiņu.
• ``: Enter taustiņa nospiešana.
• ``: Logrīks iegūst fokusu.
• ``: Logrīks zaudē fokusu.
• ``: Peles kustība logrīka ietvaros.
• ``: Pele ieiet logrīka apgabalā.
• ``: Pele pamet logrīka apgabalu.

Piemērs: Etiķetes atjaunināšana, noklikšķinot uz pogas

Izveidosim piemēru, kur, noklikšķinot uz pogas, tiek atjaunināts etiķetes teksts.

            import tkinter as tk

def update_label(event):
 label.config(text="Button Clicked!")

root = tk.Tk()
root.title("Update Label")
root.geometry("300x200")

label = tk.Label(root, text="Click the button below")
button = tk.Button(root, text="Click Me")

button.bind("", update_label)

label.pack()
button.pack()

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `label.config(text="Button Clicked!")`: Maina etiķetes tekstu uz "Button Clicked!", izmantojot `config()` metodi.

Padziļināti Tkinter jēdzieni

Kad esat apguvis Tkinter pamatus, varat izpētīt sarežģītākus jēdzienus, lai izveidotu sarežģītākas lietotnes.

Dialoglodziņi un ziņojumu lodziņi

Tkinter nodrošina iebūvētus dialoglodziņus un ziņojumu lodziņus informācijas parādīšanai, lietotāja ievades pieprasīšanai un kļūdu apstrādei. Šie dialoglodziņi ir modāli, kas nozīmē, ka tie bloķē mijiedarbību ar galveno logu, līdz tie tiek aizvērti.

            import tkinter as tk
from tkinter import messagebox

def show_message():
 messagebox.showinfo("Information", "This is an information message.")

def ask_question():
 answer = messagebox.askquestion("Question", "Are you sure?")
 if answer == "yes":
 print("User said yes")
 else:
 print("User said no")

root = tk.Tk()
root.title("Dialogs")
root.geometry("300x200")

button1 = tk.Button(root, text="Show Message", command=show_message)
button2 = tk.Button(root, text="Ask Question", command=ask_question)

button1.pack()
button2.pack()

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `from tkinter import messagebox`: Importē `messagebox` moduli, kas satur dialoga funkcijas.
• `messagebox.showinfo("Information", "This is an information message.")`: Parāda informācijas ziņojuma lodziņu ar virsrakstu "Information" un ziņojumu "This is an information message."
• `messagebox.askquestion("Question", "Are you sure?")`: Parāda jautājuma ziņojuma lodziņu ar virsrakstu "Question" un ziņojumu "Are you sure?". Lietotājs var atbildēt "yes" vai "no."

Izvēlnes

Izvēlnes nodrošina strukturētu veidu, kā organizēt komandas un opcijas jūsu lietotnē. Jūs varat izveidot izvēlņu joslas, nolaižamās izvēlnes un konteksta izvēlnes.

            import tkinter as tk

def do_nothing():
 print("Do nothing")

root = tk.Tk()
root.title("Menus")
root.geometry("400x300")

# Create a menu bar
menubar = tk.Menu(root)

# Create a File menu
filemenu = tk.Menu(menubar, tearoff=0)
filemenu.add_command(label="New", command=do_nothing)
filemenu.add_command(label="Open", command=do_nothing)
filemenu.add_command(label="Save", command=do_nothing)
filemenu.add_separator()
filemenu.add_command(label="Exit", command=root.quit)

# Add the File menu to the menu bar
menubar.add_cascade(label="File", menu=filemenu)

# Create an Edit menu
editmenu = tk.Menu(menubar, tearoff=0)
editmenu.add_command(label="Undo", command=do_nothing)
editmenu.add_command(label="Redo", command=do_nothing)

# Add the Edit menu to the menu bar
menubar.add_cascade(label="Edit", menu=editmenu)

# Configure the root window to use the menu bar
root.config(menu=menubar)

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `menubar = tk.Menu(root)`: Izveido izvēļņu joslas logrīku.
• `filemenu = tk.Menu(menubar, tearoff=0)`: Izveido Failu (File) izvēlni kā izvēļņu joslas bērnelementu. `tearoff=0` arguments neļauj izvēlni "atraut" atsevišķā logā.
• `filemenu.add_command(label="New", command=do_nothing)`: Pievieno Failu izvēlnei komandu ar etiķeti "New" un komandu `do_nothing`.
• `filemenu.add_separator()`: Pievieno atdalītājlīniju Failu izvēlnei.
• `menubar.add_cascade(label="File", menu=filemenu)`: Pievieno Failu izvēlni izvēļņu joslai.
• `root.config(menu=menubar)`: Konfigurē saknes logu, lai tas izmantotu izvēļņu joslu.

Canvas (audekla) logrīks

Canvas logrīks ļauj jums zīmēt pielāgotas grafikas, formas un tekstu jūsu lietotnē. Tas ir spēcīgs rīks vizualizāciju, spēļu un citu grafisko saskarņu veidošanai.

            import tkinter as tk

root = tk.Tk()
root.title("Canvas")
root.geometry("400x300")

canvas = tk.Canvas(root, width=400, height=300, bg="white")

# Draw a rectangle
canvas.create_rectangle(50, 50, 150, 100, fill="blue")

# Draw a circle
canvas.create_oval(200, 50, 250, 100, fill="red")

# Draw a line
canvas.create_line(50, 150, 350, 150, width=3, fill="green")

# Draw text
canvas.create_text(200, 250, text="Hello, Canvas!", font=("Arial", 16))

canvas.pack()

root.mainloop()
            

              
                Copy
              
            
          

Paskaidrojums:

• `canvas = tk.Canvas(root, width=400, height=300, bg="white")`: Izveido Canvas logrīku ar platumu 400 pikseļi, augstumu 300 pikseļi un baltu fonu.
• `canvas.create_rectangle(50, 50, 150, 100, fill="blue")`: Zīmē taisnstūri, kura augšējais kreisais stūris ir (50, 50) un apakšējais labais stūris ir (150, 100), aizpildītu ar zilu krāsu.
• `canvas.create_oval(200, 50, 250, 100, fill="red")`: Zīmē ovālu (apli) ierobežojošā rāmī, ko nosaka augšējais kreisais stūris (200, 50) un apakšējais labais stūris (250, 100), aizpildītu ar sarkanu krāsu.
• `canvas.create_line(50, 150, 350, 150, width=3, fill="green")`: Zīmē līniju no punkta (50, 150) uz punktu (350, 150) ar platumu 3 pikseļi un zaļu krāsu.
• `canvas.create_text(200, 250, text="Hello, Canvas!", font=("Arial", 16))`: Zīmē tekstu "Hello, Canvas!" koordinātās (200, 250), izmantojot Arial fontu ar izmēru 16.

Labākās prakses Tkinter izstrādē

Lai izveidotu uzturējamas un mērogojamas Tkinter lietotnes, ievērojiet šādas labākās prakses:

• Izmantojiet objektorientēto programmēšanu (OOP): Organizējiet savu kodu klasēs un objektos, lai uzlabotu struktūru un atkārtotu izmantošanu.
• Atdaliet GUI loģiku no biznesa loģikas: Turiet savu GUI kodu atsevišķi no koda, kas apstrādā jūsu lietotnes pamatfunkcionalitāti. Tas padara jūsu kodu modulārāku un vieglāk testējamu.
• Izmantojiet konsekventu kodēšanas stilu: Ievērojiet konsekventu kodēšanas stilu (piem., PEP 8), lai uzlabotu lasāmību un uzturamību.
• Pievienojiet komentārus: Pievienojiet komentārus savam kodam, lai paskaidrotu, ko tas dara un kāpēc. Tas palīdzēs jums un citiem saprast jūsu kodu nākotnē.
• Izmantojiet versiju kontroli: Izmantojiet versiju kontroles sistēmu (piem., Git), lai sekotu līdzi koda izmaiņām un sadarbotos ar citiem.
• Apsveriet internacionalizāciju (i18n) un lokalizāciju (l10n): Ja jūsu lietotne ir paredzēta globālai auditorijai, apsveriet iespēju internacionalizēt un lokalizēt savu lietotni, lai atbalstītu dažādas valodas un kultūras. Tas ietver Unikoda izmantošanu tekstam un tulkojumu nodrošināšanu visiem teksta elementiem jūsu GUI. Piemēram, jūs varētu ļaut lietotājam izvēlēties vēlamo valodu no iestatījumu izvēlnes un pēc tam ielādēt atbilstošos tulkojumu failus.

Starptautiski piemēri un apsvērumi

Izstrādājot Tkinter lietotnes globālai auditorijai, ir svarīgi ņemt vērā reģionālās atšķirības un kultūras nianses. Šeit ir daži piemēri:

• Datuma un laika formāti: Dažādās valstīs tiek izmantoti dažādi datuma un laika formāti. Izmantojiet Python `datetime` moduli un lokalizācijas iestatījumus, lai formatētu datumus un laikus atbilstoši lietotāja lokalizācijai. Piemēram, Amerikas Savienotajās Valstīs datuma formāts parasti ir MM/DD/GGGG, savukārt Eiropā tas bieži ir DD/MM/GGGG.
• Valūtas formāti: Izmantojiet `locale` moduli, lai formatētu valūtas vērtības atbilstoši lietotāja lokalizācijai. Dažādās valstīs tiek izmantoti dažādi valūtas simboli un decimālie atdalītāji.
• Teksta virziens: Dažas valodas, piemēram, arābu un ebreju, tiek rakstītas no labās uz kreiso pusi. Tkinter atbalsta teksta virzienu no labās uz kreiso, izmantojot opciju `orient` logrīkiem.
• Rakstzīmju kodējums: Izmantojiet Unikodu (UTF-8) visam tekstam savā lietotnē, lai atbalstītu plašu rakstzīmju klāstu no dažādām valodām.
• Skaitļu formatēšana: Pievērsiet uzmanību dažādām konvencijām, kas tiek izmantotas skaitļu attēlošanai. Piemēram, dažās lokalizācijās komatus izmanto kā decimālos atdalītājus un punktus, lai grupētu tūkstošus, savukārt citās dara pretējo.
• Lietotāja saskarnes dizains: Veidojot lietotāja saskarni, ņemiet vērā kultūras preferences. Krāsām, simboliem un attēliem var būt dažādas nozīmes dažādās kultūrās. Kultūras jutīguma izpēte var palīdzēt izvairīties no netīša aizvainojuma.

Alternatīvas Tkinter

Lai gan Tkinter ir stabila izvēle daudziem Python GUI projektiem, ir pieejamas vairākas citas GUI bibliotēkas, katrai ar savām stiprajām un vājajām pusēm. Šeit ir dažas ievērojamas alternatīvas:

• PyQt: Jaudīga un funkcijām bagāta GUI bibliotēka, kas balstīta uz Qt ietvaru. PyQt piedāvā plašu logrīku un rīku klāstu sarežģītu un vizuāli pievilcīgu lietotņu veidošanai. Tā ir komerciāla bibliotēka, bet atvērtā koda projektiem ir pieejama GPL versija.
• wxPython: Vēl viena populāra starpplatformu GUI bibliotēka, kas nodrošina dabisku izskatu un sajūtu dažādās operētājsistēmās. wxPython ir pazīstams ar savu plašo logrīku komplektu un spēju veidot lietotnes, kas nevainojami integrējas ar pamatā esošo platformu.
• Kivy: Starpplatformu GUI ietvars, kas paredzēts modernu, skārienjutīgu lietotņu veidošanai. Kivy izmanto pielāgotu UI valodu (Kv) un atbalsta aparatūras paātrinājumu vienmērīgai veiktspējai.
• Gtk+: Plaši izmantots starpplatformu rīkkopa grafisko lietotāja saskarņu veidošanai. Lai gan tā nav specifiska Python, tai ir Python piesaistes, ko sauc par PyGObject, kas ļauj izstrādāt GTK+ lietotnes, izmantojot Python. Bieži tiek izmantota Linux lietotnēm.
• PySimpleGUI: Bibliotēka, kas mēģina vienkāršot GUI lietotņu izveidi. Tā atbalsta Tkinter, Qt, WxPython un Remi kā aizmugursistēmas, ļaujot mainīt saskarni ar ierobežotām koda izmaiņām.

Noslēgums

Tkinter nodrošina vienkāršu un pieejamu veidu, kā veidot darbvirsmas lietotnes ar Python. Tā vienkāršība, starpplatformu saderība un iekļaušana Python standarta bibliotēkā padara to par lielisku izvēli gan iesācējiem, gan pieredzējušiem izstrādātājiem. Apgūstot šajā ceļvedī aplūkotos jēdzienus, jūs būsiet labi sagatavots, lai veidotu plašu GUI lietotņu klāstu, sākot no vienkāršiem rīkiem līdz sarežģītiem datu vizualizācijas rīkiem. Atcerieties, veidojot lietotnes, ņemt vērā globālo auditoriju un pielāgot tās dažādām lokalizācijām un kultūrām.

Eksperimentējiet ar sniegtajiem piemēriem, izpētiet Tkinter dokumentāciju un veidojiet savus projektus, lai nostiprinātu savas zināšanas. Veiksmīgu kodēšanu!