We gaan een klein programma maken met PyGTK 3.0 dat ook werkt voor PyGTK 3.4. Deze kleine GUI leert je hoe je een programma opsplitst in twee of meer bestanden.
Je kunt de tutorial van Sebastian Pölsterl over de nieuwe PyGTK 3 bezoeken, hier is de nieuwe tutorial, ik verlaat de link:
http://python-gtk-3-tutorial.readthedocs.org/en/latest/index.html
Dit is de blog van Sebastiaan.
Een punt van kritiek op de tutorial van Sebastian is dat het niet leert hoe een programma in delen of in meerdere bestanden moet worden verdeeld. Het zou leuk geweest zijn als hij een voorbeeld had laten zien van hoe het met PyGTK 3 moet.
Alle grote en complexe programma's zijn onderverdeeld in veel bestanden en zelfs de bestanden zijn in andere mappen geplaatst, dat wil zeggen dat ze zich in verschillende mappen bevinden.
Laten we beginnen met het kleine voorbeeld:
Hier laat ik de code van het schrijven achter in een enkel bestand genaamd gui.py. We openen de teksteditor Gedit of de editor die we het meest gebruiken, kopiëren onderstaande code en slaan deze op als gui.py
from gi.repository import Gtk class gui(): def on_open_clicked(self, button): print "\"Open\" button was clicked" def on_close_clicked(self, button): print "Sluiten applicatie" Gtk.main_quit() def __init__ (zelf): self.window = Gtk.Window() self.window.connect('verwijder-gebeurtenis', Gtk.main_quit) self.box = Gtk.Box() self.window.add(self.box) self. button = Gtk.Button(label='Open') self.button.connect("geklikt", self.on_open_clicked) self.box.pack_start(self.button, True, True, 0) self.button = Gtk.Button( label='Sluiten') self.button.connect("geklikt", 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\" knop is geklikt"
Het is een functie die wordt geactiveerd in de terminal wanneer we op de knop Openen klikken. Het signaal om het te activeren is:
self.button.connect("geklikt", self.on_open_clicked) def on_close_clicked(self, button): print "Applicatie sluiten" Gtk.main_quit()
Het is een functie die wordt geactiveerd wanneer we op de knop Sluiten klikken.
Sluit het programma dat we hebben uitgevoerd.
het signaal om het te activeren is
self.button.connect("clicked", self.on_close_clicked) van gi.repository import Gtk ### bel de PyGTK-bibliotheken ### class gui(): ### class definition genaamd gui is de hoofdklasse # ##
Widgetverklaring: een widget is een programma dat vooraf is bepaald door de GUI-bibliotheken die we gebruiken. Een widget is bijvoorbeeld een knop, een venster, een vak, enz. Dit zijn de widgets die we declareren in ons programma.
self.window = Gtk.Window() ### window ### self.box = Gtk.Box() ### box #### self.button = Gtk.Button(label='Open') ### # open button #### self.button = Gtk.Button(label='Close') #### close button #### self.window.add(self.box) #### de box is opgenomen in het venster met de naam window #### self.box.pack_start(self.button, True, True, 0) ##### de knop bevindt zich in het vak met de naam box ### self.window.show_all() ## # toon het hele venster ### gui = gui() ### maak een gui-object aan ####
We plaatsen ons programma in een map met de naam simpel in ons geval op de desktop
We openen de map met de terminal, in mijn geval gebruik ik Nemo van Linux Mint 14.
Om te compileren plaatsen we in de terminal python gui.py
zie de afbeelding.
Nu kunnen we ons nieuwe kleine programma of widget zien dat is gemaakt met de PyGTK 3-bibliotheken.
Het is een eenvoudig venster met twee knoppen.
Nu verdelen we het programma in drie delen hieronder laat ik de code van de drie bestanden achter.
Eerste gui.py-bestand
from gi.repository import Gtk from destroy import destroy from io import io class gui(destroy ,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='Open') self.button.connect("clicked", self.on_open_clicked) self.box.pack_start(self.button, True, True, 0) self.button = Gtk.Button(label='Sluiten') self.button.connect("geklikt", self.on_close_clicked) self.box.pack_start( self.button, True, True, 0) self.window.show_all() Gtk.main() if __name__ == '__main__': gui = gui()
Tweede io.py-bestand
class io: def on_open_clicked(self, button): print "\"Open\" knop is geklikt"
Derde bestand destroy.py
from gi.repository import Gtk class destroy: def on_close_clicked(self, button): print "Applicatie sluiten" Gtk.main_quit()
We plaatsen de drie bestanden in dezelfde map in ons geval, de map heet eenvoudig verdeeld.
Om de drie samen te stellen. We openen de map met de terminal en plaatsen hem eenvoudig terug in de terminal
python gui.py
Wijzigingen aangebracht in de gui.py-code
from destroy import destroy ### statement om ons bestand te importeren destroy.py ### from io import io ### statement om ons bestand io.py te importeren ### class gui(destroy ,io ): #### to class main voegen we de subklassen destroy en io toe ####
Dat zie je aan de zin
def on_open_clicked(self, button): print "\"Open\" knop is geklikt"
Het staat niet in gui.py, maar in het io.py-bestand
Zin
def on_close_clicked(zelf, knop):
afdrukken "Applicatie afsluiten"
gtk.main_quit()
het bevindt zich in het bestand destroy.py
Zo kunnen we een programma opdelen in veel bestanden die zich tegelijkertijd in verschillende mappen bevinden.
Aan de andere kant is Python een pijler van gratis software en is het aangepast om te werken met GTK 3.6 / 3.8, de naam is PyGTK. De poort van Python voor KDE heet PyQT.
Python is aangepast voor Mac OS en WINDOWS.
Ik hoop dat je deze mini PyGTK3-tutorial nuttig vond. Ze kunnen alle opbouwende kritiek geven die ze willen.
Ik weet ook iets over Gtk 3.4/3.6 en Vala GTK 3.4/3.6.
http://www.youtube.com/watch?v=9ckRn_sx8CE
Ten slotte verontschuldigen KDE-gebruikers zich voor het niet maken van een mini-tutorial voor KDE.
In kde gebruik ik liever kdevelop (volgens mij heet het zo) om de gui naar mijn zin te maken, maar ik vind het nog steeds moeilijk om de processen te vinden om iets te laten gebeuren :'(
Geweldig voor degenen onder ons die Python gebruiken :D!
Groeten!
Hallo, ik volg deze community al een hele tijd en ik weet niet zeker of dit de eerste keer is dat ik een opmerking heb geplaatst of dat ik het eerder heb gedaan 😀 (ik ben niet echt geneigd om opmerkingen te schrijven over de web). Het ding is dat ik het doe om een suggestie over te laten aan Elav en KZKG^Gaara als beheerders, en ik denk dat het een goed idee zou zijn om een plug-in toe te voegen voor syntaxkleuring nu ik de laatste tijd meer berichten zie met code in verschillende programmeertalen. Ik weet dat er nogal wat plug-ins zijn, maar ik heb er geen geprobeerd omdat ik geen WordPress-gebruiker ben, dus ik zal je laten nadenken over de haalbaarheid van de verzoeken. Ik maak van de gelegenheid gebruik om de rest van de lezers te vragen wat ze van het idee vinden, omdat ik weet dat er mensen zijn die de code liever lezen zonder enige verfraaiing. Mijn excuses als dit hier al is besproken en het om de een of andere reden is afgewezen, omdat ik me niet kan herinneren dat ik een discussie over dit onderwerp heb gezien.
Ik zou heel graag de optie willen hebben om de syntaxis te kleuren om de code van programmeertalen te markeren.
Dat zou gebruikers helpen die programmeertalen willen leren.
Maar goed, ik voel me ook op mijn gemak op het forum en dat we kunnen discussiëren en van elkaar kunnen leren.
Comfortabeler is GNU Emacs, omdat je tenminste moet kiezen met welke programmeertaalcontrole je wilt werken (als je niet meer gewicht wilt voor je processor, gebruik dan GNU Nano en geniet van minimalisme op zijn best).
Elio we hebben het over WordPress. Geïmplementeerd op de blog Desde Linux. Het heeft niet de functies om de letters van de berichten te kleuren.
Oh het spijt me.
Naaa emacs is comfortabel voor degenen die 84 vingers hebben XD..., normale mensen, tekstgenoot, sublieme tekst of kladblok++ xd
Wat onwaarschijnlijk is, is dat je niet hebt leren typen, wat nodig is om GNU Emacs en zijn sneltoetsen goed te kunnen gebruiken. De GUI maakt het ook gemakkelijk om de menu's te gebruiken (het kan worden gebruikt in Windows, maar het wordt niet aanbevolen om dit in de normale modus te doen, maar in de opdrachtpromptmodus, zodat win32 je script niet boycot).
De tutorial is erg cool. Maar trouwens, de broncode van Python compileert niet, het is een geïnterpreteerde taal.
Het kan worden gecompileerd tot pseudocode. Het is geen machinetaal maar bytes die iets vertegenwoordigen voor de tolk, maar het proces wordt ook wel gecompileerd genoemd. In die zin is het mogelijk om te zeggen dat er iets is samengesteld.
Misschien is het beter om pytgk2 te leren, omdat de nieuwste versie die beschikbaar is voor Windows 2.24 is. Series 3 schittert door afwezigheid. En roddels zeggen dat kabouter alle api's in elke nieuwe versie breekt.
Ik programmeer mockup met GTK 3.4/3.6 en de waarheid breekt je geduld en hoofd, je moet de code herschrijven, nu begrijp ik waarom die van Linux Mint klagen over GTK en het GNOME-project.
Voor die van MINT ben ik het eens met GTK 2.4 dat dit niet is gebeurd.
Goede tutorial en referenties.
Gewoon een detail, aangezien er code is ingevoerd, zijn inspringingen in Python verplicht en moeten worden gerespecteerd in de voorbeeldcode.
Groeten!
Kun je uitleggen waar de verplichte identificaties in Python uit bestaan? Ik zeg je de waarheid, dat heb ik nog nooit gehoord. Ik ben alleen zo gewend aan PyGTK 2/3 forums in het Engels en misschien zie ik het over het hoofd .
In Python gebruik je geen accolades zoals in C of begin-/eindblokken zoals in Pascal, maar alles wordt begrepen door de inspringing die je aan de code geeft. Dat wil zeggen, de blokken worden herkend doordat ze ingesprongen zijn. Het is een functie waar ik bijzonder van hou. Men vermijdt het schrijven van sleutels en dat soort dingen.
Ik vind dat gewoon niet leuk, het lijkt eenvoudiger om twee kleine toetsen of een std::endl; te plaatsen dan om viedo te zijn als de regel goed getabelleerd is xd
:p Je programmeerleraar geeft je een 0. Of erger nog, ze zullen je ontslaan van je werk. Het belangrijkste is dat de code leesbaar is met alle gevolgen van dien.
eindigend met accolades sluiten, dat maakt het veel leesbaarder XD ..
Echt waar???
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);}
Zie je? Zonder de inkepingen wordt het niet erg goed begrepen. En dat is een makkelijke. Met een meer complexe, begrijpt alleen de compiler het. Het punt is, aangezien je toch MOET inspringen (voor mensen om de code te begrijpen), waarom zou je overbodig zijn en scheidingstekens gebruiken? Gewoon inspringen en dat is het.
Natuurlijk wordt er niets begrepen, omdat je de regels van goed schrijven voor een c/c++-programma niet respecteert. Wat je deed is geldig voor alles, zoals het nesten van een functie, binnen een functie binnen een andere functie die zich in een andere bevindt, dan wil ik je zien xd als je het kunt begrijpen.
trouwens, met twee blikken is die code goed te begrijpen xD
Ik deed wat ik met opzet deed om u te laten zien dat het zonder inspringen, ondanks het feit dat het compileert, buitengewoon moeilijk is om welke code dan ook te begrijpen. Je hebt dus 2 regels: inspringen en omsluiten met scheidingstekens. Maar dat is overbodig. In Python wordt dergelijke code simpelweg niet geaccepteerd door de tolk. En je hebt maar één regel: Inspringen. Eenvoudig.
Maar goed, ieder zijn smaak.
Beide zijn goed, ingesprongen en niet-ingesprongen, naar mijn mening geef ik de voorkeur aan puntkomma- of robijnstijl, vergelijkbaar met python maar inspringen is niet nodig.
Dit is begrijpelijker :P:
echo 'int main(int argc, char *argv[]){program_name = argv[0];while ((argc > 1) && (argv[1][0] == '-')) {schakelaar (argv[ 1][1]) { geval 'v':verbose = 1; break;case 'o':out_file = &argv[1][2];break;case 'l':line_max = atoi(&argv[1][2]);break;default:fprintf(stderr,"Slechte optie %s \n", argv[1]);usage();}++argv;–argc;} if (argc == 1) {do_file("print.in");} else {terwijl (argc > 1) { do_file(argv[1]);++argv;–argc;}}return (0);}' | perl -p -e 's/\{/\{\n\t/g;s/\;/\;\n\t/g;s/\t\}/\}/g;'
Groeten 😀
Ik denk dat Carlos bedoelt dat waar de code uitkomt er geen inspringingen zijn. Dat werkt met kopiëren en plakken gewoon niet. Ik weet niet of de tag bestaat bij het maken van een bericht
taalcode plaatsen. Het zou leuk zijn als ze het plaatsen als het niet bestaat.Ik zag al wat het probleem is: de CODE Tag verwijdert alle spaties en tabs (dat zou niet moeten!!!) Maar als je er een nbsp op zet dan ziet de code er goed uit. A0 in hex (160 in dec) hoewel ik denk dat het kan afhangen van het lettertype (ik weet het niet). Indien gebruikt, wordt het als volgt uitgevoerd:
def fib(n):
a, b = 0, 1
while a < n:
print(a)
a, b = b, a+b
Dat het er in mijn tests goed uitziet, maar ik heb geen voorbeeld bij het plaatsen van antwoorden (en dat zou er moeten zijn!!!) Als het er niet uitkomt, is het niet mijn schuld 😉
Kijk naar de voorbeelden die Sebastian Pölsterl geeft in zijn PyGTK 3 tutorial, Sebastian plaatst geen labels.
Voorbeeld:
http://python-gtk-3-tutorial.readthedocs.org/en/latest/entry.html#example
je kunt de hele tutorial van Sebastian zien.
Ik begrijp niet wat je bedoelt. Wat ik wil zeggen is dat het hier, in de berichten, niet mogelijk is om de HTML-tag "CODE" te gebruiken, zodat wat je als code invoert, er goed ingesprongen uitkomt. Als u naar de paginabronnen kijkt, ziet u op de pagina waarnaar u verwijst, dat deze geen CODE gebruikt, maar andere HTML-scheidingstekens.
Het is niet tegen de code die je hebt gepost, maar wijst eerder op een fout in het postsysteem van deze site. Wat beheerders misschien kunnen oplossen.
Als ik het over tags heb, heb ik het duidelijk over HTML, niet over Python. In ieder geval, als je niet-ingesprongen code in Python stopt, werkt het gewoon niet. Als een nieuweling komt en de code kopieert zoals deze in dit bericht wordt weergegeven en deze probeert uit te voeren, zal deze mislukken. Je kunt gefrustreerd raken omdat je een nieuweling bent. Nogmaals, het is niet jouw schuld; en in mijn vorige onmiddellijke antwoord gaf ik een manier om het probleem op te lossen vanaf het niveau van de postende gebruiker.
Je hebt helemaal gelijk, ik had foto's moeten uploaden in plaats van de code te kopiëren.
om te laten zien hoe u verklaringen correct kunt ordenen in PyGTK 3.
Om met python te programmeren, raad ik aan om Eclipse te gebruiken met de PyDev-plug-in of de Pychar m
Zoals ze hierboven vermeldden, is dat precies waarom ik niet van python hou, vanwege het probleem van inkepingen. Zoals we hebben gezien, werkt kopiëren en plakken niet, wat niet gebeurt met andere talen zoals C, Java, PHP, enz.
Wat de leesbaarheid betreft, passen we een codeverfraaier toe (zoals http://indentcode.net/ ) en klaar,
Het lelijke is opgelost, maar als er geen inkeping is en de logica is veranderd, klinken we...
Ik ben nieuw bij PyGTK, is het mogelijk om te communiceren met shellscripts in deze taal?
Bedankt voor de tutorial.
Groeten.