tkinter — Python-gränssnitt till Tcl/Tk

Källkod: Lib/tkinter/__init__.py

Paketet tkinter (”Tk-gränssnittet”) är Pythons standardgränssnitt till GUI-verktygslådan Tcl/Tk. Både Tk och tkinter finns tillgängliga på de flesta Unix-plattformar, inklusive macOS, samt på Windows-system.

Om du kör python -m tkinter från kommandoraden öppnas ett fönster som visar ett enkelt Tk-gränssnitt, så att du vet att tkinter är korrekt installerat på ditt system, och det visas också vilken version av Tcl/Tk som är installerad, så att du kan läsa Tcl/Tk-dokumentationen som är specifik för den versionen.

Tkinter stöder en rad olika Tcl/Tk-versioner, byggda antingen med eller utan trådstöd. Den officiella binära Python-utgåvan innehåller Tcl/Tk 8.6 med trådar. Se källkoden för modulen _tkinter för mer information om vilka versioner som stöds.

Tkinter är inte bara en tunn omslagslösning, utan lägger till en hel del egen logik för att göra upplevelsen mer pythonisk. Den här dokumentationen kommer att koncentrera sig på dessa tillägg och ändringar, och hänvisa till den officiella Tcl/Tk-dokumentationen för detaljer som är oförändrade.

Anteckning

Tcl/Tk 8.5 (2007) introducerade en modern uppsättning av tematiserade användargränssnittskomponenter tillsammans med ett nytt API för att använda dem. Både gamla och nya API:er är fortfarande tillgängliga. Den mesta dokumentationen som du hittar online använder fortfarande det gamla API:et och kan vara väldigt föråldrad.

Se även

  • TkDocs

    Omfattande handledning om hur man skapar användargränssnitt med Tkinter. Förklarar viktiga begrepp och illustrerar rekommenderade tillvägagångssätt med hjälp av det moderna API:et.

  • Tkinter 8.5-referens: ett GUI för Python

    Referensdokumentation för Tkinter 8.5 som beskriver tillgängliga klasser, metoder och alternativ.

Tcl/Tk-resurser:

  • Tk-kommandon

    Omfattande referens till var och en av de underliggande Tcl/Tk-kommandon som används av Tkinter.

  • Tcl/Tk webbplats

    Ytterligare dokumentation och länkar till utveckling av Tcl/Tk-kärnan.

Böcker:

Arkitektur

Tcl/Tk är inte ett enda bibliotek utan består snarare av några olika moduler, var och en med separata funktioner och sin egen officiella dokumentation. Pythons binära utgåvor skickar också med en tilläggsmodul tillsammans med den.

Tcl

Tcl är ett dynamiskt tolkat programmeringsspråk, precis som Python. Även om det kan användas på egen hand som ett allmänt programmeringsspråk, är det vanligast att det bäddas in i C-program som en skriptmotor eller ett gränssnitt till Tk-verktygslådan. Tcl-biblioteket har ett C-gränssnitt för att skapa och hantera en eller flera instanser av en Tcl-tolk, köra Tcl-kommandon och skript i dessa instanser och lägga till anpassade kommandon som implementeras i antingen Tcl eller C. Varje tolk har en händelsekö och det finns funktioner för att skicka händelser till den och bearbeta dem. Till skillnad från Python är Tcl:s exekveringsmodell utformad kring kooperativ multitasking, och Tkinter överbryggar denna skillnad (se Threading model för detaljer).

Tk

Tk är ett Tcl-paket implementerat i C som lägger till anpassade kommandon för att skapa och manipulera GUI-widgets. Varje Tk-objekt bäddar in sin egen Tcl-tolkinstans med Tk laddat i sig. Tk:s widgets är mycket anpassningsbara, men till priset av ett daterat utseende. Tk använder Tcl:s händelsekö för att generera och bearbeta GUI-händelser.

Ttk

Themed Tk (Ttk) är en nyare familj av Tk-widgetar som ger ett mycket bättre utseende på olika plattformar än många av de klassiska Tk-widgetarna. Ttk distribueras som en del av Tk, från och med Tk version 8.5. Python-bindningar finns i en separat modul, tkinter.ttk.

Internt använder Tk och Ttk faciliteter i det underliggande operativsystemet, t.ex. Xlib på Unix/X11, Cocoa på macOS, GDI på Windows.

När ditt Python-program använder en klass i Tkinter, t.ex. för att skapa en widget, sammanställer tkinter-modulen först en Tcl/Tk-kommandosträng. Den skickar Tcl-kommandosträngen till en intern _tkinter binär modul, som sedan anropar Tcl-tolken för att utvärdera den. Tcl-tolken anropar sedan paketen Tk och/eller Ttk, som i sin tur gör anrop till Xlib, Cocoa eller GDI.

