Wiki Ubuntu-it

Indice
Partecipa
FAQ
Wiki Blog
------------------
Ubuntu-it.org
Forum
Chiedi
Chat
Cerca
Planet
  • Immutable Page
  • Info
  • Attachments


Questa guida è stata verificata solo con versioni obsolete di Ubuntu, potrebbe non essere più valida. Vuoi contribuire ad aggiornarla? Clicca qui!

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, PyGTK e PyQt.

PyGTK

GTK+ è un toolkit per la creazione di interfacce grafiche è stato progettato inizialmente come ausilio alla programmazione per GIMP ed è diventato una parte fondamentale dell'ambiente 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 questa pagina.

   1 #!/usr/bin/python
   2 
   3 # Importiamo la funzione sqrt (radice quadrata) dal modulo math
   4 from math import sqrt
   5 
   6 # Importiamo le librerie per l'interfaccia grafica GTK
   7 import pygtk
   8 pygtk.require('2.0')
   9 import gtk
  10 
  11 # Definiamo una classe Triangolo con tre metodi:
  12 # un costruttore, un metodo che calcola il perimetro e uno che calcola l'area del triangolo.
  13 class Triangolo:
  14 
  15     # Attributi della classe (le misure dei tre lati)
  16     a, b, c = 0, 0, 0
  17 
  18     # Metodo costruttore, in python i costruttori hanno il nome speciale __init__
  19     def __init__(self,a,b,c):
  20         # Controlliamo se i tre valori dati possono effettivamente 
  21         #essere le misure dei lati di un triangolo.
  22         # Caso contrario solleviamo una bella eccezione! 
  23         if ((a+b>c) and (a+c>b) and (b+c>a)):
  24             self.a=a
  25             self.b=b
  26             self.c=c 
  27         else: 
  28             raise "TriangoloImpossibile" , "I lati non possono formare un triangolo"
  29             # abbiamo dato un nome ed un essaggio di errore all'eccezione
  30     # Metodo che calcola il perimetro
  31     def perimetro(self):
  32         return self.a + self.b + self.c
  33 
  34     # Metodo che calcola l'area (tramite formula di Erone)
  35     def area(self):
  36         p=self.perimetro()/2.0
  37         return sqrt(p*(p-self.a)*(p-self.b)*(p-self.c))
  38 
  39 #questa e' la classe che definisce l'interfaccia grafica
  40 class Dialogo:
  41     def __init__(self):
  42         self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)  # definiamo la finestra
  43         self.window.set_title("Calcolo area triangolo")# le diamo in titolo
  44         self.window.connect("destroy", self.distruggi) # catturiamo l'evento destroy 
  45                                                        #(es. la X che chiude la finestra)
  46                                                        # e lo indirizziamo a una funzione
  47                                                        # che termina il programma
  48         self.window.set_resizable(False)            # la finestra non e' modificabile in dimensioni
  49         self.window.set_position(gtk.WIN_POS_MOUSE) # e compare nell'attuale posizione del muose
  50         self.bottone = gtk.Button("Calcolo")        # definiamo il bottone calcolo
  51         self.bottone.connect("clicked", self.calcola) # catturiamo il click e lo indirizzo 
  52                                                       # alla funzione che esegue il calcolo
  53         self.etichetta1 = gtk.Label("Lato 1      ")   # testo che richiede la lunghezza del 1 lato
  54         self.entrata1 = gtk.Entry(10)                 # casella per l'inserimento della lunghezza
  55                                                       # del 1 lato
  56         self.riga1 = gtk.HBox()      # creiamo un contenitore dove 
  57                                      # gli oggetti sono disposti in orizzontale (una riga)
  58         self.riga1.pack_start(self.etichetta1) # inseriamo l'etichetta e la casella di input nella 1 riga 
  59         self.riga1.pack_start(self.entrata1)
  60         self.etichetta2 = gtk.Label("Lato 2      ") # e cosi' via ...
  61         self.entrata2 = gtk.Entry(10)
  62         self.riga2 = gtk.HBox()
  63         self.riga2.pack_start(self.etichetta2)
  64         self.riga2.pack_start(self.entrata2)
  65         self.etichetta3 = gtk.Label("Lato 3      ")
  66         self.entrata3 = gtk.Entry(10)
  67         self.riga3 = gtk.HBox()
  68         self.riga3.pack_start(self.etichetta3)
  69         self.riga3.pack_start(self.entrata3)
  70         self.risultato = gtk.Label(" -- ") # creiamo un'etichetta per il risultato
  71         self.colonna = gtk.VBox()          # creiamo un contenitore dove 
  72                                            # gli oggetti sono disposti in verticale (una colonna)
  73         self.colonna.pack_start(self.riga1) # e vi inseriamo le righe, il pulsante e l'etichetta del risultato
  74         self.colonna.pack_start(self.riga2)
  75         self.colonna.pack_start(self.riga3)
  76         self.colonna.pack_start(self.bottone)
  77         self.colonna.pack_start(self.risultato)
  78         self.window.add(self.colonna)  # inseriamo il tutto nella finestra
  79         self.window.show_all()         # comando che visualizza la finestra ed il suo contenuto
  80     
  81     # funzione che raccoglie gli input, crea un'istanza Triangolo e ne richiede il calcolo dell'area
  82     def calcola(self, widget,data = None): 
  83         try:
  84             a = float(self.entrata1.get_text()) # legge i dati inseriti nella 1 casella
  85             b = float(self.entrata2.get_text())
  86             c = float(self.entrata3.get_text())
  87             triangolo = Triangolo(a, b, c)
  88             self.risultato.set_text(str(triangolo.area()))
  89         except ValueError: # catturo l'eccezione
  90             self.risultato.set_text("Devi inserire valori numerici.")
  91         except "TriangoloImpossibile": # catturo la seconda eccezione
  92             self.risultato.set_text("I lati immessi non possono formare un triangolo")
  93     # funzione di uscita
  94     def distruggi(self, widget,data = None):
  95         print data
  96         return gtk.main_quit()
  97     # funzione di lancio della GUI
  98     def main(self):
  99         gtk.main()
 100 
 101 # avvio del programma a condizione che non sia caricato come modulo
 102 print __name__
 103 if __name__ == "__main__":
 104     base = Dialogo()
 105     base.main()

