Progetti Python Tkinter [Spiegazione passo-passo]

L'apprendimento della GUI in Python può essere piuttosto impegnativo. Non preoccuparti perché noi ti copriamo le spalle! In questo articolo, abbiamo condiviso un tutorial di Tkinter in modo da poter lavorare in modo efficiente su progetti GUI Python. Dopo aver completato questo tutorial, acquisirai familiarità con gli elementi costitutivi per la creazione di progetti Python Tkinter. Se vuoi acquisire maggiore esperienza in Python, dai un'occhiata ai nostri programmi di scienza dei dati.

Abbiamo anche condiviso il codice per ogni passaggio. Tuttavia, ti consigliamo di copiarlo e incollarlo solo quando avrai capito come funziona. Altrimenti, non sarebbe di grande utilità.

Cos'è Tkinter?

Tkinter è un pacchetto per Python per utilizzare il toolkit Tk GUI. Puoi usare Tkinter per creare programmi GUI tramite Python. Sebbene Tkinter sia in grado di produrre molti programmi, potrebbe essere necessario utilizzare moduli per implementazioni avanzate. Dovresti avere familiarità con le basi di Tkinter prima di lavorare su progetti Python Tkinter:

Un programma Hello World a Tkinter

Ecco un esempio di programma Hello World in Tkinter:

importa tkinter come tk

classe Applicazione (tk.Frame):

def __init__(self, master=Nessuno):

super().__init__(master)

self.master = maestro

self.pack()

self.create_widgets()

def create_widgets(self):

self.hi_there = tk.Button(self)

self.hi_there[“text”] = "Hello World\n(cliccami)"

self.hi_there["comando"] = self.say_hi

self.hi_there.pack(side=”top”)

self.quit = tk.Button(self, text=”QUIT”, fg=”red”,

comando=self.master.destroy)

self.quit.pack(side=”fondo”)

def say_hi(self):

print("Ciao a tutti!")

radice = tk.Tk()

app = Applicazione(master=root)

app.mainloop()

Gestori di geometria in Tkinter

Un altro concetto principale che dovresti conoscere mentre lavori su progetti Python Tkinter sono i gestori di geometria. Senza utilizzare un gestore della geometria, i tuoi widget non apparirebbero sullo schermo. Esistono principalmente tre modi per aggiungere un gestore della geometria:

Griglia

Aggiunge una griglia al genitore e gli consente di mostrare i widget di conseguenza. La griglia ha righe e colonne per misurare la lunghezza e l'altezza dei suoi widget.

Pacchetto

Questo metodo dice al widget di impacchettarsi all'interno del genitore. Aggiunge solo il widget a un elenco di widget figli per il genitore. In termini semplici, li aggiunge a un blocco prima di posizionarli in un widget padre.

Luogo

Questo metodo posiziona i widget in una posizione specifica in base al widget principale.

Nel nostro tutorial qui sotto, abbiamo utilizzato il pack manager per gestire la posizione dei nostri widget. Ecco perché sarebbe meglio se hai familiarità con questi concetti. Ti aiuterebbe a capire meglio il funzionamento del nostro progetto.

Checkout: 42 entusiasmanti idee e argomenti per progetti Python per principianti

Costruire una GUI in Python (Tkinter Tutorial)

Passaggio n. 1: importazione del modulo

Per iniziare a lavorare sull'applicazione, dobbiamo prima importare il modulo necessario. Puoi farlo importando il modulo nel tuo spazio dei nomi. Ti consentirebbe di utilizzare le costanti e le classi con i loro nomi invece di qualificarle. Ciò significa che puoi utilizzare "Label" utilizzando il suo nome invece di qualificarlo come "TkinterLabel". Renderebbe le cose relativamente facili e potresti risparmiare molto tempo poiché qualificare ogni classe e costante può essere molto ingombrante. Utilizzare il codice seguente per importare il modulo:

>>> da importazione Tkinter *