Tkinter-moduler

Stödet för Tkinter är fördelat på flera moduler. De flesta program behöver huvudmodulen tkinter samt modulen tkinter.ttk, som tillhandahåller den moderna widgetuppsättningen och API:

från tkinter import *
från tkinter import ttk
class tkinter.Tk(screenName=None, baseName=None, className='Tk', useTk=True, sync=False, use=None)

Konstruera en Tk-widget på toplevel-nivå, som vanligtvis är huvudfönstret i ett program, och initiera en Tcl-tolk för denna widget. Varje instans har sin egen associerade Tcl-tolk.

Klassen Tk instansieras normalt med alla standardvärden. Följande nyckelordsargument känns dock igen för närvarande:

skärmNamn

När den anges (som en sträng), ställer den in miljövariabeln DISPLAY. (endast X11)

basNamn

Namnet på profilfilen. Som standard härleds baseName från programnamnet (sys.argv[0]).

klassnamn

Namnet på widgetklassen. Används som en profilfil och även som det namn som Tcl anropas med (argv0 i interp).

användningTk

Om True, initiera Tk-undersystemet. Funktionen tkinter.Tcl() sätter detta till False.

synk

Om True, körs alla X-serverkommandon synkront, så att fel rapporteras omedelbart. Kan användas för felsökning. (Endast X11)

använda

Anger id för det fönster som programmet ska bäddas in i, istället för att det skapas som ett oberoende toplevel-fönster. id måste anges på samma sätt som värdet för alternativet -use för toplevel-widgets (dvs. det måste ha samma form som det som returneras av winfo_id()).

Observera att på vissa plattformar fungerar detta endast korrekt om id hänvisar till en Tk-ram eller toplevel som har alternativet -container aktiverat.

Tk läser och tolkar profilfiler, som heter .className.tcl och .baseName.tcl, i Tcl-tolken och anropar exec() på innehållet i .className.py och .baseName.py. Sökvägen till profilfilerna är miljövariabeln HOME eller, om den inte är definierad, os.curdir.

tk

Tk-applikationsobjektet som skapas genom instansiering av Tk. Detta ger tillgång till Tcl-tolken. Varje widget som är kopplad till samma instans av Tk har samma värde för sitt attribut tk.

master

Det widgetobjekt som innehåller denna widget. För Tk är master None eftersom det är huvudfönstret. Termerna master och parent är snarlika och används ibland synonymt som argumentnamn, men anrop av winfo_parent() returnerar en sträng med widgetens namn medan master returnerar objektet. parent/child återspeglar den trädliknande relationen medan master/slave återspeglar containerstrukturen.

children

De närmaste ättlingarna till denna widget som en dict med namnen på underordnade widgetar som nycklar och underordnade instansobjekt som värden.

tkinter.Tcl(screenName=None, baseName=None, className='Tk', useTk=False)

Funktionen Tcl() är en fabriksfunktion som skapar ett objekt ungefär som det som skapas av klassen Tk, förutom att den inte initierar Tk-undersystemet. Detta är oftast användbart när man kör Tcl-tolken i en miljö där man inte vill eller kan skapa ovidkommande toplevel-fönster (t.ex. Unix/Linux-system utan X-server). Ett objekt som skapats av Tcl()-objektet kan få ett Toplevel-fönster skapat (och Tk-undersystemet initialiserat) genom att anropa dess loadtk()-metod.

De moduler som ger stöd för Tk inkluderar:

tkinter

Huvudmodul för Tkinter.

tkinter.colorchooser

Dialog för att låta användaren välja en färg.

tkinter.commondialog

Basklass för de dialogrutor som definieras i de andra modulerna som listas här.

tkinter.filedialog

Vanliga dialogrutor där användaren kan ange en fil som ska öppnas eller sparas.

tkinter.font

Verktyg för att underlätta arbetet med teckensnitt.

tkinter.messagebox

Tillgång till Tk:s standarddialogrutor.

tkinter.scrolledtext

Textwidget med inbyggd vertikal rullningslist.

tkinter.simpledialog

Grundläggande dialoger och bekvämlighetsfunktioner.

tkinter.ttk

Tematisk widgetuppsättning som introducerades i Tk 8.5 och som ger moderna alternativ för många av de klassiska widgetarna i huvudmodulen tkinter.

Ytterligare moduler:

_tkinter

En binär modul som innehåller lågnivågränssnittet till Tcl/Tk. Den importeras automatiskt av huvudmodulen tkinter och bör aldrig användas direkt av applikationsprogrammerare. Det är vanligtvis ett delat bibliotek (eller DLL), men kan i vissa fall vara statiskt länkad med Python-tolken.