Listato del programma AreaTriangolo2.py con interfaccia grafica GTK+

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/python
   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()

wxPython

Questa è una versione del programma AreaTriangolo2.py, presente all'interno di questa pagina, che utilizza le librerie wxpython.

Esempio di applicazione

   1 #!/usr/bin/python
   2 
   3 import wx #importiamo l'interfaccia grafica          
   4 
   5 from string import digits # importiamo una variabile per il controllo dei dati in input
   6 from math import sqrt # importiamo la funzione sqrt per il calcolo della radicequadrata dal modulo math
   7 
   8 class Finestra(wx.Frame):
   9     #inizializza la finestra grafica   
  10     def __init__(self,parent,id=-1,title='',pos = wx.Point(0,0),size = wx.Size(400,300),style = wx.DEFAULT_FRAME_STYLE,name = 'frame'):
  11         pre=wx.PreFrame()
  12         pre.Create(parent,id,title,pos,size,style,name)
  13         self.this = pre.this
  14         self.VwXinit()
  15         
  16     #quando si clicca X [angolo superiore destro della finestra] per chiudere la finestra       
  17     def __del__(self):
  18         self.Ddel()
  19         return
  20 
  21     #definizione della presentazione della finestra e dei suoi oggetti interni
  22     def VwXinit(self):
  23         self.SetTitle("Finestra principale ")  # titolo della finestra
  24       
  25         self.SetFont(wx.Font(11,74,90,90,0,"Modern No. 20"))
  26         self.StBar = self.CreateStatusBar(1,wx.ST_SIZEGRIP)
  27         self.StBar.SetStatusWidths([-1])
  28         self.StBar.SetStatusText("Calcolo dell'area di un triangolo noti i lati",0)
  29         self.StBar.SetForegroundColour(wx.RED)
  30         self.SetBackgroundColour(wx.GREEN)
  31         self.st1 = wx.StaticText(self,-1,"Calcolo Area del Triangolo formula Erone ",wx.Point(20,30),wx.Size(400,30))
  32         
  33         self.st1.SetFont(wx.Font(11,74,90,90,0,"Modern No. 20"))
  34         self.st1.SetForegroundColour(wx.RED)
  35         self.lato1 = wx.StaticText(self, -1, "Inserisci il 1 Lato [1..9]  :",wx.Point(10,63))
  36         self.latoa = wx.TextCtrl(self, -1, "", wx.Point(200, 60), wx.Size(100,-1))
  37         
  38         self.lato2 = wx.StaticText(self, -1, "Inserisci il 2 Lato [1..9]  :",wx.Point(10,93))
  39         self.latob = wx.TextCtrl(self, -1, "", wx.Point(200, 90), wx.Size(100,-1))
  40                         
  41         self.lato3 = wx.StaticText(self, -1, "Inserisci il 3 Lato [1..9]  :",wx.Point(10,123))
  42         self.latoc = wx.TextCtrl(self, -1, "", wx.Point(200, 120), wx.Size(100,-1))
  43                                 
  44         self.bt1 = wx.Button(self,-1,"",wx.Point(155,220),wx.Size(90,30))
  45         self.bt1.SetLabel('Inserisci')
  46         self.bt1.SetFont(wx.Font(12,74,90,90,0,"Modern No. 20"))
  47         self.bt1.SetForegroundColour(wx.Colour(0,130,255))
  48 
  49         wx.EVT_BUTTON(self.bt1,-1,self.Acquisisci)      #manda in esecuzione i controlli e 
  50                                                         # se superati calcola l'area
  51                 
  52         return
  53     #acquisisce i dati inseriti li controlla e se puo' calcola l'area
  54     def Acquisisci(self,event): 
  55         a=str(self.latoa.GetValue())
  56         b=str(self.latob.GetValue())
  57         c=str(self.latoc.GetValue())
  58         
  59         vero = Finestra.Contronum(self,a)
  60         if vero == "F":
  61                 avviso = "Il lato a ="+ a+"  <-- non e' di tipo numerico; Riprova "
  62                 msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)   
  63                 return
  64         vero = Finestra.Contronum(self,b)
  65         if vero == "F":
  66                 avviso = "Il lato b ="+ b+"  <-- non e' di tipo numerico; Riprova "
  67                 msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)  
  68                 return          
  69         vero =Finestra.Contronum(self,c)        
  70         if vero == "F":
  71                 avviso = "Il lato c ="+ c+"  <-- non e' di tipo numerico; Riprova "
  72                 msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR) 
  73                 return
  74         # li trasforma in virgola mobile e poi verifica che corrispondano ad un triangolo
  75         a= float(a)
  76         b=float(b)
  77         c=float(c)      
  78         
  79         p = (a+b+c)/2.0
  80         
  81         if p <=a or  p <= b or p <= c:
  82                 avviso ='I dati immessi non sono quelli di un triangolo; Riprova'
  83                 msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)     
  84                 return    
  85         else:
  86                 # calcolo area triangolo
  87                 area =sqrt(p*(p-a)*(p-b)*(p-c)) 
  88                 avviso =" L'area del triangolo misura  Mq "+str(area)
  89                 msg = wx.MessageBox( avviso, 'Risultato',wx.OK )     
  90                 
  91         return
  92         
  93     def Contronum(self,valore): # serve per la verifica che i dati immessi siano di tipo numerico
  94 
  95         vero = "F"
  96         for i in range(len(valore)):
  97 
  98             if valore[i]  in digits :
  99 
 100                 vero = "T"
 101 
 102                 continue
 103 
 104             else:
 105 
 106                 vero = "F"
 107 
 108                 break            
 109         return vero
 110 
 111     def Ddel(self): #serve per la chiusura della finestra
 112 
 113         return 
 114 
 115 
 116 
 117 class App(wx.App):# finestra  da cui derivano tutte le finestre successive
 118     def OnInit(self):
 119 
 120         self.main = Finestra(None,-1,'')
 121         self.main.Show()
 122         
 123         return 1
 124 
 125 def main():#lancia il programma in quanto non  caricato come modulo
 126    
 127     application = App(0)
 128     application.MainLoop()
 129 
 130 if __name__ == '__main__':
 131        main()

Ulteriori risorse


CategoryProgrammazione