PyGTK 3.0 உடன் ஒரு சிறிய நிரலை உருவாக்க உள்ளோம், இது PyGTK 3.4 க்கும் வேலை செய்கிறது. ஒரு நிரலை இரண்டு அல்லது அதற்கு மேற்பட்ட கோப்புகளாக எவ்வாறு பிரிப்பது என்பதை இந்த சிறிய GUI உங்களுக்குக் கற்பிக்கும்.
புதிய PyGTK 3 குறித்த செபாஸ்டியன் பால்ஸ்டெர்லின் டுடோரியலை நீங்கள் பார்வையிடலாம், இங்கே புதிய பயிற்சி உள்ளது, நான் இணைப்பை விட்டு விடுகிறேன்:
http://python-gtk-3-tutorial.readthedocs.org/en/latest/index.html
இது செபாஸ்டியனின் வலைப்பதிவு.
செபாஸ்டியனின் இந்த டுடோரியலின் ஒரு விமர்சனம் என்னவென்றால், ஒரு நிரலை எவ்வாறு பகுதிகளாக அல்லது பல கோப்புகளாகப் பிரிப்பது என்று அது கற்பிக்கவில்லை, PyGTK 3 உடன் அதை எவ்வாறு செய்வது என்பதற்கான உதாரணத்தை அவர் காட்டியிருந்தால் நன்றாக இருந்திருக்கும்.
அனைத்து பெரிய மற்றும் சிக்கலான நிரல்களும் பல கோப்புகளாக பிரிக்கப்பட்டுள்ளன மற்றும் கோப்புகள் மற்ற கோப்பகங்களில் கூட வைக்கப்படுகின்றன, அதாவது அவை வெவ்வேறு கோப்புறைகளில் அமைந்துள்ளன.
சிறிய எடுத்துக்காட்டுடன் ஆரம்பிக்கலாம்:
Gui.py எனப்படும் ஒற்றை கோப்பில் எழுதும் குறியீடு இங்கே. கெடிட் உரை திருத்தியை அல்லது நாம் அதிகம் பயன்படுத்தும் எடிட்டரைத் திறந்து, கீழே உள்ள குறியீட்டை நகலெடுத்து gui.py ஆக சேமிக்கிறோம்
ஜி.ஐ. (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 ("கிளிக்", self.on_open_clicked) self.box.pack_start (self.button, true, true, 0) self.button = Gtk.Button ( label = 'மூடு') self.button.connect ("கிளிக்", self.on_close_clicked) self.box.pack_start (self.button, true, true, 0) self.window.show_all () Gtk.main () __name__ என்றால் == '__ மெயின்__': குய் = குய் ()
def on_open_clicked (self, button): அச்சிடு "\" திற \ "பொத்தானைக் கிளிக் செய்யப்பட்டது"
திறந்த பொத்தானைக் கிளிக் செய்யும் போது இது முனையத்தில் செயல்படுத்தப்படும் ஒரு செயல்பாடு. அதை செயல்படுத்த சமிக்ஞை:
self.button.connect ("கிளிக்", self.on_open_clicked) def on_close_clicked (self, button): அச்சிடு "பயன்பாட்டை நிறைவு" Gtk.main_quit ()
இது மூடு பொத்தானைக் கிளிக் செய்யும் போது செயல்படுத்தப்படும் ஒரு செயல்பாடு.
நாங்கள் இயக்கும் நிரலை மூடுக.
அதை செயல்படுத்த சமிக்ஞை
gi.repository import Gtk ### இலிருந்து self.button.connect ("கிளிக்", self.on_close_clicked) நாங்கள் PyGTK நூலகங்களை அழைக்கிறோம் ### வகுப்பு gui (): ### குய் எனப்படும் வகுப்பு வரையறை முக்கிய வகுப்பு # ##
விட்ஜெட்களின் பிரகடனம்: விட்ஜெட்டுகள் என்பது நாம் பயன்படுத்தும் GUI நூலகங்களால் முன்னரே தீர்மானிக்கப்பட்ட ஒரு நிரலாகும். எடுத்துக்காட்டாக, விட்ஜெட்டுகள் ஒரு பொத்தான், ஒரு சாளரம், ஒரு பெட்டி போன்றவை. எங்கள் திட்டத்தில் நாங்கள் அறிவிக்கும் விட்ஜெட்டுகள் இவை.
self.window = Gtk.Window () ### சாளரம் ### self.box = Gtk.Box () ### பெட்டி #### self.button = Gtk.Button (label = 'Open') ### # திறந்த பொத்தான் #### self.button = Gtk.Button (label = 'Close') #### மூடு பொத்தான் #### self.window.add (self.box) #### பெட்டியில் உள்ளது சாளரம் என்று அழைக்கப்படும் சாளரம் #### self.box.pack_start (self.button, True, True, 0) ##### ### self.window.show_all () ## என்ற பெட்டியில் பொத்தானைக் கொண்டுள்ளது. # முழு சாளரத்தையும் காண்பிக்கிறோம் ### gui = gui () ### ஒரு குய் பொருளை உருவாக்கு ####
டெஸ்க்டாப்பில் எங்கள் விஷயத்தில் எளிமையான கோப்புறையில் எங்கள் நிரலை வைக்கிறோம்
கோப்புறையை முனையத்துடன் திறக்கிறோம், என் விஷயத்தில் நான் லினக்ஸ் புதினா 14 இலிருந்து நெமோவைப் பயன்படுத்துகிறேன்.
தொகுக்க நாம் முனையத்தில் பைதான் gui.py ஐ வைக்கிறோம்
படத்தைப் பார்க்கவும்.
இப்போது எங்கள் சிறிய நிரல் அல்லது PyGTK 3 நூலகங்களுடன் உருவாக்கப்பட்ட புதிய விட்ஜெட்டைக் காணலாம்
இது இரண்டு பொத்தான்கள் கொண்ட எளிய சாளரம்.
இப்போது நாம் நிரலை மூன்று பகுதிகளாகப் பிரிக்கிறோம், பின்னர் மூன்று கோப்புகளுக்கான குறியீட்டை விட்டு விடுகிறேன்.
முதல் gui.py கோப்பு
gi.repository import இலிருந்து Gtk இறக்குமதி இறக்குமதியிலிருந்து io இறக்குமதி io class gui (அழிக்க, io): def __init __ (self): self.window = Gtk.Window () self.window.connect ('நீக்கு-நிகழ்வு', Gtk .main_quit) self.box = Gtk.Box () self.window.add (self.box) self.button = Gtk.Button (label = 'Open') self.button.connect ("கிளிக்", self.on_open_clicked) self.box.pack_start (self.button, True, True, 0) self.button = Gtk.Button (label = 'Close') self.button.connect ("கிளிக்", self.on_close_clicked) self.box.pack_start ( self.button, உண்மை, உண்மை, 0) self.window.show_all () Gtk.main () என்றால் __name__ == '__main__': gui = gui ()
இரண்டாவது io.py கோப்பு
class io: def on_open_clicked (self, button): அச்சிடு "\" திற \ "பொத்தானைக் கிளிக் செய்யப்பட்டது"
மூன்றாவது கோப்பு dest.py
gi.repository import இலிருந்து Gtk class dest: def on_close_clicked (self, button): அச்சிடு "பயன்பாட்டை நிறைவு" Gtk.main_quit ()
எங்கள் விஷயத்தில் மூன்று கோப்புகளை ஒரே கோப்புறையில் வைக்கிறோம், கோப்புறை எளிய பிரிக்கப்பட்டதாக அழைக்கப்படுகிறது.
மூன்று கோப்புகளை தொகுக்க. நாம் முனையத்துடன் கோப்புறையைத் திறந்து அதை முனையத்தில் மீண்டும் வைக்கிறோம்
python gui.py
Gui.py குறியீட்டில் செய்யப்பட்ட மாற்றங்கள்
எங்கள் கோப்பை இறக்குமதி செய்ய ### அறிக்கையை அழிக்கவும். எங்கள் கோப்பை இறக்குமதி செய்ய io இறக்குமதி io ### அறிக்கையிலிருந்து io.py ### வகுப்பு குய் (அழிக்கவும், io): #### வகுப்பிற்கு முக்கியமாக நாம் துணைப்பிரிவுகளை அழித்து io #### ஐ சேர்க்கிறோம்
அந்த வாக்கியத்தை நீங்கள் காணலாம்
def on_open_clicked (self, button): அச்சிடு "\" திற \ "பொத்தானைக் கிளிக் செய்யப்பட்டது"
இது gui.py இல் இல்லை, இது io.py கோப்பில் உள்ளது
தண்டனை
def on_close_clicked (சுய, பொத்தான்):
"பயன்பாட்டை நிறைவு" அச்சிடுக
Gtk.main_quit ()
இது dest.py கோப்பில் அமைந்துள்ளது
இவ்வாறு ஒரே நேரத்தில் வெவ்வேறு கோப்பகங்களில் அமைந்துள்ள பல கோப்புகளாக ஒரு நிரலைப் பிரிக்கலாம்.
மறுபுறம், பைதான் இலவச மென்பொருளின் தூணாகும், மேலும் இது ஜி.டி.கே 3.6 / 3.8 உடன் வேலை செய்யத் தழுவி உள்ளது, அதன் பெயர் பைஜிடிகே. KDE க்கான பைத்தானின் தழுவல் PyQT என அழைக்கப்படுகிறது.
பைதான் மேக் ஓஎஸ் மற்றும் விண்டோஸ் ஆகியவற்றிற்கு ஏற்றது.
இந்த PyGTK3 மினி டுடோரியல் உங்களுக்கு உதவியாக இருக்கும் என்று நம்புகிறேன். அவர்கள் விரும்பும் ஆக்கபூர்வமான விமர்சனங்கள் அனைத்தையும் அவர்கள் செய்ய முடியும்.
சில ஜி.டி.கே 3.4 / 3.6 மற்றும் வாலா ஜி.டி.கே 3.4 / 3.6 ஆகியவற்றை நான் அறிவேன்.
http://www.youtube.com/watch?v=9ckRn_sx8CE
கடைசியாக, கே.டி.இ-க்கு மினி டுடோரியல் செய்யாததற்காக கே.டி.இ பயனர்கள் மன்னிப்பு கேட்கிறார்கள்.
Kde இல் நான் குயியை எளிதில் உருவாக்க kdevelop ஐப் பயன்படுத்த விரும்புகிறேன் (அதுதான் இது என்று நான் நினைக்கிறேன்) ஆனால் அது x விஷயத்தை நிகழ்த்துவதற்கான செயல்முறைகளைக் கண்டறிவதில் எனக்கு இன்னும் கடினமாக உள்ளது: '(
பைத்தானைப் பயன்படுத்துபவர்களுக்கு சிறந்தது: டி!
நன்றி!
வணக்கம், நான் இந்த சமூகத்தை நீண்ட காலமாகப் பின்பற்றி வருகிறேன், இது நான் கருத்து தெரிவித்த முதல் தடவையா அல்லது நான் முன்பே செய்துள்ளேனா என்பது எனக்குத் தெரியவில்லை 😀 (வலையில் கருத்துரைகளை எழுதுவதற்கு நான் மிகவும் கொடுக்கப்படவில்லை). விஷயம் என்னவென்றால், நிர்வாகிகளாக எலவ் மற்றும் கே.ஜே.கே.ஜி ^ காரா ஆகியோருக்கு ஒரு ஆலோசனையை விட்டுவிடுவதற்காக நான் இதைச் செய்கிறேன், மேலும் தொடரியல் வண்ணமயமாக்கலுக்கான சொருகி ஒன்றைச் சேர்ப்பது நல்ல யோசனையாக இருக்கும் என்று நான் நினைக்கிறேன், இப்போது வெவ்வேறு நிரலாக்க மொழிகளில் குறியீட்டைக் கொண்ட கூடுதல் இடுகைகளைப் பார்க்கிறேன். சில செருகுநிரல்கள் இருப்பதை நான் அறிவேன், ஆனால் நான் ஒரு வேர்ட்பிரஸ் பயனராக இல்லாததால் நான் எதையும் முயற்சிக்கவில்லை, எனவே கோரிக்கையின் நம்பகத்தன்மையைப் பற்றி சிந்திக்க உங்களை விட்டு விடுகிறேன். மீதமுள்ள வாசகர்களிடம் அவர்கள் என்ன நினைக்கிறார்கள் என்று கேட்க இந்த வாய்ப்பை நான் பயன்படுத்துகிறேன், ஏனென்றால் எந்த அலங்காரமும் இல்லாமல் குறியீட்டைப் படிக்க விரும்பும் நபர்கள் அங்கே இருக்கிறார்கள் என்பது எனக்குத் தெரியும். இது ஏற்கனவே இங்கு கருத்து தெரிவிக்கப்பட்டிருந்தால், மன்னிப்பு கேட்டுக்கொள்கிறேன், சில காரணங்களால் அது நிராகரிக்கப்பட்டது, ஏனெனில் இந்த விஷயத்தில் எந்த விவாதத்தையும் நான் நினைவில் இல்லை.
உண்மை என்னவென்றால், நிரலாக்க மொழிகளின் குறியீட்டை முன்னிலைப்படுத்த தொடரியல் வண்ணமயமாக்குவதற்கான விருப்பத்தை நான் விரும்புகிறேன்.
நிரலாக்க மொழிகளைக் கற்க விரும்பும் பயனர்களுக்கு இது உதவும்.
ஆனால் ஏய், நான் மன்றத்துடன் வசதியாக இருக்கிறேன், நாங்கள் ஒன்றாக விவாதிக்கலாம் மற்றும் கற்றுக்கொள்ளலாம்.
குனு எமாக்ஸ் மிகவும் வசதியானது, ஏனென்றால் நீங்கள் எந்த நிரலாக்க மொழி சரிபார்ப்பில் நீங்கள் வேலை செய்ய விரும்புகிறீர்கள் என்பதை தேர்வு செய்ய வேண்டும் (உங்கள் செயலிக்கு அதிக எடை தேவையில்லை என்றால், குனு நானோவைப் பயன்படுத்துங்கள் மற்றும் மினிமலிசத்தை அதன் சிறந்த முறையில் அனுபவிக்கவும்).
எலியோ நாம் வேர்ட்பிரஸ் பற்றி பேசுகிறோம். வலைப்பதிவில் செயல்படுத்தப்பட்டது Desde Linux. இடுகைகளின் எழுத்துக்களை வண்ணமயமாக்கும் செயல்பாடுகள் இதில் இல்லை.
ஓ மன்னிக்கவும்.
84 விரல்கள் எக்ஸ்டி உள்ளவர்களுக்கு Naaa emacs வசதியானது .., சாதாரண மக்கள், டெக்ஸ்ட்மேட், சப்ளைமெடெக்ஸ்ட் அல்லது நோட்பேட் ++ xd
நம்பமுடியாத விஷயம் தட்டச்சு கற்றுக் கொள்ளவில்லை, இது குனு எமாக்ஸையும் அதன் விசைப்பலகை குறுக்குவழிகளையும் நன்றாக கையாள முடியும். கூடுதலாக, அதன் GUI அதன் மெனுக்களைப் பயன்படுத்துவதை எளிதாக்குகிறது (இது விண்டோஸில் பயன்படுத்தப்படலாம், ஆனால் அதை சாதாரண பயன்முறையில் செய்ய பரிந்துரைக்கப்படவில்லை, ஆனால் கட்டளை வரியில் பயன்முறையில் win32 உங்கள் ஸ்கிரிப்டை புறக்கணிக்காது).
மிகவும் அருமையான பயிற்சி. ஆனால் மூலம், பைதான் மூலக் குறியீடு தொகுக்கப்படவில்லை, இது ஒரு விளக்கப்பட்ட மொழி.
இதை போலி குறியீடுக்கு தொகுக்கலாம். இது இயந்திர மொழி அல்ல, ஆனால் மொழிபெயர்ப்பாளருக்கு எதையாவது குறிக்கும் பைட்டுகள், ஆனால் செயல்முறை தொகுக்கப்பட்டதாகவும் அழைக்கப்படுகிறது. இந்த அர்த்தத்தில், ஏதாவது தொகுக்கப்பட்டுள்ளது என்று சொல்ல முடியும்.
விண்டோஸுக்கான சமீபத்திய பதிப்பு 2 என்பதால் பைட்க் 2.24 ஐக் கற்றுக்கொள்வது நல்லது. தொடர் 3 அதன் இல்லாததால் வெளிப்படையானது. ஒவ்வொரு புதிய பதிப்பிலும் ஜினோம் அனைத்து அப்பிஸையும் உடைக்கிறது என்று கெட்ட நாக்குகள் கூறுகின்றன.
நான் ஜி.டி.கே 3.4 / 3.6 உடன் ஒரு மொக்கப்பை நிரல் செய்கிறேன், உண்மை என்னவென்றால் அவை உங்கள் பொறுமையையும் தலையையும் உடைக்கின்றன, நீங்கள் குறியீட்டை மீண்டும் எழுத வேண்டும், இப்போது லினக்ஸ் புதினா மக்கள் ஜி.டி.கே மற்றும் க்னோம் திட்டம் குறித்து ஏன் புகார் கூறுகிறார்கள் என்பது எனக்கு புரிகிறது.
MINT இன் நபர்களுக்கு நான் ஜி.டி.கே 2.4 உடன் உடன்படுகிறேன் இது நடக்கவில்லை.
நல்ல பயிற்சி மற்றும் குறிப்புகள்.
ஒரு விவரம், குறியீடு வைக்கப்பட்டுள்ளதால், பைத்தான் உள்தள்ளல்கள் கட்டாயமாகும், எடுத்துக்காட்டாக குறியீட்டில் மதிக்கப்பட வேண்டும்.
நன்றி!
பைத்தானில் உள்ள கட்டாய அடையாளங்கள் எவை என்பதை நீங்கள் விளக்க முடியுமா? நான் உங்களுக்கு உண்மையைச் சொல்கிறேன், நான் அதைக் கேள்விப்பட்டதே இல்லை. நான் ஆங்கிலத்தில் PyGTK 2/3 மன்றங்களுடன் மோசமாகப் பழகிவிட்டேன், ஒருவேளை நான் அதைக் கவனிக்கவில்லை.
பைத்தானில் நீங்கள் சி போன்ற விசைகளைப் பயன்படுத்துவதில்லை அல்லது பாஸ்கலில் உள்ளதைப் போன்ற தொடக்க / இறுதித் தொகுதிகளைப் பயன்படுத்த வேண்டாம், ஆனால் நீங்கள் குறியீட்டிற்கு கொடுக்கும் உள்தள்ளல் மூலம் எல்லாம் புரிந்து கொள்ளப்படும். அதாவது, தொகுதிகள் உள்தள்ளப்பட்டதாக அங்கீகரிக்கப்படுகின்றன. இது நான் குறிப்பாக விரும்பும் ஒரு அம்சம். விசைகள் மற்றும் அது போன்ற விஷயங்களை எழுதுவதைத் தவிர்க்கிறீர்கள்.
எனக்கு அது பிடிக்கவில்லை, xd வரி நன்கு அட்டவணைப்படுத்தப்பட்டிருந்தால் பார்க்கப்படுவதை விட இரண்டு சிறிய விசைகள் அல்லது ஒரு வகுப்பு :: endl;
: p உங்கள் நிரலாக்க ஆசிரியர் உங்களுக்காக 0 வைப்பார். அல்லது மோசமாக, அவர்கள் உங்கள் வேலையிலிருந்து உங்களை நீக்குவார்கள். மிகவும் முக்கியமானது என்னவென்றால், குறியீட்டைக் குறிக்கும் எல்லாவற்றையும் கொண்டு படிக்க முடியும்
மூடும் பிரேஸ்களுடன் முடிவடைகிறது, இது என்னை மிகவும் படிக்கக்கூடிய எக்ஸ்டி ஆக்குகிறது ..
தீவிரமாக ???
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);}
நீங்கள் பார்க்கிறீர்களா? உள்தள்ளல்கள் இல்லாமல் அது நன்றாக புரிந்து கொள்ளப்படவில்லை. அது ஒரு எளிதானது. மிகவும் சிக்கலான ஒன்றைக் கொண்டு, தொகுப்பி மட்டுமே அதைப் புரிந்துகொள்கிறது. விஷயம் என்னவென்றால், நீங்கள் எப்படியும் உள்தள்ள வேண்டும் என்பதால் (மனிதர்கள் குறியீட்டைப் புரிந்து கொள்ள) நீங்கள் ஏன் பணிநீக்கம் செய்ய வேண்டும் மற்றும் பிரிப்பான்களைப் பயன்படுத்த வேண்டும்? உள்தள்ளலுடன் போதும், அவ்வளவுதான்.
நிச்சயமாக, எதுவும் புரியவில்லை, ஏனென்றால் சி / சி ++ இல் ஒரு நிரலின் நல்ல எழுத்தின் விதிகளை நீங்கள் மதிக்கவில்லை. நீங்கள் செய்தது என்னவென்றால், ஒரு செயல்பாட்டைக் கூடு கட்டுவது, ஒரு செயல்பாட்டினுள் இன்னொரு செயல்பாட்டினுள் இருக்கும் மற்றொரு செயல்பாட்டிற்குள் செல்லுபடியாகும், அதை நீங்கள் புரிந்து கொள்ள முடிந்தால் உங்களை xd ஐப் பார்க்க விரும்புகிறேன்.
மூலம், இரண்டு தோற்றங்களுடன், அந்த குறியீடு எளிதில் புரிந்துகொள்ளக்கூடிய xD ஆகும்
உள்தள்ளல் இல்லாமல், தொகுத்திருந்தாலும், எந்த குறியீட்டையும் புரிந்துகொள்வது மிகவும் கடினம் என்பதை உங்களுக்குக் காண்பிக்கும் நோக்கில் நான் என்ன செய்தேன். எனவே உங்களிடம் 2 விதிகள் உள்ளன: டிலிமிட்டர்களுடன் உள்தள்ளவும் இணைக்கவும். ஆனால் அது தேவையற்றது. பைத்தானில் இத்தகைய குறியீடு மொழிபெயர்ப்பாளரால் ஏற்றுக்கொள்ளப்படவில்லை. உங்களுக்கு ஒரே ஒரு விதி மட்டுமே உள்ளது: உள்தள்ளல். சுலபம்.
ஆனால் ஏய், எல்லோரும் தங்கள் சுவைகளுடன்.
இரண்டும் நல்லவை, உள்தள்ளப்பட்டவை மற்றும் உள்தள்ளப்படாதவை, என் கருத்துப்படி நான் மலைப்பாம்பைப் போன்ற அரைப்புள்ளி பாணி அல்லது மாணிக்கத்தை விரும்புகிறேன், ஆனால் உள்தள்ளல் தேவையில்லை.
இது நன்கு புரிந்து கொள்ளப்படுகிறது: பி:
எதிரொலி 'int main (int argc, char * argv []) {program_name = argv [0]; அதே நேரத்தில் ((argc> 1) && (argv [1] [0] ==' - ')) {சுவிட்ச் (argv [ 1] [1]) {வழக்கு 'வி': வினைச்சொல் = 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]); பயன்பாடு ();} ++ argv; –argc;} if (argc == 1) {do_file (" print.in ");} else {போது (argc> 1 ) {do_file (argv [1]); ++ argv; –argc;}} return (0);} '| perl -p -e 's / \ {/ \ {\ n \ t / g; s / \; / \; \ n \ t / g; s / \ t \} / \ g / g;'
வாழ்த்துக்கள்
கார்லோஸ் என்றால் குறியீடு வெளியே வரும் இடத்தில் எந்த உள்தள்ளல்களும் இல்லை என்று நினைக்கிறேன். நகல் மற்றும் ஒட்டுடன் அது இயங்காது. ஒரு இடுகையை உருவாக்கும் போது குறிச்சொல் இருக்கிறதா என்று எனக்குத் தெரியவில்லை
மொழி குறியீட்டை உள்ளிட. அது இல்லாவிட்டால் அவர்கள் அதை வைத்தால் நல்லது.சிக்கல் என்ன என்பதை நான் ஏற்கனவே பார்த்தேன்: CODE டேக் எல்லா இடங்களையும் தாவல்களையும் நீக்குகிறது (அது அவ்வாறு செய்யக்கூடாது !!!) ஆனால் நீங்கள் அதில் ஒரு nbsp ஐ வைத்தால், குறியீடு நன்றாக இருக்கும். ஹெக்ஸில் A0 (டிசம்பரில் 160) இது எழுத்துருவைப் பொறுத்தது என்று நான் நினைக்கிறேன் (எனக்குத் தெரியாது). இது பயன்படுத்தப்பட்டால் அது இவ்வாறு வெளிவருகிறது:
def fib(n):
a, b = 0, 1
while a < n:
print(a)
a, b = b, a+b
எனது சோதனைகளில் இது நன்றாக இருக்கிறது, ஆனால் நான் பதில்களை இடுகையிடும்போது எனக்கு முன்னோட்டம் இல்லை (அது இருக்க வேண்டும் !!!) அது வெளியே வரவில்லை என்றால், அது என் தவறு குல்பா அல்ல
செபாஸ்டியன் பால்ஸ்டர்ல் தனது PyGTK 3 டுடோரியலில் கொடுக்கும் எடுத்துக்காட்டுகளைப் பாருங்கள், செபாஸ்டியன் லேபிள்களை வைக்கவில்லை.
உதாரணமாக :
http://python-gtk-3-tutorial.readthedocs.org/en/latest/entry.html#example
செபாஸ்டியனின் அனைத்து பயிற்சிகளையும் நீங்கள் காணலாம்.
நீ என்ன சொல்கிறாய் என்று எனக்கு தெரியாது. நான் சொல்வது என்னவென்றால், இங்கே, இடுகைகளில், "கோட்" HTML குறிச்சொல்லைப் பயன்படுத்த முடியாது, இதனால் நீங்கள் குறியீடாக வைத்தது மற்றும் அது நன்கு உள்தள்ளப்பட்டிருக்கும். நீங்கள் குறிப்பிடும் பக்கத்தில், பக்க மூலங்களைக் கண்டால், அது CODE ஐப் பயன்படுத்தாது, ஆனால் பிற HTML டிலிமிட்டர்களைப் பயன்படுத்துகிறது என்பதை நீங்கள் காண்பீர்கள்.
இது நீங்கள் வைத்த குறியீட்டிற்கு எதிரானது அல்ல, மாறாக இந்த தளத்தின் இடுகையிடல் அமைப்பில் உள்ள குறைபாட்டை சுட்டிக்காட்டுகிறது. எந்த, ஒருவேளை, நிர்வாகிகள் சரிசெய்ய முடியும்.
குறிச்சொற்களைப் பற்றி நான் பேசும்போது நான் வெளிப்படையாக பேசுவது HTML ஐப் பற்றியது, பைத்தான் அல்ல. எப்படியிருந்தாலும், பைத்தானில் உள்தள்ளல் இல்லாமல் குறியீட்டை வைத்தால் அது இயங்காது. ஒரு புதியவர் வந்து இந்த இடுகையில் தோன்றும் குறியீட்டை நகலெடுத்து அதை இயக்க முயற்சித்தால், அவர் தோல்வியடைவார். நீங்கள் ஒரு புதியவர் என்பதால் நீங்கள் விரக்தியடையலாம். மீண்டும், தவறு உங்களுடையது அல்ல; எனது உடனடி முந்தைய பதிலில், பயனர்-யார்-இடுகைகள் மட்டத்திலிருந்து சிக்கலைத் தீர்க்க ஒரு வழியைக் கொடுத்தேன்.
நீங்கள் சொல்வது சரிதான், குறியீட்டை நகலெடுப்பதற்கு பதிலாக புகைப்படங்களை நான் பதிவேற்றியிருக்க வேண்டும்.
PyGTK 3 இல் அறிக்கைகள் எவ்வாறு ஒழுங்காக வரிசைப்படுத்தப்பட்டுள்ளன என்பதைக் காட்ட.
பைத்தானுடன் நிரல் செய்ய பைடேவ் சொருகி அல்லது பைகார் மீ உடன் கிரகணத்தைப் பயன்படுத்த பரிந்துரைக்கிறேன்
மேலே கருத்து தெரிவித்தபடி, உள்தள்ளல் பிரச்சினை காரணமாக நான் பைத்தானை விரும்பவில்லை. நாம் பார்த்தபடி, நகல் மற்றும் ஒட்டு செய்வது வேலை செய்யாது, இது சி, ஜாவா, PHP போன்ற பிற மொழிகளுடன் நடக்காது.
படிக்கக்கூடிய விஷயம், நாங்கள் ஒரு குறியீடு அழகுபடுத்தியைப் பயன்படுத்துகிறோம் (போன்றவை http://indentcode.net/ ) மற்றும் தயாராக,
அசிங்கமானது சரி செய்யப்பட்டது, ஆனால் உள்தள்ளல் இல்லாதிருந்தால் மற்றும் தர்க்கம் மாற்றப்பட்டால், நாங்கள் ஒலிக்கிறோம் ..
நான் PyGTK க்கு புதியவன், இந்த மொழியில் ஷெல் ஸ்கிரிப்டுகளுடன் தொடர்பு கொள்ள முடியுமா?
பயிற்சிக்கு நன்றி.
வாழ்த்துக்கள்.