idlelib

Pythons integrerade utvecklings- och inlärningsmiljö (IDLE). Baserat på tkinter.

tkinter.constants

Symboliska konstanter som kan användas i stället för strängar när olika parametrar skickas till Tkinter-anrop. Importeras automatiskt av huvudmodulen tkinter.

tkinter.dnd

(experimentell) Stöd för dra-och-släpp för tkinter. Detta kommer att bli föråldrat när det ersätts med Tk DND.

sköldpadda

Turtle-grafik i ett Tk-fönster.

Tkinter Life Preserver

Detta avsnitt är inte avsett att vara en uttömmande handledning om vare sig Tk eller Tkinter. För detta hänvisas till någon av de externa resurser som nämnts tidigare. Istället ger detta avsnitt en mycket snabb orientering om hur en Tkinter-applikation ser ut, identifierar grundläggande Tk-koncept och förklarar hur Tkinter-wrappern är uppbyggd.

Resten av detta avsnitt hjälper dig att identifiera de klasser, metoder och alternativ som du behöver i din Tkinter-applikation och var du hittar mer detaljerad dokumentation om dem, inklusive i den officiella Tcl/Tk-referenshandboken.

Ett Hello World-program

Vi börjar med att gå igenom en ”Hello World”-applikation i Tkinter. Det är inte det minsta vi kan skriva, men det räcker för att illustrera några viktiga begrepp som du behöver känna till.

från tkinter import *
från tkinter import ttk
rot = Tk()
frm = ttk.Frame(rot, utfyllnad=10)
frm.grid()
ttk.Label(frm, text="Hello World!").grid(kolumn=0, rad=0)
ttk.Button(frm, text="Avsluta", command=root.destroy).grid(kolumn=1, rad=0)
root.mainloop()

Efter importen skapas på nästa rad en instans av klassen Tk, som initierar Tk och skapar den tillhörande Tcl-tolken. Den skapar också ett toplevel-fönster, känt som rotfönstret, som fungerar som huvudfönster för applikationen.

Följande rad skapar en ramwidget, som i det här fallet kommer att innehålla en etikett och en knapp som vi ska skapa härnäst. Ramen placeras inuti rotfönstret.

På nästa rad skapas en etikettwidget som innehåller en statisk textsträng. Metoden grid() används för att ange den relativa layouten (positionen) för etiketten inom den ramwidget som innehåller den, på samma sätt som tabeller i HTML fungerar.

En knappwidget skapas sedan och placeras till höger om etiketten. När du trycker på den kommer den att anropa metoden destroy() i rotfönstret.

Slutligen visar metoden mainloop() allt på skärmen och svarar på användarens inmatningar tills programmet avslutas.

Viktiga Tk-koncept

Även detta enkla program illustrerar följande viktiga Tk-koncept:

widgets

Ett Tkinter-användargränssnitt består av individuella widgets. Varje widget representeras som ett Python-objekt, instansierat från klasser som ttk.Frame, ttk.Label och ttk.Button.

widget-hierarki

Widgets är ordnade i en hierarki. Etiketten och knappen var placerade i en ram, som i sin tur var placerad i rotfönstret. När varje barn-widget skapas, skickas dess förälder-widget som det första argumentet till widgetkonstruktören.

konfigurationsalternativ

Widgetar har konfigurationsalternativ som ändrar deras utseende och beteende, t.ex. vilken text som ska visas i en etikett eller knapp. Olika klasser av widgetar har olika uppsättningar av alternativ.

geometrihantering

Widgets läggs inte automatiskt till i användargränssnittet när de skapas. En geometrihanterare som grid styr var i användargränssnittet de placeras.

händelseslinga

Tkinter reagerar på användarinmatning, ändringar från ditt program och uppdaterar till och med skärmen endast när en händelseslinga körs aktivt. Om ditt program inte kör händelseslingan uppdateras inte ditt användargränssnitt.

Förstå hur Tkinter omsluter Tcl/Tk

När ditt program använder Tkinters klasser och metoder samlar Tkinter internt ihop strängar som representerar Tcl/Tk-kommandon och kör dessa kommandon i Tcl-tolken som är kopplad till ditt programs Tk-instans.

Oavsett om det handlar om att navigera i referensdokumentation, försöka hitta rätt metod eller alternativ, anpassa befintlig kod eller felsöka din Tkinter-applikation, finns det tillfällen då det är användbart att förstå hur de underliggande Tcl/Tk-kommandona ser ut.

