Läsare som du hjälper till att stödja MUO. När du gör ett köp med hjälp av länkar på vår webbplats kan vi tjäna en affiliate-provision. Läs mer.

Att bygga en kalender är ett bra sätt att lära sig hur man skapar GUI-applikationer med Pythons Tkinter-modul. Du kan använda den här applikationen för att hantera och planera händelser i förväg.

Om du tar det längre kan du utöka appen för att spåra kommande möten och ställa in påminnelser. Du kan till och med införa samarbete med andra användares kalendrar för att undvika schemaläggningskonflikter.

Allt börjar med det grundläggande skelettet i en GUI Calendar-app.

Modulerna Kalender, Tkinter och DateTime

För att bygga GUI-kalendern använder du kalendern, Tkinter och DateTime-modulen. De Kalendermodul kommer med Python och låter dig utföra datum, månad och kalenderrelaterade åtgärder.

Tkinter låter dig skapa skrivbordsapplikationer. Den erbjuder en mängd olika widgets, användbara bibliotek, canvasobjekt och HTML/XML/PDF-tolkare. För att bygga en GUI-applikation är allt du behöver göra:

instagram viewer
  1. Importera biblioteket.
  2. Skapa ett fönster.
  3. Lägg till widgets i det fönstret.
  4. Anropa huvudhändelsslingan för att utföra åtgärder baserade på användarinteraktion.

För att installera Tkinter i ditt system, öppna en terminal och kör:

pip installera tkinter

DateTime-modulen är en annan som är inbyggd. Det erbjuder flera klasser som kan hantera datum, tider och tidsintervall. Med den här modulen kan du bygga en händelseschemaläggare, en väckarklocka, en datumkalkylator och en tidszonapplikation.

Hur man bygger en GUI-kalender med Python

Du kan hitta källkoden för GUI-kalendern med Python i detta GitHub-förråd.

Börja med att importera Tkinter, Calendar och DateTime-modulen. Definiera en funktion, printCalendar. Använd skaffa sig() metod på Spinboxen (definierad senare i koden) för att extrahera månaden och året som användaren har valt. Skicka dessa värden till kalendermodulen för att få en formaterad textkalender som representerar det angivna året och månaden. Den här texten representerar ett enkelt monospace-rutnät, med dagar ordnade i veckor som börjar på måndag.

Rensa bort alla befintliga data från skärmen. 1.0 indikerar början av fältet, och slutet indikerar slutet av fältet. Sätt slutligen in den tidigare genererade kalendern och visa den på skärmen.

från tkinter importera *
importera kalender
från datum Tid importera datum
defprintCalendar():
 månad = int (month_box.get())
 year = int (year_box.get())
 output_calendar = kalender.månad (år, månad)
 calendar_field.delete(1.0, 'slutet')
 calendar_field.insert('slutet', output_calendar)

Definiera en funktion, återställa. Radera innehållet på skärmen och ställ in månad och år till nutid och använd config() sätt att visa det på skärmen.

defåterställa():
 calendar_field.delete(1.0, 'slutet')
 month_var.set (current_month)
 year_var.set (current_year)
 month_box.config (textvariable=month_var)
 year_box.config (textvariable=year_var)

Definiera en funktion, stäng för att förstöra fönsterdisplayen och avsluta programmet.

defstänga():
 guiWindow.destroy()

Initiera Tkinter-instansen och visa rotfönstret. Ställ in titeln, måtten i pixlar och inaktivera dess storleksändring genom att behålla parametrarna som 0.

om __namn__ == "__huvud__":
 guiWindow = Tk()
 guiWindow.title("GUI-kalender")
 guiWindow.geometry('500x550')
 guiWindow.resizable(0, 0)

Definiera fyra ramar för rubriktiteln, månads- och årposten, displayen och knapparna. Den utför funktionen som en behållare och styr placeringen av andra widgets. Den ordnar layouten och ger utfyllnad för dessa widgets med hjälp av rektangulära sektioner på skärmen.

Organisera ramarna i block innan du placerar dem i guidefönstret med hjälp av packa() metod. Ställ in värdet på expand till sant för att göra det möjligt för widgeten att ändra storlek och expandera i det tillgängliga utrymmet. Ställ in fylla attribut till båda för att tillåta widgeten att expandera för att uppta hela fönstret i x- och y-riktningen.

 header_frame = Ram (guiWindow)
 entry_frame = Ram (guiWindow)
 result_frame = Ram (guiWindow)
 button_frame = Ram (guiWindow)
 header_frame.pack (expand=Sann, fyll="både")
 entry_frame.pack (expand=Sann, fyll="både")
 result_frame.pack (expand=Sann, fyll="både")
 button_frame.pack (expand=Sann, fyll="både")

