Creeremo un piccolo programma con PyGTK 3.0 che funziona anche per PyGTK 3.4. Questa piccola GUI ti insegnerà come dividere un programma in due o più file.
Puoi visitare il tutorial di Sebastian Pölsterl sul nuovo PyGTK 3, ecco il nuovo tutorial, lascio il link:
http://python-gtk-3-tutorial.readthedocs.org/en/latest/index.html
Questo è il blog di Sebastian.
Una critica a questo tutorial di Sebastian è che non insegna come dividere un programma in parti o in più file, sarebbe stato bello se avesse mostrato un esempio di come farlo con PyGTK 3.
Tutti i programmi grandi e complessi sono divisi in molti file e i file sono persino collocati in altre directory, cioè si trovano in cartelle diverse.
Cominciamo con il piccolo esempio:
Ecco il codice di scrittura in un unico file chiamato gui.py. Apriamo l'editor di testo Gedit o l'editor che usiamo di più, copiamo il codice sottostante e lo salviamo come gui.py
from gi.repository import Gtk class gui (): def on_open_clicked (self, button): print "\" Open \ "è stato cliccato" def on_close_clicked (self, button): print "Chiusura applicazione" Gtk.main_quit () def __init__ (self): self.window = Gtk.Window () self.window.connect ('delete-event', Gtk.main_quit) self.box = Gtk.Box () self.window.add (self.box) self. button = Gtk.Button (label = 'Open') self.button.connect ("clicked", self.on_open_clicked) self.box.pack_start (self.button, True, True, 0) self.button = Gtk.Button ( label = 'Close') self.button.connect ("clicked", self.on_close_clicked) self.box.pack_start (self.button, True, True, 0) self.window.show_all () Gtk.main () if __name__ == '__main__': gui = gui ()
def on_open_clicked (self, button): print "\" Open \ "button was clicked"
È una funzione che si attiva nel terminale quando si fa clic sul pulsante di apertura. Il segnale per attivarlo è:
self.button.connect ("clicked", self.on_open_clicked) def on_close_clicked (self, button): print "Chiusura dell'applicazione" Gtk.main_quit ()
È una funzione che si attiva quando si fa clic sul pulsante di chiusura.
chiudere il programma che eseguiamo.
il segnale per attivarlo è
self.button.connect ("clicked", self.on_close_clicked) da gi.repository import Gtk ### invochiamo le librerie PyGTK ### class gui (): ### definizione di classe chiamata gui è la classe principale # ##
Dichiarazione dei widget: un widget è un programma predeterminato dalle librerie dell'interfaccia grafica che utilizziamo. Ad esempio, un widget è un pulsante, una finestra, una casella, ecc. Questi sono i widget che dichiariamo nel nostro programma.
self.window = Gtk.Window () ### window ### self.box = Gtk.Box () ### box #### self.button = Gtk.Button (label = 'Apri') ### # pulsante di apertura #### self.button = Gtk.Button (label = 'Chiudi') #### pulsante di chiusura #### self.window.add (self.box) #### la scatola è contenuta la finestra chiamata window #### self.box.pack_start (self.button, True, True, 0) ##### il pulsante è contenuto nella casella chiamata box ### self.window.show_all () ## # mostriamo l'intera finestra ### gui = gui () ### crea un oggetto gui ####
Inseriamo il nostro programma in una cartella chiamata semplice nel nostro caso sul desktop
Apriamo la cartella con il terminale, nel mio caso utilizzo Nemo da Linux Mint 14.
Per compilare mettiamo nel terminale python gui.py
guarda l'immagine.
Ora possiamo vedere il nostro piccolo programma o il nuovo widget creato con le librerie PyGTK 3
È una semplice finestra con due pulsanti.
Ora dividiamo il programma in tre parti, quindi lascio il codice dei tre file.
Primo file gui.py
da gi.repository importa Gtk da distruggi import distruggi da io import io class gui (distruggi, io): def __init __ (self): self.window = Gtk.Window () self.window.connect ('delete-event', Gtk .main_quit) self.box = Gtk.Box () self.window.add (self.box) self.button = Gtk.Button (label = 'Apri') self.button.connect ("clicked", self.on_open_clicked ) self.box.pack_start (self.button, True, True, 0) self.button = Gtk.Button (label = 'Close') self.button.connect ("clicked", self.on_close_clicked) self.box.pack_start (self.button, True, True, 0) self.window.show_all () Gtk.main () if __name__ == '__main__': gui = gui ()
Secondo file io.py
class io: def on_open_clicked (self, button): print "\" Open \ "button was clicked"
Terzo file destroy.py
from gi.repository import Gtk class destroy: def on_close_clicked (self, button): print "Closing application" Gtk.main_quit ()
Mettiamo i tre file nella stessa cartella nel nostro caso, la cartella si chiama divisa semplice.
Per compilare i tre file. Apriamo la cartella con il terminale e semplicemente la rimettiamo nel terminale
python gui.py
Modifiche apportate al codice gui.py
da distruggere import distruggere ### istruzione per importare il nostro file destroy.py ### da io import io ### istruzione per importare il nostro file io.py ### class gui (destroy, io): #### nella class main aggiungiamo le sottoclassi destroy e io ####
Puoi vedere che la frase
def on_open_clicked (self, button): print "\" Open \ "button was clicked"
Non è in gui.py, è nel file io.py
Frase
def on_close_clicked (self, button):
print "Chiusura applicazione"
Gtk.main_quit ()
si trova nel file destroy.py
In questo modo possiamo dividere un programma in molti file situati in diverse directory contemporaneamente.
D'altra parte, Python è un pilastro del software libero ed è adattato per funzionare con GTK 3.6 /3.8, il suo nome è PyGTK. L'adattamento di Python per KDE si chiama PyQT.
Python è adattato per Mac OS e WINDOWS.
Spero che questo mini tutorial di PyGTK3 ti sia stato utile. Possono fare tutte le critiche costruttive che vogliono.
Conosco anche alcuni Gtk 3.4 /3.6 e Vala GTK 3.4 / 3.6.
http://www.youtube.com/watch?v=9ckRn_sx8CE
Infine, gli utenti di KDE si scusano per non aver fatto un mini tutorial per KDE.
In kde preferisco usare kdevelop (penso sia così che si chiama) per creare la gui a mio agio, ma ho ancora difficoltà a trovare i processi perché accada x cosa: '(
Ottimo per quelli di noi che usano Python: D!
Saluti!
Ciao, seguo questa community da molto tempo e non sono molto sicuro se questa sia la prima volta che commento o l'ho già fatto prima 😀 (non sono molto portato a scrivere commenti sul web in realtà). Il fatto è che lo faccio per lasciare un suggerimento a Elav e KZKG ^ Gaara come amministratori, e penso che sarebbe una buona idea aggiungere un plugin per la colorazione della sintassi ora che ultimamente vedo più post con codice in diversi linguaggi di programmazione. So che ci sono parecchi plugin ma non ne ho provati nessuno poiché non sono un utente wordpress, quindi lascio a voi pensare alla fattibilità della richiesta. Colgo l'occasione per chiedere al resto dei lettori cosa ne pensano dell'idea, perché so che ci sono persone là fuori che preferiscono leggere il codice senza alcun ornamento. Mi scuso se questo è già stato commentato qui ed è stato respinto per qualche motivo, poiché non ricordo di aver visto alcuna discussione sull'argomento.
La verità è che mi piacerebbe avere la possibilità di colorare la sintassi per evidenziare il codice dei linguaggi di programmazione.
Ciò aiuterebbe gli utenti che desiderano imparare i linguaggi di programmazione.
Ma hey, sono anche a mio agio con il forum e questo possiamo discutere e imparare insieme.
GNU Emacs è più comodo, perché almeno devi scegliere in quale controllore del linguaggio di programmazione vuoi lavorare (se non vuoi più peso per il tuo processore, usa GNU Nano e goditi il minimalismo al suo meglio).
Elio stiamo parlando di WordPress. Implementato sul blog Desde Linux. Non ha le funzioni per colorare le lettere dei post.
Oh mi dispiace.
Naaa emacs è comodo per chi ha 84 dita XD .., persone normali, textmate, sublimetext o notepad ++ xd
La cosa improbabile è che non hai imparato a digitare, che è necessario per essere in grado di gestire bene GNU Emacs e le sue scorciatoie da tastiera. Inoltre, la sua GUI semplifica l'utilizzo dei suoi menu (può essere utilizzato in Windows, ma non è consigliabile farlo con la modalità normale ma con la modalità prompt dei comandi in modo che win32 non boicotti lo script).
Tutorial molto interessante. Ma a proposito, il codice sorgente di Python non è compilato, è un linguaggio interpretato.
Può essere compilato in pseudo codice. Non è il linguaggio macchina ma i byte che rappresentano qualcosa per l'interprete, ma anche il processo è chiamato compilato. In questo senso, è possibile dire che qualcosa è compilato.
Forse è meglio imparare pytgk2 perché l'ultima versione disponibile per Windows è la 2.24. La serie 3 brilla per la sua assenza. E le cattive lingue dicono che lo gnomo rompe tutte le api in ogni nuova versione.
Programma un mockup con GTK 3.4 / 3.6 e la verità è che ti spezzano la pazienza e la testa, devi riscrivere il codice, ora capisco perché le persone di Linux Mint si lamentano di GTK e del progetto GNOME.
A quelli di MINT sono d'accordo con GTK 2.4 questo non è accaduto.
Buon tutorial e riferimenti.
Solo un dettaglio, da quando è stato inserito il codice, in Python i rientri sono obbligatori e dovrebbero essere rispettati nel codice di esempio.
Saluti!
Puoi spiegare in cosa consistono le identificazioni obbligatorie in Python? A dire il vero, non l'ho mai sentito, sono mal abituato ai forum di PyGTK 2/3 in inglese e forse lo trascuro.
In Python non usi chiavi come in C o blocchi di inizio / fine come in Pascal, ma tutto si capisce attraverso l'indentazione che dai al codice. Cioè, i blocchi vengono riconosciuti essendo rientrati. È una caratteristica che amo particolarmente. Eviti di scrivere chiavi e cose del genere.
Semplicemente non mi piace, sembra più semplice mettere due piccoli tasti o uno std :: endl;, che essere visto se la riga xd è ben tabulata
: p Il tuo insegnante di programmazione ti metterà uno 0. O peggio ti licenzieranno dal tuo lavoro. Ciò che conta di più è che il codice sia leggibile con tutto ciò che ciò implica
terminando con le parentesi graffe chiuse, mi rende molto più leggibile XD ..
Sul serio???
int main(int argc, char *argv[]){program_name = argv[0];while ((argc > 1) && (argv[1][0] == '-')) {switch (argv[1][1]) {case 'v':verbose = 1; break;case 'o':out_file = &argv[1][2];break;case 'l':line_max = atoi(&argv[1][2]);break;default:fprintf(stderr,"Bad option %s\n", argv[1]);usage();}++argv;--argc;} if (argc == 1) {do_file("print.in");} else {while (argc > 1) {do_file(argv[1]);++argv;--argc;}}return (0);}
Vedi? Senza rientranze non è molto ben compreso. Ed è facile. Con uno più complesso, solo il compilatore lo capisce. Il fatto è che, dal momento che DEVI indentare comunque (affinché gli umani comprendano il codice), perché dovrebbe essere ridondante e utilizzare separatori? Basta con la rientranza e basta.
Ovviamente non si capisce nulla, perché non si rispettano le regole di buona scrittura per un programma c / c ++. Quello che hai fatto è valido per qualsiasi cosa, come annidare una funzione, all'interno di una funzione all'interno di un'altra funzione che è dentro un'altra, quindi voglio vederti xd se sei in grado di capirlo.
a proposito, con due sguardi, quel codice è facilmente comprensibile xD
Quello che ho fatto l'ho fatto apposta per dimostrarti che senza indentazione, anche se si compila, è estremamente difficile capire qualsiasi codice. Quindi hai 2 regole: Rientro e racchiude con delimitatori. Ma questo è ridondante. In Python tale codice semplicemente non è accettato dall'interprete. E hai solo una regola: Rientro. Facile.
Ma ehi, tutti con i loro gusti.
Entrambi sono buoni, indentati e non indentati, a mio parere preferisco lo stile punto e virgola o ruby, simile a python ma l'indentazione non è necessaria.
Questo è meglio compreso: P:
echo 'int main (int argc, char * argv []) {nome_programma = argv [0]; while ((argc> 1) && (argv [1] [0] ==' - ')) {switch (argv [ 1] [1]) {case 'v': verbose = 1; break; case 'o': out_file = & argv [1] [2]; break; case 'l': line_max = atoi (& argv [1] [2]); break; default: fprintf (stderr, »Bad option % s \ n », argv [1]); usage ();} ++ argv; –argc;} if (argc == 1) {do_file (" print.in ");} else {while (argc> 1 ) {do_file (argv [1]); ++ argv; –argc;}} return (0);} '| perl -p -e 's / \ {/ \ {\ n \ t / g; s / \; / \; \ n \ t / g; s / \ t \} / \} / g;'
Saluti 😀
Penso che Carlos significhi che dove esce il codice non ci sono trattini. Quello con copia e incolla semplicemente non funzionerà. Non so se il tag esiste durante la creazione di un post
per inserire il codice della lingua. Sarebbe bello se lo mettessero se non esiste.Ho già visto qual è il problema: il tag CODE rimuove tutti gli spazi e le tabulazioni (non dovrebbe farlo !!!) Ma se ci metti un nbsp, il codice sembra buono. A0 in hex (160 in dec) anche se penso che potrebbe dipendere dal font (non lo so). Se viene utilizzato, risulta così:
def fib(n):
a, b = 0, 1
while a < n:
print(a)
a, b = b, a+b
Che nei miei test sembra buono, ma non ho un'anteprima quando posto le risposte (e dovrebbe esserci !!!) Se non viene fuori, non è colpa mia culpa
Guarda gli esempi che Sebastian Pölsterl mette nel suo tutorial PyGTK 3, Sebastian non posiziona etichette.
Esempio :
http://python-gtk-3-tutorial.readthedocs.org/en/latest/entry.html#example
puoi vedere tutto il tutorial di Sebastian.
Non so cosa intendi. Quello che sto dicendo è che qui, nei post, non è possibile utilizzare il Tag HTML "CODE" in modo che quello che metti come codice risulti ben rientrato. Nella pagina a cui fai riferimento, se guardi i sorgenti della pagina, vedrai che non usa CODE ma usa altri delimitatori HTML.
Non è contro il codice che hai inserito, ma piuttosto indica un difetto nel sistema di pubblicazione di questo sito. Che, forse, gli amministratori possono risolvere.
Quando parlo di tag sto ovviamente parlando di HTML, non di Python. In ogni caso, se metti codice senza indentazione in Python, semplicemente non funzionerà. Se un principiante arriva e copia il codice come appare in questo post e cerca di eseguirlo, fallirà. Potresti essere frustrato perché sei un principiante. Di nuovo, la colpa non è tua; e nella mia risposta precedente immediata quello che ho fatto è stato fornire un modo per risolvere il problema dal livello di utente-chi-pubblica.
Hai perfettamente ragione, avrei dovuto caricare le foto invece di copiare il codice.
per mostrare come le istruzioni sono correttamente ordinate in PyGTK 3.
Per programmare con python consiglio di utilizzare Eclipse con il plugin PyDev, o Pychar m
Come accennato in precedenza, è per questo che non mi piace Python, a causa delle rientranze. Come abbiamo visto, fare copia e incolla non funzionerà, cosa che non accade con altri linguaggi come C, Java, PHP, ecc.
Per la leggibilità, applichiamo un abbellimento del codice (come http://indentcode.net/ ) e pronto,
Il brutto è fisso, ma se non c'è indentazione e la logica è alterata, suoniamo ..
Sono nuovo in PyGTK, è possibile interagire con gli script di shell in questo linguaggio?
Grazie per il tutorial.
Saluti.