För att illustrera detta följer här Tcl/Tk-motsvarigheten till huvuddelen av Tkinter-skriptet ovan.

ttk::frame .frm -utfyllnad 10
rutnät .frm
grid [ttk::label .frm.lbl -text "Hello World!"] -kolumn 0 -rad 0
grid [ttk::button .frm.btn -text "Avsluta" -kommando "förstör ."] -kolumn 1 -rad 0

Tcl:s syntax liknar många skalspråk, där det första ordet är kommandot som ska utföras, och argumenten till kommandot följer efter, åtskilda med mellanslag. Utan att gå in på alltför många detaljer kan man notera följande:

  • De kommandon som används för att skapa widgetar (som ttk::frame) motsvarar widgetklasser i Tkinter.

  • Tcl-widgetalternativ (som -text) motsvarar nyckelordsargument i Tkinter.

  • Widgets refereras till med ett pathname i Tcl (som .frm.btn), medan Tkinter inte använder namn utan objektreferenser.

  • En widgets plats i widgethierarkin kodas i dess (hierarkiska) sökvägsnamn, som använder en . (punkt) som sökvägsavgränsare. Sökvägsnamnet för rotfönstret är bara . (punkt). I Tkinter definieras hierarkin inte av sökvägsnamnet utan genom att ange den överordnade widgeten när varje underordnad widget skapas.

  • Operationer som implementeras som separata kommandon i Tcl (som grid eller destroy) representeras som metoder på Tkinters widgetobjekt. Som du snart kommer att se använder Tcl vid andra tillfällen vad som verkar vara metodanrop på widgetobjekt, vilket mer speglar vad som används i Tkinter.

Hur gör jag…? Vilket alternativ gör…?

Om du är osäker på hur du ska göra något i Tkinter och inte hittar det direkt i den handledning eller referensdokumentation du använder finns det några strategier som kan vara till hjälp.

Kom först ihåg att detaljerna i hur enskilda widgetar fungerar kan variera mellan olika versioner av både Tkinter och Tcl/Tk. Om du söker efter dokumentation, se till att den motsvarar de Python- och Tcl/Tk-versioner som är installerade på ditt system.

När du söker efter hur du använder ett API hjälper det att veta det exakta namnet på den klass, det alternativ eller den metod som du använder. Introspektion, antingen i ett interaktivt Python-skal eller med print(), kan hjälpa dig att identifiera vad du behöver.

För att ta reda på vilka konfigurationsalternativ som är tillgängliga för en widget, anropa dess configure()-metod, som returnerar en ordbok som innehåller en mängd information om varje objekt, inklusive dess standardvärden och aktuella värden. Använd keys() för att bara få namnen på varje alternativ.

btn = ttk.knapp(frm, ...)
print(btn.configure().keys())

Eftersom de flesta widgetar har många gemensamma konfigurationsalternativ kan det vara bra att ta reda på vilka som är specifika för en viss widgetklass. Ett sätt att göra det är att jämföra listan med alternativ för en enklare widget, t.ex. en ram.

print(set(btn.configure().keys()) - set(frm.configure().keys()))

På samma sätt kan du hitta de tillgängliga metoderna för ett widgetobjekt med hjälp av standardfunktionen dir(). Om du provar den kommer du att se att det finns över 200 vanliga widgetmetoder, så återigen är det bra att identifiera de som är specifika för en widgetklass.

print(dir(btn))
print(set(dir(btn)) - set(dir(frm)))

Gängningsmodell

Python och Tcl/Tk har mycket olika trådningsmodeller, som tkinter försöker överbrygga. Om du använder trådar kan du behöva vara medveten om detta.

En Python-tolk kan ha många trådar kopplade till sig. I Tcl kan flera trådar skapas, men varje tråd har en separat Tcl-tolkinstans associerad med sig. Trådar kan också skapa mer än en tolkinstans, men varje tolkinstans kan bara användas av den tråd som skapade den.

Varje Tk-objekt som skapas av tkinter innehåller en Tcl-tolk. Den håller också reda på vilken tråd som skapade den tolken. Anrop till tkinter kan göras från vilken Python-tråd som helst. Internt, om ett anrop kommer från en annan tråd än den som skapade Tk-objektet, skickas en händelse till tolkens händelsekö, och när den exekveras returneras resultatet till den anropande Python-tråden.

Tcl/Tk-applikationer är normalt händelsestyrda, vilket innebär att tolken efter initialiseringen kör en händelseslinga (t.ex. Tk.mainloop()) och svarar på händelser. Eftersom den är entrådig måste händelsehanterare reagera snabbt, annars blockerar de andra händelser från att behandlas. För att undvika detta bör alla långdragna beräkningar inte köras i en händelsehanterare, utan antingen delas upp i mindre delar med hjälp av timers eller köras i en annan tråd. Detta skiljer sig från många GUI toolkits där GUI körs i en helt separat tråd från all applikationskod inklusive händelsehanterare.