Se Python non è collegato a Tk (o Tcl) nel tuo sistema o se non hai Tk (o Tcl) installato nel tuo sistema, vedrai un messaggio di errore in questa sezione. Per risolvere questo problema, avresti bisogno dell'amministratore del tuo sistema per l'accesso. Assicurati di risolvere questo problema facendo lo stesso.

D'altra parte, se non vedi alcun messaggio di errore in queste sezioni, puoi passare al passaggio successivo per creare una finestra:

>>> vittoria = Tk()

Abbiamo assegnato alla nostra finestra la variabile "win". Dopo aver implementato il codice sopra, dovresti vedere una piccola finestra sullo schermo. La barra del titolo dovrebbe mostrare "tk" scritto al suo interno.

Ciò significa che hai completato questo passaggio con successo e ora puoi iniziare a creare la GUI in Python.

Passaggio 2: aggiunta di pulsanti

Ora che abbiamo il nostro Tkinter in esecuzione, possiamo aggiungere pulsanti al nostro programma. I pulsanti sono la sezione più semplice di qualsiasi programma GUI, quindi inizieremo con loro:

>>> b1 = Pulsante(vincita, testo=”Uno”)

>>> b2 = Pulsante (vincita, testo = "Due")

La finestra che abbiamo creato nell'ultima sezione è il genitore per i pulsanti che abbiamo creato ora. Man mano che lavorerai su più progetti Python Tkinter, scoprirai che i frame possono anche fungere da genitori per altre classi. Ora, quando implementi questo codice, noterai una strana occorrenza: i pulsanti non vengono visualizzati nella finestra!

Questo perché dobbiamo aggiungere una griglia e un pacchetto al nostro programma. Sono chiamati gestori di geometria e li abbiamo discussi in precedenza in questo articolo. Aggiungeremo il gestore pacchetti nella nostra prossima sezione:

Passaggio 3: implementazione di Pack Manager

Useremo il metodo pack per aggiungere i nostri pulsanti al widget genitore. Con il gestore pacchetti, puoi dire su quale lato del widget genitore vuoi che il tuo widget figlio venga compresso. Puoi usare TOP, RIGHT, BOTTOM, LEFT come tue funzioni. Il programma seleziona TOP come predefinito se non si specifica un lato. Aggiungiamo prima il gestore pacchetti:

>>> b1.pack()

>>> b2.pack()

Quando aggiungi il primo pulsante (prima riga del codice), noterai che la tua finestra si restringe alle dimensioni del pulsante. Allo stesso modo, quando aggiungi il secondo pulsante (seconda riga del codice), la finestra si espande in base alle dimensioni di quel pulsante. La finestra ha posizionato i pulsanti in ordine verticale perché non abbiamo specificato su quale lato devono essere imballati. Imballiamoli a sinistra usando il codice qui sotto:

>>> b2.pack(lato=SINISTRA)

>>> b1.pack(lato=SINISTRA)

Nota che utilizziamo il gestore pacchetti principalmente quando dobbiamo posizionare i nostri widget solo in questi due ordini (orizzontale e verticale). Per altri tipi di posizionamento dei widget, utilizziamo il metodo della griglia o il metodo del luogo. Puoi aggiungere un po' di spazio tra i pulsanti e la finestra usando le funzioni 'padx' o 'pady'. La funzione "padx" aggiunge il riempimento all'asse X (sinistro e destro) del widget e la funzione "pady" aggiunge il riempimento all'asse Y (in alto e in basso) del dispositivo.

>>> b1.pack(lato=SINISTRA, padx=10)

>>> b2.pack(lato=SINISTRA, padx=10)

Consigliamo di sperimentare il padding dei widget. Ti aiuterebbe a comprendere i diversi modi in cui puoi modificare il posizionamento dei widget. Il riempimento è un concetto impegnativo da padroneggiare, quindi sarebbe meglio provarlo prima di passare alla sezione successiva.

Passaggio n. 4: il gestore della griglia