Ange tre etiketter för rubriken, månaden och året. Ställ in det överordnade fönstret du vill placera det i, texten som det kommer att visa, typsnittsstilarna tillsammans med teckensnittsfärgen. Packa och placera etiketterna på lämpligt sätt. Associera IntVar() med entry_frame för att ställa in och ta emot heltalsdata.

 header_label = Etikett (header_frame, text="KALENDER",
 typsnitt=('arial', '45', 'djärv'), fg="#A020F0")
 header_label.pack (expand=Sann, fyll="både")


 month_label = Etikett (entry_frame, text="Månad:",
 typsnitt=("arial", "20", "djärv"), fg="#000000")


 year_label = Etikett (entry_frame, text="År:",
 typsnitt=("arial", "20", "djärv"), fg="#000000")
 month_label.place (x=30, y=0)
 year_label.place (x=275, y=0)
 month_var = IntVar (entry_frame)
 year_var = IntVar (entry_frame)

Hämta aktuell månad, år och ställ in den på variabeln IntVar(). Använd Spinbox-widgeten för att ange ett värdeintervall för användaren. Ställ in intervallet av värden som Spinbox ska innehålla, bredden, det aktuella värdet den ska hålla och typsnittsstilarna. Placera lådorna på rätt sätt.

 aktuell_månad = date.today().month
 nuvarande_år = date.today().år
 month_var.set (current_month)
 year_var.set (current_year)
 month_box = Spinbox (entry_frame, from_=1, till=12, bredd="10",
 textvariable=month_var, font=('arial','15'))


 year_box = Spinbox (entry_frame, from_=0000, till=3000, bredd="10",
 textvariable=year_var, font=('arial','15'))
 month_box.place (x=130, y=5)
 year_box.place (x=360, y=5)

Deklarera ett textfält och ställ in dess överordnade fönster, bredd, höjd, teckensnittsstil, 3D-animeringsstil och kantbredd. Organisera textwidgeten och deklarera tre knappar för att visa, återställa och stänga fönstret. Knapparna innehåller ytterligare en bakgrundsfärgsegenskap och en kommandoegenskap.

Med kommandoegenskapen kan du ställa in vilken funktion den ska köra när du klickar på den. Placera knapparna i en enda rad med gott om utrymme mellan var och en av dem.

 calendar_field = Text (resultatram, bredd=20, höjd=8,
 typsnitt=("kurir", "18"), relief=RIDGE, borderwidth=2)
 calendar_field.pack()


 display_button = Knapp (button_frame, text="VISA", bg="#A020F0",
 fg="#E0FFFF", kommando=printCalendar, font=('arial', '15'))


 reset_button = Knapp (button_frame, text="ÅTERSTÄLLA", bg="#A020F0",
 fg="#E0FFFF", kommando=återställ, typsnitt=('arial','15'))


 close_button = Knapp (button_frame, text="STÄNGA", bg="#A020F0",
 fg="#E0FFFF", kommando=stäng, teckensnitt=('arial','15'))
 display_button.place (x=55, y=0)
 reset_button.place (x=210, y=0)
 close_button.place (x=350, y=0)

De mainloop() funktionen säger åt Python att köra Tkinter-händelsslingan och lyssna efter händelser (som knapptryckningar) tills du stänger fönstret.

 guiWindow.mainloop()

Sätt ihop all kod för att se din GUI-kalender i aktion.

Exempel på utdata från GUI-kalendern

När programmet körs ovan visar programmet ett fönster med aktuell månad och datum. Återställ-knappen visar samma skärm när den klickas.

När månaden ställs in på 3 och året till 2000, visar programmet kalendern för mars 2000. När du trycker på knappen Stäng förstör programmet fönstret och stoppar dess körning.

Ta dig an några GUI-projekt för nybörjare med Python

Att bygga GUI-applikationer har aldrig varit så enklare. Pythons Tkinter-modul tillhandahåller många användbara widgets som du helt kan anpassa med väldigt lite kod. Tillsammans med detta får du tillgång till layouthanterare som pack, rutnät och plats för att placera element enligt dina önskemål.

Du kan bygga ett skrivtestspel, färgpalett, valutaomvandlare eller kalkylator för att komma igång. Dessa applikationer är roliga att bygga och kommer att utveckla dina objektorienterade programmeringsfärdigheter med lätthet.