Om Tcl-tolken inte kör händelseslingan och bearbetar händelser kommer alla tkinter-anrop som görs från andra trådar än den som kör Tcl-tolken att misslyckas.

Det finns ett antal specialfall:

  • Tcl/Tk-bibliotek kan byggas så att de inte är trådmedvetna. I detta fall anropar tkinter biblioteket från den ursprungliga Python-tråden, även om denna är en annan än den tråd som skapade Tcl-tolken. Ett globalt lås säkerställer att endast ett anrop sker åt gången.

  • Med tkinter kan du skapa mer än en instans av ett Tk-objekt (med sin egen tolk), men alla tolkar som ingår i samma tråd delar en gemensam händelsekö, vilket snabbt blir otrevligt. I praktiken bör man inte skapa mer än en instans av Tk åt gången. Annars är det bäst att skapa dem i separata trådar och se till att du kör en trådmedveten Tcl/Tk-byggnad.

  • Att blockera händelsehanterare är inte det enda sättet att hindra Tcl-tolken från att återgå till händelseslingan. Det är till och med möjligt att köra flera kapslade händelseslingor eller överge händelseslingan helt och hållet. Om du gör något knepigt när det gäller händelser eller trådar, var medveten om dessa möjligheter.

  • Det finns några utvalda tkinter-funktioner som för närvarande endast fungerar när de anropas från den tråd som skapade Tcl-tolken.

Praktisk referens

Inställningsalternativ

Alternativ styr saker som färg och kantbredd för en widget. Alternativ kan ställas in på tre sätt:

Vid skapandet av objektet, med hjälp av nyckelordsargument
fred = Button(self, fg="röd", bg="blå")
När objektet har skapats behandlas alternativnamnet som ett ordboksindex
fred["fg"] = "röd"
fred["bg"] = "blå"
Använd config()-metoden för att uppdatera flera attrs efter att objektet skapats
fred.config(fg="röd", bg="blå")

För en fullständig förklaring av ett visst alternativ och dess beteende, se Tk-manussidorna för widgeten i fråga.

Observera att man-sidorna listar ”STANDARD OPTIONS” och ”WIDGET SPECIFIC OPTIONS” för varje widget. De förstnämnda är en lista över alternativ som är gemensamma för många widgetar, de senare är de alternativ som är specifika för just den widgeten. Standardalternativen finns dokumenterade på man-sidan options(3).

I detta dokument görs ingen åtskillnad mellan standardalternativ och widgetspecifika alternativ. Vissa alternativ gäller inte för vissa typer av widgetar. Huruvida en viss widget svarar på ett visst alternativ beror på widgetens klass; knappar har ett command-alternativ, etiketter har det inte.

De alternativ som stöds av en viss widget listas i widgetens man-sida eller kan efterfrågas vid körning genom att anropa metoden config() utan argument eller genom att anropa metoden keys() för den widgeten. Returvärdet av dessa anrop är en ordbok vars nyckel är namnet på alternativet som en sträng (till exempel 'relief') och vars värden är 5-tupler.

Vissa alternativ, som bg är synonymer för vanliga alternativ med långa namn (bg är en förkortning för ”background”). Om namnet på ett kortfattat alternativ skickas till metoden config() returneras en 2-tupel, inte en 5-tupel. Den 2-tupel som skickas tillbaka kommer att innehålla namnet på synonymen och det ”riktiga” alternativet (t.ex. ('bg', 'background')).

Index

Betydelse

Exempel

0

alternativets namn

'relief'

1

namn på alternativ för databasuppslagning

'relief'

2

alternativklass för databasuppslagning

”Relief

3

standardvärde

”Upphöjd

4

aktuellt värde

'groove'

Exempel:

>>> print(fred.config())
{'relief': ('relief', 'relief', 'Relief', 'raised', 'groove')}

Den ordbok som skrivs ut kommer naturligtvis att innehålla alla tillgängliga alternativ och deras värden. Detta är endast avsett som ett exempel.

The Packer

Packern är en av Tk:s geometrihanteringsmekanismer. Geometrihanterare används för att specificera den relativa positioneringen av widgetar inom deras behållare - deras ömsesidiga master. I motsats till den mer besvärliga placer (som används mindre ofta och som vi inte tar upp här) tar packern kvalitativa relationsspecifikationer - över, till vänster om, fyller, etc - och räknar ut allt för att bestämma de exakta placeringskoordinaterna åt dig.