Un altro gestore della geometria popolare in Tkinter è il gestore della griglia. Come abbiamo discusso in precedenza nel nostro articolo, il gestore della griglia ti consente di dividere il genitore in righe e colonne. Puoi posizionare i widget figlio nelle celle della griglia del genitore. È possibile modificare la larghezza e la lunghezza di ogni colonna e riga in base alle proprie esigenze. Non tutte le colonne devono avere la stessa larghezza. Allo stesso modo, non è necessario che ogni riga abbia la stessa altezza. Quindi, il gestore della griglia ti dà più libertà creativa in termini di modifica dell'aspetto e del posizionamento dei tuoi widget.

Creeremo una nuova finestra con gli stessi pulsanti che abbiamo creato prima per testare il gestore della griglia. Tuttavia, aggiungeremo i pulsanti in una griglia 2×2:

>>> vittoria = Tk()

>>> b1 = Pulsante(vincita, testo=”Uno”)

>>> b2 = Pulsante (vincita, testo = "Due")

>>> b1.grid(riga=0, colonna=0)

>>> b2.grid(riga=1, colonna=1)

Noterai che il nostro programma ha lasciato alcune celle vuote. Questo perché non abbiamo aggiunto nulla alla riga 0, alla colonna 1 (o alla riga 1 e alla colonna 0). Proveremo un nuovo widget per vedere qualcosa di interessante:

