Wiki Ubuntu-it

Indice
Partecipa
FAQ
Wiki Blog
------------------
Ubuntu-it.org
Forum
Chiedi
Chat
Cerca
Planet
  • Pagina non alterabile
  • Informazioni
  • Allegati
  • Differenze per "Programmazione/Python/InterfacceGrafichePython3"
Differenze tra le versioni 1 e 7 (in 6 versioni)
Versione 1 del 02/03/2020 16.00.33
Dimensione: 16223
Commento:
Versione 7 del 02/03/2020 18.22.05
Dimensione: 5322
Commento:
Le cancellazioni sono segnalate in questo modo. Le aggiunte sono segnalate in questo modo.
Linea 7: Linea 7:
<<Informazioni(forum="https://forum.ubuntu-it.org/viewtopic.php?f=46&t=631491"; rilasci="18.04")>> <<Informazioni(forum="https://forum.ubuntu-it.org/viewtopic.php?f=46&t=638223"; rilasci="18.04")>>
Linea 11: Linea 11:
All'interno di questa pagina sono presenti degli esempi di come creare delle semplici interfacce grafiche usando programmi come '''wxPython''', '''PyGTK''' e '''!PyQt'''. All'interno di questa pagina sono presenti degli esempi di come creare delle semplici interfacce grafiche usando programmi come '''wxPython''', '''Tkinter''' e '''PyGTK'''.
Linea 13: Linea 13:
= PyGTK = Tkinter è di norma preinstallato in Ubuntu, mentre wxPython può essere installato con:
{{{
sudo apt install python3-wxgtk4.0
}}}
Linea 15: Linea 18:
GTK+ è un toolkit per la creazione di interfacce grafiche è stato progettato inizialmente come ausilio alla programmazione per [[Grafica/Gimp|GIMP]] ed è diventato una parte fondamentale dell'ambiente [[AmbienteGrafico/Gnome| GNOME]].

'''PyGTK''' è un set di moduli che permettono l'interfacciamento tra Python e le librerie GTK, è un toolkit orientato agli oggetti, permette quindi la possibilità di riutilizzare dello stesso codice in più applicazioni.

== Esempio di applicazione ==

Questa è una versione del programma `AreaTriangolo2.py`, presente all'interno di [[Programmazione/Python/Listati#areatraingolo2| questa pagina]].
{{{#!python
#!/usr/bin/python

# Importiamo la funzione sqrt (radice quadrata) dal modulo math
from math import sqrt

# Importiamo le librerie per l'interfaccia grafica GTK
import pygtk
pygtk.require('2.0')
import gtk

# Definiamo una classe Triangolo con tre metodi:
# un costruttore, un metodo che calcola il perimetro e uno che calcola l'area del triangolo.
class Triangolo:

    # Attributi della classe (le misure dei tre lati)
    a, b, c = 0, 0, 0

    # Metodo costruttore, in python i costruttori hanno il nome speciale __init__
    def __init__(self,a,b,c):
        # Controlliamo se i tre valori dati possono effettivamente
        #essere le misure dei lati di un triangolo.
        # Caso contrario solleviamo una bella eccezione!
        if ((a+b>c) and (a+c>b) and (b+c>a)):
            self.a=a
            self.b=b
            self.c=c
        else:
            raise "TriangoloImpossibile" , "I lati non possono formare un triangolo"
            # abbiamo dato un nome ed un essaggio di errore all'eccezione
    # Metodo che calcola il perimetro
    def perimetro(self):
        return self.a + self.b + self.c

    # Metodo che calcola l'area (tramite formula di Erone)
    def area(self):
        p=self.perimetro()/2.0
        return sqrt(p*(p-self.a)*(p-self.b)*(p-self.c))

#questa e' la classe che definisce l'interfaccia grafica
class Dialogo:
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) # definiamo la finestra
        self.window.set_title("Calcolo area triangolo")# le diamo in titolo
        self.window.connect("destroy", self.distruggi) # catturiamo l'evento destroy
                                                       #(es. la X che chiude la finestra)
                                                       # e lo indirizziamo a una funzione
                                                       # che termina il programma
        self.window.set_resizable(False) # la finestra non e' modificabile in dimensioni
        self.window.set_position(gtk.WIN_POS_MOUSE) # e compare nell'attuale posizione del muose
        self.bottone = gtk.Button("Calcolo") # definiamo il bottone calcolo
        self.bottone.connect("clicked", self.calcola) # catturiamo il click e lo indirizzo
                                                      # alla funzione che esegue il calcolo
        self.etichetta1 = gtk.Label("Lato 1 ") # testo che richiede la lunghezza del 1 lato
        self.entrata1 = gtk.Entry(10) # casella per l'inserimento della lunghezza
                                                      # del 1 lato
        self.riga1 = gtk.HBox() # creiamo un contenitore dove
                                     # gli oggetti sono disposti in orizzontale (una riga)
        self.riga1.pack_start(self.etichetta1) # inseriamo l'etichetta e la casella di input nella 1 riga
        self.riga1.pack_start(self.entrata1)
        self.etichetta2 = gtk.Label("Lato 2 ") # e cosi' via ...
        self.entrata2 = gtk.Entry(10)
        self.riga2 = gtk.HBox()
        self.riga2.pack_start(self.etichetta2)
        self.riga2.pack_start(self.entrata2)
        self.etichetta3 = gtk.Label("Lato 3 ")
        self.entrata3 = gtk.Entry(10)
        self.riga3 = gtk.HBox()
        self.riga3.pack_start(self.etichetta3)
        self.riga3.pack_start(self.entrata3)
        self.risultato = gtk.Label(" -- ") # creiamo un'etichetta per il risultato
        self.colonna = gtk.VBox() # creiamo un contenitore dove
                                           # gli oggetti sono disposti in verticale (una colonna)
        self.colonna.pack_start(self.riga1) # e vi inseriamo le righe, il pulsante e l'etichetta del risultato
        self.colonna.pack_start(self.riga2)
        self.colonna.pack_start(self.riga3)
        self.colonna.pack_start(self.bottone)
        self.colonna.pack_start(self.risultato)
        self.window.add(self.colonna) # inseriamo il tutto nella finestra
        self.window.show_all() # comando che visualizza la finestra ed il suo contenuto
    
    # funzione che raccoglie gli input, crea un'istanza Triangolo e ne richiede il calcolo dell'area
    def calcola(self, widget,data = None):
        try:
            a = float(self.entrata1.get_text()) # legge i dati inseriti nella 1 casella
            b = float(self.entrata2.get_text())
            c = float(self.entrata3.get_text())
            triangolo = Triangolo(a, b, c)
            self.risultato.set_text(str(triangolo.area()))
        except ValueError: # catturo l'eccezione
            self.risultato.set_text("Devi inserire valori numerici.")
        except "TriangoloImpossibile": # catturo la seconda eccezione
            self.risultato.set_text("I lati immessi non possono formare un triangolo")
    # funzione di uscita
    def distruggi(self, widget,data = None):
        print data
        return gtk.main_quit()
    # funzione di lancio della GUI
    def main(self):
        gtk.main()

# avvio del programma a condizione che non sia caricato come modulo
print __name__
if __name__ == "__main__":
    base = Dialogo()
    base.main()

}}} ''Listato del programma Area``Triangolo2.py con interfaccia grafica GTK+''
<<BR>>
Linea 140: Linea 27:
#!/usr/bin/python #!/usr/bin/python3
Linea 145: Linea 32:
from Tkinter import * from tkinter import *
Linea 164: Linea 51:
            raise "TriangoloImpossibile" , "I lati non possono formare un triangolo"             raise "TriangoloImpossibile"("I lati non possono formare un triangolo")
Linea 240: Linea 127:
= wxPython =
Questa è una versione del programma `AreaTriangolo2.py`, presente all'interno di [[Programmazione/Python/Listati#areatraingolo2| questa pagina]], che utilizza le librerie '''wxpython'''.
= PyGTK =
Linea 243: Linea 129:
== Esempio di applicazione ==

{{{#!python
#!/usr/bin/python

import wx #importiamo l'interfaccia grafica

from string import digits # importiamo una variabile per il controllo dei dati in input
from math import sqrt # importiamo la funzione sqrt per il calcolo della radicequadrata dal modulo math

class Finestra(wx.Frame):
    #inizializza la finestra grafica
    def __init__(self,parent,id=-1,title='',pos = wx.Point(0,0),size = wx.Size(400,300),style = wx.DEFAULT_FRAME_STYLE,name = 'frame'):
        pre=wx.PreFrame()
        pre.Create(parent,id,title,pos,size,style,name)
        self.this = pre.this
        self.VwXinit()
        
    #quando si clicca X [angolo superiore destro della finestra] per chiudere la finestra
    def __del__(self):
        self.Ddel()
        return

    #definizione della presentazione della finestra e dei suoi oggetti interni
    def VwXinit(self):
        self.SetTitle("Finestra principale ") # titolo della finestra
      
        self.SetFont(wx.Font(11,74,90,90,0,"Modern No. 20"))
        self.StBar = self.CreateStatusBar(1,wx.ST_SIZEGRIP)
        self.StBar.SetStatusWidths([-1])
        self.StBar.SetStatusText("Calcolo dell'area di un triangolo noti i lati",0)
        self.StBar.SetForegroundColour(wx.RED)
        self.SetBackgroundColour(wx.GREEN)
        self.st1 = wx.StaticText(self,-1,"Calcolo Area del Triangolo formula Erone ",wx.Point(20,30),wx.Size(400,30))
        
        self.st1.SetFont(wx.Font(11,74,90,90,0,"Modern No. 20"))
        self.st1.SetForegroundColour(wx.RED)
        self.lato1 = wx.StaticText(self, -1, "Inserisci il 1 Lato [1..9] :",wx.Point(10,63))
        self.latoa = wx.TextCtrl(self, -1, "", wx.Point(200, 60), wx.Size(100,-1))
        
        self.lato2 = wx.StaticText(self, -1, "Inserisci il 2 Lato [1..9] :",wx.Point(10,93))
        self.latob = wx.TextCtrl(self, -1, "", wx.Point(200, 90), wx.Size(100,-1))
          
        self.lato3 = wx.StaticText(self, -1, "Inserisci il 3 Lato [1..9] :",wx.Point(10,123))
        self.latoc = wx.TextCtrl(self, -1, "", wx.Point(200, 120), wx.Size(100,-1))
           
        self.bt1 = wx.Button(self,-1,"",wx.Point(155,220),wx.Size(90,30))
        self.bt1.SetLabel('Inserisci')
        self.bt1.SetFont(wx.Font(12,74,90,90,0,"Modern No. 20"))
        self.bt1.SetForegroundColour(wx.Colour(0,130,255))

        wx.EVT_BUTTON(self.bt1,-1,self.Acquisisci) #manda in esecuzione i controlli e
                                                 # se superati calcola l'area
  
 return
    #acquisisce i dati inseriti li controlla e se puo' calcola l'area
    def Acquisisci(self,event):
 a=str(self.latoa.GetValue())
 b=str(self.latob.GetValue())
 c=str(self.latoc.GetValue())
 
 vero = Finestra.Contronum(self,a)
 if vero == "F":
  avviso = "Il lato a ="+ a+" <-- non e' di tipo numerico; Riprova "
                msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)
  return
        vero = Finestra.Contronum(self,b)
 if vero == "F":
  avviso = "Il lato b ="+ b+" <-- non e' di tipo numerico; Riprova "
                msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)
  return
 vero =Finestra.Contronum(self,c)
 if vero == "F":
  avviso = "Il lato c ="+ c+" <-- non e' di tipo numerico; Riprova "
                msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)
  return
 # li trasforma in virgola mobile e poi verifica che corrispondano ad un triangolo
 a= float(a)
 b=float(b)
 c=float(c)
 
 p = (a+b+c)/2.0
 
 if p <=a or p <= b or p <= c:
  avviso ='I dati immessi non sono quelli di un triangolo; Riprova'
                msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)
                return
 else:
  # calcolo area triangolo
  area =sqrt(p*(p-a)*(p-b)*(p-c))
  avviso =" L'area del triangolo misura Mq "+str(area)
  msg = wx.MessageBox( avviso, 'Risultato',wx.OK )
  
 return
        
    def Contronum(self,valore): # serve per la verifica che i dati immessi siano di tipo numerico

        vero = "F"
        for i in range(len(valore)):

            if valore[i] in digits :

                vero = "T"

                continue

            else:

                vero = "F"

                break
 return vero

    def Ddel(self): #serve per la chiusura della finestra

        return



class App(wx.App):# finestra da cui derivano tutte le finestre successive
    def OnInit(self):

        self.main = Finestra(None,-1,'')
        self.main.Show()
        
        return 1

def main():#lancia il programma in quanto non caricato come modulo
   
    application = App(0)
    application.MainLoop()

if __name__ == '__main__':
       main()
}}}
(codice in lavorazione)


Problemi in questa pagina? Segnalali in questa discussione

Introduzione

All'interno di questa pagina sono presenti degli esempi di come creare delle semplici interfacce grafiche usando programmi come wxPython, Tkinter e PyGTK.

Tkinter è di norma preinstallato in Ubuntu, mentre wxPython può essere installato con:

sudo apt install python3-wxgtk4.0

Tkinter

Tk è un piccolo toolkit per la creazione d'interfacce grafiche è stato successivamente portato anche verso altri linguaggi (Python, Ruby, Lisp, ...). Tkinter è il modulo Python che permette l'interfacciamento con Tk.

Esempio di applicazione

Di seguito viene mostrato un esempio di programma:

   1 #!/usr/bin/python3
   2 
   3 # Importiamo la funzione sqrt (radice quadrata) dal modulo math
   4 from math import sqrt
   5 # Importiamo i widgets dal modulo Tkinter
   6 from tkinter import *
   7 
   8 # Definiamo una classe Triangolo con tre metodi:
   9 # un costruttore, un metodo che calcola il perimetro e uno che calcola l'area del triangolo.
  10 class Triangolo:
  11 
  12       # Attributi della classe (le misure dei tre lati)
  13       a, b, c = 0, 0, 0
  14 
  15       # Metodo costruttore
  16       def __init__(self,a,b,c):
  17          # Controlliamo se i tre valori dati possono effettivamente essere le misure dei lati di un triangolo.
  18          # Caso contrario solleviamo una bella eccezione! 
  19          if ((a+b>c) and (a+c>b) and (b+c>a)):
  20             self.a=a
  21             self.b=b
  22             self.c=c
  23          else:
  24             # abbiamo dato un nome ed un essaggio di errore all'eccezione
  25             raise "TriangoloImpossibile"("I lati non possono formare un triangolo")
  26 
  27       # Metodo che calcola il perimetro
  28       def perimetro(self):
  29          return self.a + self.b + self.c
  30 
  31       # Metodo che calcola l'area (tramite formula di Erone)
  32       def area(self):
  33          p=self.perimetro()/2.0
  34          return sqrt(p*(p-self.a)*(p-self.b)*(p-self.c))
  35 
  36 
  37 # questa e' la classe che definisce l'interfaccia grafica
  38 class Dialogo(Frame):
  39 
  40      def __init__(self):
  41         Frame.__init__(self)
  42         self.master.title("Area triangolo.") # Diamo il titolo alla finestra.
  43         self.master.minsize(250,150) # Dimensioni minime della finestra
  44         self.grid(sticky=E+W+N+S)
  45 
  46         self.ris=StringVar() # Questa variabile stringa viene usata per
  47         self.ris.set("---")  # aggiornare la gui quando il risultato cambia.
  48 
  49         # Rendiamo ridimensionabile la finestra dell'applicazione
  50         top=self.winfo_toplevel()         
  51         top.rowconfigure(0, weight=1)
  52         top.columnconfigure(0, weight=1)
  53 
  54         for i in range(5): self.rowconfigure(i, weight=1)
  55         self.columnconfigure(1, weight=1)
  56 
  57 
  58         self.etichetta1=Label(self, text="Lato 1    ") # Etichetta del lato 1
  59         self.etichetta1.grid(row=0, column=0, padx=2)  
  60  
  61         self.entrata1=Entry(self) # Casella d'inserimento del lato 1
  62         self.entrata1.grid(row=0, column=1, pady=2, padx=2, sticky=E+W+N+S)
  63 
  64         self.etichetta2=Label(self, text="Lato 2    ") # Etichetta del lato 2
  65         self.etichetta2.grid(row=1, column=0, padx=2)
  66 
  67         self.entrata2=Entry(self) # Casella d'inserimento del lato 2
  68         self.entrata2.grid(row=1, column=1, pady=2, padx=2, sticky=E+W+N+S)
  69 
  70         self.etichetta3=Label(self, text="Lato 3    ") # Etichetta del lato 3
  71         self.etichetta3.grid(row=2, column=0, padx=2)
  72 
  73         self.entrata3=Entry(self) # Casella d'inserimento del lato 3
  74         self.entrata3.grid(row=2, column=1, pady=2, padx=2, sticky=E+W+N+S)
  75 
  76         self.bottone=Button(self, text="Calcola", command=self.calcola) # Bottone "Calcola"
  77         self.bottone.grid(row=3, column=0, columnspan=2, pady=2, padx=2, sticky=E+W+N+S)
  78 
  79         self.risultato=Label(self, textvariable=self.ris) # Testo che motra il risultato.
  80         self.risultato.grid(row=4, column=0, columnspan=2, pady=2, padx=2, sticky=E+W+N+S)
  81 
  82 
  83      # Raccogliamo l'input e calcoliamo l'area
  84      def calcola(self):
  85         try :
  86           a=float(self.entrata1.get())
  87           b=float(self.entrata2.get())
  88           c=float(self.entrata3.get())
  89           t=Triangolo(a,b,c)
  90           self.ris.set("Area = "+str(t.area()))
  91         except ValueError: self.ris.set("Devi inserire valori numerici.")
  92         except "TriangoloImpossibile": self.ris.set("I lati immessi non possono formare un triangolo") 
  93 
  94           
  95 # Avvio del programma a condizione che non sia caricato come modulo
  96 if __name__=="__main__":
  97    d=Dialogo()
  98    d.mainloop()

= PyGTK =

(codice in lavorazione)

Ulteriori risorse


CategoryProgrammazione