Storleken på en master widget bestäms av storleken på de ”slave widgets” som finns inuti. Packern används för att styra var slavwidgetar visas i den master som de packas in i. Du kan packa in widgetar i ramar och ramar i andra ramar för att få den layout du vill ha. Dessutom justeras arrangemanget dynamiskt för att tillgodose stegvisa ändringar av konfigurationen när den väl är packad.

Observera att widgetar inte visas förrän de har fått sin geometri specificerad med en geometrihanterare. Det är ett vanligt tidigt misstag att utelämna geometrispecifikationen och sedan bli förvånad när widgeten skapas men ingenting visas. En widget kommer att visas först efter att den har fått till exempel packarens pack()-metod tillämpad på sig.

Metoden pack() kan anropas med nyckelord/alternativ/värdepar som styr var widgeten ska visas i sin behållare och hur den ska bete sig när huvudfönstret ändras i storlek. Här är några exempel:

fred.pack() # standardvärde för sida = "topp"
fred.pack(sida="vänster")
fred.pack(expand=1)

Alternativ för packare

Mer omfattande information om packern och de alternativ som den kan använda finns i man-sidorna och på sidan 183 i John Ousterhouts bok.

ankare

Typ av ankare. Anger var packaren ska placera varje slav i sitt kolli.

expandera

Boolean, 0 eller 1.

fyllning

Lagliga värden: 'x', 'y', 'both', 'none'.

ipadx och ipady

Ett avstånd - betecknar inre stoppning på vardera sidan av slavwidgeten.

padx och pady

Ett avstånd - betecknar yttre stoppning på vardera sidan av slavwidgeten.

sida

Lagliga värden är: 'vänster', 'höger', 'topp', 'botten'.

Variabler för kopplingswidget

För vissa widgetar (t.ex. textinmatningswidgetar) kan inställningen av aktuellt värde kopplas direkt till programvariabler med hjälp av särskilda alternativ. Dessa alternativ är variable, textvariable, onvalue, offvalue och value. Den här kopplingen fungerar åt båda hållen: om variabeln ändras av någon anledning kommer widgeten som den är kopplad till att uppdateras med det nya värdet.

Tyvärr är det i den nuvarande implementationen av tkinter inte möjligt att överföra en godtycklig Python-variabel till en widget genom ett variable- eller textvariable-alternativ. De enda typer av variabler som detta fungerar för är variabler som är underklassade från en klass som heter Variable, definierad i tkinter.

Det finns redan många användbara underklasser till Variable definierade: StringVar, IntVar, DoubleVar och BooleanVar. För att läsa det aktuella värdet på en sådan variabel anropar du metoden get() på den, och för att ändra dess värde anropar du metoden set(). Om du följer detta protokoll kommer widgeten alltid att spåra variabelns värde, utan ytterligare ingripande från din sida.

Till exempel:

import tkinter as tk

class App(tk.Frame):
    def __init__(self, master):
        super().__init__(master)
        self.pack()

        self.entrythingy = tk.Entry()
        self.entrythingy.pack()

        # Create the application variable.
        self.contents = tk.StringVar()
        # Set it to some value.
        self.contents.set("this is a variable")
        # Tell the entry widget to watch this variable.
        self.entrythingy["textvariable"] = self.contents

        # Define a callback for when the user hits return.
        # It prints the current value of the variable.
        self.entrythingy.bind('<Key-Return>',
                             self.print_contents)

    def print_contents(self, event):
        print("Hi. The current entry content is:",
              self.contents.get())

root = tk.Tk()
myapp = App(root)
myapp.mainloop()

Fönsterhanteraren

I Tk finns det ett verktygskommando, wm, för att interagera med fönsterhanteraren. Alternativ till kommandot wm gör att du kan kontrollera saker som titlar, placering, ikonbitmappar och liknande. I tkinter har dessa kommandon implementerats som metoder i Wm-klassen. Toplevel-widgetar är underklassade från Wm-klassen och kan därför anropa Wm-metoderna direkt.

För att komma till det toplevel-fönster som innehåller en viss widget kan du ofta bara hänvisa till widgetens master. Om widgeten har packats in i en ram kommer naturligtvis inte mastern att representera ett toplevel-fönster. För att komma åt det toplevel-fönster som innehåller en godtycklig widget kan du anropa metoden _root(). Den här metoden börjar med ett understreck för att markera att funktionen är en del av implementationen och inte ett gränssnitt till Tk-funktionalitet.

Här är några exempel på typiska användningsområden:

import tkinter as tk