>>> l = Etichetta(win, text=”Questa è un'etichetta”)

>>> l.grid(riga=1, colonna=0)

Dopo aver aggiunto il codice sopra, noterai che il secondo pulsante si sposta a destra per adattare il testo. Sarebbe meglio provare il gestore della griglia con più widget per vedere come funziona.

Da leggere: Stipendio per sviluppatori Django in India

Passaggio n. 5: miglioramento del layout

In questa sezione proveremo un nuovo widget chiamato frame. Un frame serve solo a contenere altri widget. Puoi impacchettare più widget in una cornice o utilizzare una griglia per posizionarli nello stesso. Puoi anche imballare diversi fotogrammi in un unico fotogramma. Questa funzione ti consente di creare layout avanzati per il tuo programma GUI. Ad esempio, aggiungeremo tre pulsanti di seguito a una cornice. Aggiungi i pulsanti orizzontalmente e poi imballa l'etichetta verticalmente con la cornice:

>>> vittoria = Tk()

>>> f = Fotogramma (vincita)

>>> b1 = Pulsante(f, “Uno”)

>>> b2 = Pulsante(f, “Due”)

>>> b3 = Pulsante(f, “Tre”)

>>> b1.pack(lato=SINISTRA)

>>> b2.pack(lato=SINISTRA)

>>> b3.pack(lato=SINISTRA)

>>> l = Label(win,”Questa etichetta è su tutti i pulsanti”)

>>> l.pack()

>>> f.pack()

Come abbiamo discusso in precedenza nell'articolo, puoi anche utilizzare il metodo place come gestore della geometria. Il metodo place consente di inserire i widget in una posizione specifica all'interno di una finestra o di una cornice. Tuttavia, non è consigliabile utilizzare frequentemente il metodo place perché limita la reattività del programma.

Con la funzione griglia, puoi utilizzare il parametro 'sticky' che ti consente di utilizzare le coordinate della mappa (S, N, O, SO, NE, ecc.) per specificare i posizionamenti dei widget. Prima di passare alla sezione successiva, assicurati di aver compreso le funzioni di cui abbiamo già discusso. Prova la griglia e le funzioni frame insieme per vedere come puoi usarlo in altri progetti GUI Python.

Passaggio n. 6: rendere utili i pulsanti

Se hai fatto clic sui pulsanti che abbiamo creato finora, devi aver notato che non rispondono (non fanno nulla). Si deprimono quando si fa clic e si evidenziano quando si passa sopra di loro, ma non svolgono alcuna funzione. Per fare in modo che i nostri pulsanti svolgano funzioni specifiche, dovremo utilizzare la funzione 'configura'.

Possiamo passare qualsiasi argomento di parola chiave al metodo "configura" di un widget per passarlo durante la creazione. Ecco un esempio:

>>> b1.configure(text=”Uno”)

Il parametro 'comando' lega i pulsanti alle funzioni di richiamata quando li crei o aggiungi 'configura' ad essi. Per capire come funziona, creeremo una funzione che stampa un messaggio:

>>> def but1():

… print("Il pulsante uno è stato premuto")

…

>>> b1.configure(comando=ma1)

Quindi, quando si fa clic sul rispettivo pulsante, viene stampato un messaggio.

Passaggio n. 7: aggiunta di widget di ingresso

I widget di ingresso consentono agli utenti di inserire del testo nel programma. Tuttavia, dovremmo rendere funzionale il widget di ingresso come abbiamo fatto con i pulsanti. Un widget di immissione deve recuperare (e impostare) il testo. Affinché il widget di ingresso esegua questa funzione, dovresti utilizzare l'oggetto Tkinter 'StringVar.' L'oggetto 'StringVar' contiene il testo sotto forma di stringa e lo rende leggibile tramite get.

Creeremo una nuova finestra per testare i nostri widget di ingresso:

>>> vittoria = Tk()

>>> v = StringVar()

>>> e = Entry(win,textvariable=v)

>>> e.pack()

Aggiungiamo ora "questo è un test" come voce e recuperiamo lo stesso tramite StringVar:

>>> v.get()

"questa è una prova"

Ora puoi impostare il testo in StringVar e farlo apparire nel widget:

>>> v.set(“questo è impostato dal programma”)

Widget aggiuntivo: il widget Listbox

Oltre al widget di immissione, possiamo aggiungere un widget della casella di riepilogo. Un widget della casella di riepilogo consente all'utente di scegliere un elemento da un menu. Creeremo una nuova finestra per provare il widget della casella di riepilogo:

>>> vittoria = Tk()

>>> lb = Listbox (vincita, altezza=3)

>>> lb.pack()

>>> lb.insert(END, “first entry”)

>>> lb.insert(END, “seconda voce”)

>>> lb.insert(END, “terza voce”)

>>> lb.insert(END, “quarta voce”)

È possibile inserire elementi all'inizio, al centro e alla fine dell'elenco. Puoi eliminarli anche tu. Se ci sono troppi elementi nell'elenco, puoi aggiungere una barra di scorrimento:

>>> sb = Scrollbar(win, orient=VERTICAL)

>>> sb.pack(lato=SINISTRA, riempimento=Y)

Per rendere funzionale la nostra barra di scorrimento dovremo utilizzare le funzioni di richiamata:

>>> sb.configure(command=lb.yview)

>>> lb.configure(yscrollcommand=sb.set)

Il metodo curselection restituisce un elemento quando lo selezioni nella casella di riepilogo. Restituirà una tupla vuota se non scegli alcun elemento.

Passaggio n. 8: passaggi finali

Useremo tutte le cose che abbiamo imparato nel nostro tutorial su Tkinter per creare un editor di elenchi telefonici:

Codice totale

#!/usr/bin/env python3

da tkinter import *

dall'importazione dei telefoni *

def quale_selezionato():

print("Al {0}".format(select.curselection()))

return int(select.curselection()[0])

def add_entry():

phonelist.append([fnamevar.get(), lnamevar.get(), phonevar.get()])

set_select()

def update_entry():

elenco telefonico[quale_selezionato()] = [fnamevar.get(),

lnamevar.get(),

phonevar.get()]

def delete_entry():

del phonelist[which_selected()]

set_select()

def load_entry():

fname, lname, telefono = elenco telefonico[che_selezionato()]

fnamevar.set(fname)

lnamevar.set(lname)

phonevar.set(telefono)

def make_window():

globale fnamevar, lnamevar, phonevar, select

vinci = Tk()

frame1 = Frame(vittoria)

frame1.pack()

Label(frame1, text=”Nome”).grid(row=0, column=0, sticky=W)

fnomevar = StringVar()

fname = Entry(frame1, textvariable=fnamevar)

fname.grid(row=0, column=1, sticky=W)

Label(frame1, text=”Last Name”).grid(row=1, column=0, sticky=W)

lnamevar = StringVar()

lname = Entry(frame1, textvariable=lnamevar)

lname.grid(riga=1, colonna=1, sticky=W)

Label(frame1, text="Telefono").grid(row=2, column=0, sticky=W)

phonevar = StringVar()

telefono = Entry(frame1, textvariable=phonevar)

phone.grid(riga=2, colonna=1, sticky=W)

frame2 = Frame(win) # Riga di pulsanti

frame2.pack()

b1 = Pulsante(frame2, testo=”Aggiungi “, comando=add_entry)

b2 = Pulsante(frame2, testo=”Aggiorna”, comando=voce_aggiornamento)

b3 = Pulsante(frame2, testo=”Delete”, comando=delete_entry)

b4 = Pulsante(frame2, testo=”Carica“, comando=voce_carica)

b5 = Pulsante(frame2, testo=”Aggiorna”, comando=set_select)

b1.pack(lato=SINISTRA)

b2.pack(lato=SINISTRA)

b3.pack(lato=SINISTRA)

b4.pack(lato=SINISTRA)

b5.pack(lato=SINISTRA)

frame3 = Frame(win) # selezione dei nomi

frame3.pack()

scroll = Scrollbar(frame3, orient=VERTICAL)

select = Listbox(frame3, yscrollcommand=scroll.set, altezza=6)

scroll.config(comando=select.yview)

scroll.pack(lato=DESTRA, riempimento=Y)

select.pack(lato=SINISTRA, riempimento=ENTRO, espandi=1)

vittoria di ritorno

def set_select():

phonelist.sort(key=record lambda: record[1])

select.delete(0, END)

per fname, lname, telefono in elenco:

select.insert(END, “{0}, {1}”.format(lname, fname))

win = make_window()

set_select()

win.mainloop()

Ecco l'elenco telefonico:

lista fonetica = [['Chris', 'Meyers', '241-343-4349'],

['Robert', 'Smith', '202-689-1234'],

['Janet', 'Jones', '609-483-5432'],

['Ralph', 'Barnhart', '215-683-2341'],

['Eric', 'Nelson', '571-485-2689'],

['Ford', 'Prefetto', '703-987-6543'],

['Maria', 'Zigler', '812-567-8901'],

['Bob', 'Smith', '856-689-1234']]

Il programma che abbiamo condiviso qui è un esempio. Puoi creare il tuo programma con le funzioni di cui abbiamo discusso in questo tutorial di Tkinter. Il programma di cui sopra manca di diverse funzionalità, ad esempio non ha la possibilità di salvare le modifiche. Puoi aggiungere la funzione di salvataggio da solo creando un pulsante in grado di eseguire questa attività.

Deve leggere: Markov Chain in Python Tutorial

Ulteriori informazioni sui progetti GUI Python e Python

Lavorare su progetti Python Tkinter può essere piuttosto divertente se sai cosa stai facendo. Sono anche un ottimo modo per capire i tuoi punti forti (e deboli). Puoi saperne di più su Python; ti consigliamo di visitare il nostro blog. Ecco alcune risorse per ulteriori letture:

• 10 progetti GUI Python
• Come creare un chatbot in Python
• 42 idee per progetti Python

Cosa ne pensi di questo progetto? Hai lavorato ad altri progetti Python Tkinter? Facci sapere.

Se sei curioso di conoscere la scienza dei dati, dai un'occhiata al programma Executive PG in Data Science di IIIT-B e upGrad, creato per i professionisti che lavorano e offre oltre 10 casi di studio e progetti, workshop pratici pratici, tutoraggio con esperti del settore, 1 -on-1 con mentori del settore, oltre 400 ore di apprendimento e assistenza al lavoro con le migliori aziende.