class App(tk.Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.pack()

# create the application
myapp = App()

#
# here are method calls to the window manager class
#
myapp.master.title("My Do-Nothing Application")
myapp.master.maxsize(1000, 400)

# start the program
myapp.mainloop()

Tk Option Datatyper

ankare

Juridiska värden är kompassriktningar: "n", "ne", "e", "se", "s", "sw", "w", "nw" och även "center".

bitmapp

Det finns åtta inbyggda, namngivna bitmappar: 'error', 'gray25', 'gray50', 'hourglass', 'info', 'questhead', 'question', 'warning'. För att ange ett X-bitmapfilnamn, ange den fullständiga sökvägen till filen, föregången av en @, som i "@/usr/contrib/bitmap/gumby.bit".

booleansk

Du kan skicka heltalen 0 eller 1 eller strängarna "yes" eller "no".

återuppringning

Detta är en Python-funktion som inte tar några argument. Till exempel:

def print_it():
    print("hej där")
fred["kommando"] = print_it
färg

Färger kan anges som namnen på X-färger i filen rgb.txt eller som strängar som representerar RGB-värden i 4 bitar: "#RGB", 8 bitars: "#RRGGBB", 12 bitar: "#RRRGGGBBB", eller 16 bitar: "#RRRRGGGGBBBB", där R,G,B här representerar alla lagliga hexsiffror. Se sidan 160 i Ousterhouts bok för detaljer.

markör

Standardnamnen på X-markörer från cursorfont.h kan användas, utan prefixet XC_. För att t.ex. få en handmarkör (XC_hand2), använd strängen "hand2". Du kan också ange en egen bitmap- och maskfil. Se sidan 179 i Ousterhouts bok.

avstånd

Skärmavstånd kan anges i antingen pixlar eller absoluta avstånd. Pixlar anges som tal och absoluta avstånd som strängar, med ett tecken efter som anger enhet: c för centimeter, i för tum, m för millimeter, p för tryckpunkter. Exempelvis uttrycks 3,5 tum som "3.5i".

typsnitt

Tk använder ett listformat för teckensnittsnamn, till exempel {courier 10 bold}. Teckensnittsstorlekar med positiva siffror mäts i punkter, medan storlekar med negativa siffror mäts i pixlar.

geometri

Detta är en sträng av formen breddxhöjd, där bredd och höjd mäts i pixlar för de flesta widgetar (i tecken för widgetar som visar text). Till exempel: fred["geometry"] = "200x100".

justera

Lagliga värden är strängarna: "left", "center", "right" och "fill".

region

Detta är en sträng med fyra mellanslagsavgränsade element, som vart och ett är ett lagligt avstånd (se ovan). Till exempel: "2 3 4 5" och "3i 2i 4,5i 2i" och "3c 2c 4c 10,43c" är alla lagliga regioner.

lättnad

Bestämmer vilken kantstil som ska gälla för en widget. Lagliga värden är: "upphöjd", "nedsänkt", "platt", "spår" och "ås".

scroll-kommando

Detta är nästan alltid set()-metoden i någon scrollbar-widget, men det kan vara vilken widget-metod som helst som tar ett enda argument.

linda

Måste vara en av: "none", "char" eller "word".

Bindningar och händelser

Med bind-metoden från widget-kommandot kan du hålla utkik efter vissa händelser och låta en callback-funktion utlösas när den händelsetypen inträffar. Bindningsmetodens form är:

def bind(self, sequence, func, add=''):

var:

sekvens

är en sträng som anger vilken typ av händelse som är målet. (Se bind(3tk) manpage och sidan 201 i John Ousterhouts bok, Tcl and the Tk Toolkit (2nd edition), för mer information).

func

är en Python-funktion, som tar ett argument, som ska anropas när händelsen inträffar. En Event-instans kommer att skickas som argument. (Funktioner som används på detta sätt är allmänt kända som callbacks.)

lägg till

är valfritt, antingen '' eller '+'. Om du anger en tom sträng innebär det att denna bindning ska ersätta alla andra bindningar som händelsen är associerad med. Om du anger '+' innebär det att funktionen ska läggas till i listan över funktioner som är bundna till händelsetypen.

Till exempel:

def turn_red(self, event):
    event.widget["activeforeground"] = "red"

self.button.bind("<Enter>", self.turn_red)

Lägg märke till hur widgetfältet för händelsen nås i turn_red() callback. Detta fält innehåller den widget som fångade X-händelsen. I följande tabell listas de andra händelsefälten som du kan komma åt och hur de betecknas i Tk, vilket kan vara användbart när du hänvisar till Tk:s man pages.

Tk

Tkinter Händelsefält

Tk

Tkinter Händelsefält

%f

fokus

%A

röding

%h

höjd

%E

skicka_händelse

%k

nyckelkod

%K

nyckelhål

%s

stat/delstat

%N

nyckelsym_nummer

%t

tid

%T

typ

%w

bredd

%W

widget

%x

bredd

%X

x_rot

%y

Y

%Y

y_rot

Index Parameter

Ett antal widgetar kräver att ”index”-parametrar skickas. Dessa används för att peka på en viss plats i en Text-widget, eller på vissa tecken i en Entry-widget, eller på vissa menyalternativ i en Menu-widget.

Entry widget index (index, view index, etc.)

Entry widgets har alternativ som hänvisar till teckenpositioner i den text som visas. Du kan använda dessa tkinter-funktioner för att komma åt dessa speciella punkter i textwidgets:

Index för textwidget

Indexnotationen för Text-widgetar är mycket omfattande och beskrivs bäst i Tk:s man pages.

Menyindex (menu.invoke(), menu.entryconfig(), etc.)

Vissa alternativ och metoder för menyer manipulerar specifika menyposter. Närhelst ett menyindex behövs för ett alternativ eller en parameter kan du skicka in det:

  • ett heltal som hänvisar till den numeriska positionen för posten i widgeten, räknat uppifrån, med början på 0;

  • strängen "active", som hänvisar till den menyposition som för närvarande finns under markören;

  • strängen "last" som hänvisar till det sista menyalternativet;

  • Ett heltal föregånget av @, som i @6, där heltalet tolkas som en y-pixelkoordinat i menyns koordinatsystem;

  • strängen "none", som anger att det inte finns någon menypost alls, används oftast med menu.activate() för att inaktivera alla poster, och slutligen,

  • en textsträng som mönstermatchas mot menypostens etikett, när den skannas från toppen av menyn till botten. Observera att denna indextyp beaktas efter alla andra, vilket innebär att matchningar för menyalternativ med beteckningarna last, active eller none kan tolkas som ovanstående bokstavstexter i stället.

Bilder

Bilder i olika format kan skapas genom motsvarande underklass av tkinter.Image:

  • BitmapImage för bilder i XBM-format.

  • PhotoImage för bilder i PGM-, PPM-, GIF- och PNG-format. Det senare stöds från och med Tk 8.6.

Båda typerna av bilder skapas antingen med alternativet file eller data (andra alternativ finns också).

Ändrad i version 3.13: Lagt till PhotoImage-metoden copy_replace() för att kopiera en region från en bild till en annan bild, eventuellt med pixelzoomning och/eller subsampling. Lägg till from_coords parameter till PhotoImage metoderna copy(), zoom() och subsample(). Lägg till parametrarna zoom och subsample i PhotoImage-metoden copy().

Bildobjektet kan sedan användas överallt där ett bild-alternativ stöds av en widget (t.ex. etiketter, knappar, menyer). I dessa fall kommer Tk inte att behålla en referens till bilden. När den sista Python-referensen till bildobjektet raderas, raderas även bilddata och Tk kommer att visa en tom ruta där bilden användes.

Se även

Paketet Pillow lägger till stöd för format som BMP, JPEG, TIFF och WebP, bland andra.

Filhanterare

Med Tk kan du registrera och avregistrera en callback-funktion som kommer att anropas från Tk:s huvudslinga när I/O är möjligt på en filbeskrivning. Endast en hanterare kan registreras per fildeskriptor. Exempel på kod:

import tkinter
widget = tkinter.Tk()
mask = tkinter.READABLE | tkinter.WRITABLE
widget.tk.createfilehandler(file, mask, callback)
...
widget.tk.deletefilehandler(file)

Denna funktion är inte tillgänglig i Windows.

Eftersom du inte vet hur många byte som är tillgängliga för läsning kanske du inte vill använda metoderna BufferedIOBase eller TextIOBase read() eller readline(), eftersom dessa insisterar på att läsa ett fördefinierat antal byte. För sockets fungerar metoderna recv() eller recvfrom() bra; för andra filer, använd raw reads eller os.read(file.fileno(), maxbytecount).

Widget.tk.createfilehandler(file, mask, func)

Registrerar filhanterarens återuppringningsfunktion func. Argumentet file kan antingen vara ett objekt med en fileno()-metod (t.ex. ett fil- eller socketobjekt) eller en filbeskrivare med heltal. Argumentet mask är en OR-kombination av någon av de tre konstanterna nedan. Återkallelsen anropas på följande sätt:

återuppringning(fil, mask)
Widget.tk.deletefilehandler(file)

Avregistrerar en filhanterare.

_tkinter.READABLE
_tkinter.WRITABLE
_tkinter.EXCEPTION

Konstanter som används i mask-argumenten.