ನಾವು PyGTK 3.0 ನೊಂದಿಗೆ ಸಣ್ಣ ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು ಹೊರಟಿದ್ದೇವೆ ಅದು PyGTK 3.4 ಗಾಗಿ ಸಹ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಫೈಲ್‌ಗಳಾಗಿ ಹೇಗೆ ವಿಂಗಡಿಸಬೇಕು ಎಂಬುದನ್ನು ಈ ಚಿಕ್ಕ ಜಿಯುಐ ನಿಮಗೆ ಕಲಿಸುತ್ತದೆ.
ಹೊಸ ಪಿಜಿಟಿಕೆ 3 ಕುರಿತು ಸೆಬಾಸ್ಟಿಯನ್ ಪಾಲ್ಸ್ಟರ್ಲ್ ಅವರ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ನೀವು ಭೇಟಿ ಮಾಡಬಹುದು, ಇಲ್ಲಿ ಹೊಸ ಟ್ಯುಟೋರಿಯಲ್ ಇದೆ, ನಾನು ಲಿಂಕ್ ಅನ್ನು ಬಿಡುತ್ತೇನೆ:
http://python-gtk-3-tutorial.readthedocs.org/en/latest/index.html
ಇದು ಸೆಬಾಸ್ಟಿಯನ್ ಅವರ ಬ್ಲಾಗ್.
ಸೆಬಾಸ್ಟಿಯನ್ ಅವರ ಈ ಟ್ಯುಟೋರಿಯಲ್ ನ ಒಂದು ಟೀಕೆಯೆಂದರೆ, ಅದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಭಾಗಗಳಾಗಿ ಅಥವಾ ಹಲವಾರು ಫೈಲ್‌ಗಳಾಗಿ ಹೇಗೆ ವಿಂಗಡಿಸಬೇಕು ಎಂಬುದನ್ನು ಕಲಿಸುವುದಿಲ್ಲ, ಪೈಜಿಟಿಕೆ 3 ನೊಂದಿಗೆ ಅದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂಬುದನ್ನು ಅವರು ಉದಾಹರಣೆ ತೋರಿಸಿದ್ದರೆ ಒಳ್ಳೆಯದು.
ಎಲ್ಲಾ ದೊಡ್ಡ ಮತ್ತು ಸಂಕೀರ್ಣ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಅನೇಕ ಫೈಲ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ ಮತ್ತು ಫೈಲ್‌ಗಳನ್ನು ಇತರ ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ ಅವು ವಿಭಿನ್ನ ಫೋಲ್ಡರ್‌ಗಳಲ್ಲಿವೆ.
ಸಣ್ಣ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ:
Gui.py ಎಂಬ ಒಂದೇ ಫೈಲ್‌ನಲ್ಲಿ ಬರೆಯುವ ಕೋಡ್ ಇಲ್ಲಿದೆ. ನಾವು ಹೆಚ್ಚು ಬಳಸುವ ಜೆಡಿಟ್ ಪಠ್ಯ ಸಂಪಾದಕ ಅಥವಾ ಸಂಪಾದಕವನ್ನು ನಾವು ತೆರೆಯುತ್ತೇವೆ, ನಾವು ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು gui.py ಎಂದು ಉಳಿಸುತ್ತೇವೆ
gi.repository import ನಿಂದ Gtk class gui (): def on_open_clicked (self, button): print "\" Open \ "ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಲಾಗಿದೆ" def on_close_clicked (self, button): ಮುದ್ರಣ "ಮುಚ್ಚುವ ಅಪ್ಲಿಕೇಶನ್" 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 ("ಕ್ಲಿಕ್", self.on_open_clicked) self.box.pack_start (self.button, True, True, 0) self.button = Gtk.Button ( ಲೇಬಲ್ = 'ಮುಚ್ಚು') 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.connect ("ಕ್ಲಿಕ್ ಮಾಡಲಾಗಿದೆ", self.on_open_clicked) def on_close_clicked (self, button): ಮುದ್ರಣ "ಮುಚ್ಚುವ ಅಪ್ಲಿಕೇಶನ್" Gtk.main_quit ()
ನಾವು ಕ್ಲೋಸ್ ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಅದು ಸಕ್ರಿಯಗೊಳ್ಳುವ ಕಾರ್ಯವಾಗಿದೆ.
ನಾವು ನಡೆಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮುಚ್ಚಿ.
ಅದನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಸಂಕೇತ
gi.repository ಆಮದು Gtk ನಿಂದ self.button.connect ("ಕ್ಲಿಕ್", self.on_close_clicked) ನಾವು PyGTK ಗ್ರಂಥಾಲಯಗಳನ್ನು ಆಹ್ವಾನಿಸುತ್ತೇವೆ ### ವರ್ಗ ಗುಯಿ (): ### ಗುಯಿ ಎಂಬ ವರ್ಗ ವ್ಯಾಖ್ಯಾನವು ಮುಖ್ಯ ವರ್ಗ # ##
ವಿಜೆಟ್‌ಗಳ ಘೋಷಣೆ: ವಿಜೆಟ್‌ಗಳು ಎನ್ನುವುದು ನಾವು ಬಳಸುವ ಜಿಯುಐ ಲೈಬ್ರರಿಗಳಿಂದ ಮೊದಲೇ ನಿರ್ಧರಿಸಲ್ಪಟ್ಟ ಒಂದು ಪ್ರೋಗ್ರಾಂ. ಉದಾಹರಣೆಗೆ, ವಿಜೆಟ್‌ಗಳು ಒಂದು ಬಟನ್, ವಿಂಡೋ, ಬಾಕ್ಸ್ ಇತ್ಯಾದಿ. ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ನಾವು ಘೋಷಿಸುವ ವಿಜೆಟ್‌ಗಳು ಇವು.
self.window = Gtk.Window () ### ವಿಂಡೋ ### self.box = Gtk.Box () ### ಬಾಕ್ಸ್ #### self.button = Gtk.Button (ಲೇಬಲ್ = 'ಓಪನ್') ### # ತೆರೆದ ಬಟನ್ #### self.button = Gtk.Button (ಲೇಬಲ್ = 'ಮುಚ್ಚು') #### ಮುಚ್ಚು ಬಟನ್ #### self.window.add (self.box) #### ಬಾಕ್ಸ್ ಇದೆ ವಿಂಡೋ ಎಂದು ಕರೆಯಲ್ಪಡುವ ವಿಂಡೋ #### self.box.pack_start (self.button, True, True, 0) ##### ಬಟನ್ ### self.window.show_all () ## ಎಂಬ ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ಅಡಕವಾಗಿದೆ. # ನಾವು ಇಡೀ ವಿಂಡೋವನ್ನು ತೋರಿಸುತ್ತೇವೆ ### gui = gui () ### ಗೈ ವಸ್ತುವನ್ನು ರಚಿಸಿ ####
ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಡೆಸ್ಕ್‌ಟಾಪ್‌ನಲ್ಲಿ ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಸರಳ ಎಂಬ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಇಡುತ್ತೇವೆ
ನಾವು ಟರ್ಮಿನಲ್ನೊಂದಿಗೆ ಫೋಲ್ಡರ್ ಅನ್ನು ತೆರೆಯುತ್ತೇವೆ, ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ನಾನು ಲಿನಕ್ಸ್ ಮಿಂಟ್ 14 ರಿಂದ ನೆಮೊ ಬಳಸುತ್ತೇನೆ.
ಕಂಪೈಲ್ ಮಾಡಲು ನಾವು ಟರ್ಮಿನಲ್ ಪೈಥಾನ್ gui.py ನಲ್ಲಿ ಇರಿಸಿದ್ದೇವೆ
ಚಿತ್ರವನ್ನು ನೋಡಿ.
ಈಗ ನಾವು ನಮ್ಮ ಸಣ್ಣ ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಪಿಜಿಟಿಕೆ 3 ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ ರಚಿಸಲಾದ ಹೊಸ ವಿಜೆಟ್ ಅನ್ನು ನೋಡಬಹುದು
ಇದು ಎರಡು ಗುಂಡಿಗಳನ್ನು ಹೊಂದಿರುವ ಸರಳ ವಿಂಡೋ ಆಗಿದೆ.
ಈಗ ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮೂರು ಭಾಗಗಳಾಗಿ ವಿಂಗಡಿಸುತ್ತೇವೆ, ನಂತರ ನಾನು ಮೂರು ಫೈಲ್‌ಗಳ ಕೋಡ್ ಅನ್ನು ಬಿಡುತ್ತೇನೆ.
ಮೊದಲ gui.py ಫೈಲ್
gi.repository import ನಿಂದ Gtk ಆಮದು ನಾಶದಿಂದ io import io class gui (dest, 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 ("ಕ್ಲಿಕ್", 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, True, True, 0) self.window.show_all () Gtk.main () __name__ == '__main__' ವೇಳೆ: gui = gui ()
ಎರಡನೇ io.py ಫೈಲ್
ವರ್ಗ io: def on_open_clicked (ಸ್ವಯಂ, ಬಟನ್): ಮುದ್ರಿಸು "\" ಓಪನ್ \ "ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಲಾಗಿದೆ"
ಮೂರನೇ ಫೈಲ್ dest.py.
gi.repository import ನಿಂದ Gtk class dest: def on_close_clicked (self, button): "ಅಪ್ಲಿಕೇಶನ್ ಮುಚ್ಚಲಾಗುತ್ತಿದೆ" ಮುದ್ರಿಸು Gtk.main_quit ()
ನಾವು ಮೂರು ಫೈಲ್‌ಗಳನ್ನು ಒಂದೇ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಇಡುತ್ತೇವೆ, ಫೋಲ್ಡರ್ ಅನ್ನು ಸರಳ ಭಾಗ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ಮೂರು ಫೈಲ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು. ನಾವು ಟರ್ಮಿನಲ್ನೊಂದಿಗೆ ಫೋಲ್ಡರ್ ಅನ್ನು ತೆರೆಯುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ
python gui.py
Gui.py ಕೋಡ್‌ಗೆ ಮಾರ್ಪಾಡು ಮಾಡಲಾಗಿದೆ
ನಮ್ಮ ಫೈಲ್ ಅನ್ನು ಆಮದು ಮಾಡಲು ### ಹೇಳಿಕೆಯನ್ನು ನಾಶಮಾಡಿ ### ನಮ್ಮ ಫೈಲ್ ಅನ್ನು ಆಮದು ಮಾಡಲು io.py ### ಹೇಳಿಕೆಯಿಂದ io.py ### ವರ್ಗ ಗುಯಿ (ನಾಶ, io): #### ಗೆ ವರ್ಗ ಮುಖ್ಯ ನಾವು ಉಪವರ್ಗಗಳನ್ನು ನಾಶಪಡಿಸುತ್ತೇವೆ ಮತ್ತು io ####
ನೀವು ವಾಕ್ಯವನ್ನು ನೋಡಬಹುದು
def on_open_clicked (ಸ್ವಯಂ, ಬಟನ್): ಮುದ್ರಿಸು "\" ಓಪನ್ \ "ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಲಾಗಿದೆ"
ಇದು gui.py ನಲ್ಲಿಲ್ಲ, ಅದು io.py ಫೈಲ್‌ನಲ್ಲಿದೆ
ವಾಕ್ಯ
ಡೆಫ್ ಆನ್_ಕ್ಲೋಸ್_ಕ್ಲಿಕ್ ಮಾಡಲಾಗಿದೆ (ಸ್ವಯಂ, ಬಟನ್):
ಮುದ್ರಣ "ಅಪ್ಲಿಕೇಶನ್ ಮುಚ್ಚಲಾಗುತ್ತಿದೆ"
Gtk.main_quit ()
ಇದು dest.py ಫೈಲ್‌ನಲ್ಲಿದೆ
ಹೀಗೆ ನಾವು ಒಂದೇ ಸಮಯದಲ್ಲಿ ವಿವಿಧ ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅನೇಕ ಫೈಲ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಬಹುದು.
ಮತ್ತೊಂದೆಡೆ, ಪೈಥಾನ್ ಉಚಿತ ಸಾಫ್ಟ್‌ವೇರ್‌ನ ಆಧಾರ ಸ್ತಂಭವಾಗಿದೆ, ಮತ್ತು ಇದು ಜಿಟಿಕೆ 3.6 / 3.8 ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ, ಇದರ ಹೆಸರು ಪೈಜಿಟಿಕೆ. ಕೆಡಿಇಗಾಗಿ ಪೈಥಾನ್ ರೂಪಾಂತರವನ್ನು ಪೈಕ್ಯೂಟಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ಪೈಥಾನ್ ಅನ್ನು ಮ್ಯಾಕ್ ಓಎಸ್ ಮತ್ತು ವಿಂಡೊಗಳಿಗಾಗಿ ಅಳವಡಿಸಲಾಗಿದೆ.
ಈ PyGTK3 ಮಿನಿ ಟ್ಯುಟೋರಿಯಲ್ ನಿಮಗೆ ಸಹಾಯಕವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಅವರು ಬಯಸಿದ ಎಲ್ಲಾ ರಚನಾತ್ಮಕ ಟೀಕೆಗಳನ್ನು ಮಾಡಬಹುದು.
ನನಗೆ ಕೆಲವು ಜಿಟಿಕೆ 3.4 / 3.6 ಮತ್ತು ವಾಲಾ ಜಿಟಿಕೆ 3.4 / 3.6 ಸಹ ತಿಳಿದಿದೆ.
http://www.youtube.com/watch?v=9ckRn_sx8CE
ಕೊನೆಯದಾಗಿ, ಕೆಡಿಇಗಾಗಿ ಮಿನಿ ಟ್ಯುಟೋರಿಯಲ್ ಮಾಡದಿದ್ದಕ್ಕಾಗಿ ಕೆಡಿಇ ಬಳಕೆದಾರರು ಕ್ಷಮೆಯಾಚಿಸುತ್ತಾರೆ.
Kde ಯಲ್ಲಿ ನಾನು ಸುಲಭವಾಗಿ ಗುಯಿಯನ್ನು ರಚಿಸಲು kdevelop ಅನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೇನೆ (ಅದನ್ನೇ ಕರೆಯಲಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ) ಆದರೆ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ನನಗೆ ಇನ್ನೂ ಕಷ್ಟವಾಗುತ್ತಿದೆ x ವಿಷಯ: '(
ಪೈಥಾನ್ ಬಳಸುವ ನಮ್ಮಲ್ಲಿ ಅದ್ಭುತವಾಗಿದೆ: ಡಿ!
ಧನ್ಯವಾದಗಳು!
ಹಲೋ, ನಾನು ಈ ಸಮುದಾಯವನ್ನು ಬಹಳ ಸಮಯದಿಂದ ಅನುಸರಿಸುತ್ತಿದ್ದೇನೆ ಮತ್ತು ಇದು ನಾನು ಮೊದಲ ಬಾರಿಗೆ ಕಾಮೆಂಟ್ ಮಾಡಿದ್ದೇನೆ ಅಥವಾ ನಾನು ಮೊದಲೇ ಇದನ್ನು ಮಾಡಿದ್ದೇನೆ ಎಂದು ನನಗೆ ಖಚಿತವಿಲ್ಲ 😀 (ವೆಬ್‌ನಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಬರೆಯಲು ನನಗೆ ಹೆಚ್ಚು ಅವಕಾಶವಿಲ್ಲ). ವಿಷಯವೆಂದರೆ ಎಲಾವ್ ಮತ್ತು ಕೆ Z ಡ್‌ಕೆಜಿ ^ ಗಾರಾಗೆ ನಿರ್ವಾಹಕರಾಗಿ ಒಂದು ಸಲಹೆಯನ್ನು ಬಿಡಲು ನಾನು ಅದನ್ನು ಮಾಡುತ್ತೇನೆ ಮತ್ತು ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಣ್ಣಕ್ಕಾಗಿ ಪ್ಲಗ್‌ಇನ್ ಅನ್ನು ಸೇರಿಸುವುದು ಒಳ್ಳೆಯದು ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಇತ್ತೀಚೆಗೆ ನಾನು ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಕೋಡ್‌ನೊಂದಿಗೆ ಹೆಚ್ಚಿನ ಪೋಸ್ಟ್‌ಗಳನ್ನು ನೋಡುತ್ತಿದ್ದೇನೆ. ಕೆಲವು ಪ್ಲಗ್‌ಇನ್‌ಗಳಿವೆ ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ ಆದರೆ ನಾನು ವರ್ಡ್ಪ್ರೆಸ್ ಬಳಕೆದಾರನಲ್ಲದ ಕಾರಣ ನಾನು ಯಾವುದನ್ನೂ ಪ್ರಯತ್ನಿಸಲಿಲ್ಲ, ಆದ್ದರಿಂದ ವಿನಂತಿಯ ಕಾರ್ಯಸಾಧ್ಯತೆಯ ಬಗ್ಗೆ ಯೋಚಿಸಲು ನಾನು ನಿಮ್ಮನ್ನು ಬಿಡುತ್ತೇನೆ. ಉಳಿದ ಓದುಗರಿಗೆ ಅವರು ಆಲೋಚನೆಯ ಬಗ್ಗೆ ಏನು ಯೋಚಿಸುತ್ತಾರೆ ಎಂದು ಕೇಳಲು ನಾನು ಈ ಅವಕಾಶವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇನೆ, ಏಕೆಂದರೆ ಯಾವುದೇ ಅಲಂಕಾರವಿಲ್ಲದೆ ಕೋಡ್ ಓದಲು ಆದ್ಯತೆ ನೀಡುವ ಜನರಿದ್ದಾರೆ ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ. ಇದನ್ನು ಈಗಾಗಲೇ ಇಲ್ಲಿ ಕಾಮೆಂಟ್ ಮಾಡಿದ್ದರೆ ಮತ್ತು ಕೆಲವು ಕಾರಣಗಳಿಂದ ಅದನ್ನು ತಿರಸ್ಕರಿಸಲಾಗಿದ್ದರೆ ನಾನು ಕ್ಷಮೆಯಾಚಿಸುತ್ತೇನೆ, ಏಕೆಂದರೆ ಈ ವಿಷಯದ ಬಗ್ಗೆ ಯಾವುದೇ ಚರ್ಚೆಯನ್ನು ನೋಡಿದ ನೆನಪಿಲ್ಲ.
ಸತ್ಯವೆಂದರೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳ ಕೋಡ್ ಅನ್ನು ಹೈಲೈಟ್ ಮಾಡಲು ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಣ್ಣ ಮಾಡುವ ಆಯ್ಕೆಯನ್ನು ನಾನು ಬಯಸುತ್ತೇನೆ.
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಕಲಿಯಲು ಬಯಸುವ ಬಳಕೆದಾರರಿಗೆ ಅದು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಆದರೆ ಹೇ, ನಾನು ಫೋರಂನೊಂದಿಗೆ ಸಹ ಆರಾಮದಾಯಕವಾಗಿದ್ದೇನೆ ಮತ್ತು ನಾವು ಒಟ್ಟಿಗೆ ಚರ್ಚಿಸಬಹುದು ಮತ್ತು ಕಲಿಯಬಹುದು.
ಗ್ನು ಇಮ್ಯಾಕ್ಸ್ ಹೆಚ್ಚು ಆರಾಮದಾಯಕವಾಗಿದೆ, ಏಕೆಂದರೆ ನೀವು ಕೆಲಸ ಮಾಡಲು ಬಯಸುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷಾ ಪರೀಕ್ಷಕವನ್ನು ನೀವು ಆರಿಸಬೇಕಾಗುತ್ತದೆ (ನಿಮ್ಮ ಪ್ರೊಸೆಸರ್‌ಗೆ ಹೆಚ್ಚಿನ ತೂಕವನ್ನು ನೀವು ಬಯಸದಿದ್ದರೆ, ಗ್ನೂ ನ್ಯಾನೊ ಬಳಸಿ ಮತ್ತು ಕನಿಷ್ಠೀಯತೆಯನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿ ಆನಂದಿಸಿ).
Elio estamos hablando de Worpress . Implementado en el blog Desde Linux. No tiene las funciones para dar color a las letras de los posteos .
ಓ ನನ್ನನು ಕ್ಷಮಿಸಿ.
84 ಬೆರಳುಗಳ ಎಕ್ಸ್‌ಡಿ .., ಸಾಮಾನ್ಯ ಜನರು, ಟೆಕ್ಸ್ಟ್‌ಮೇಟ್, ಸಬ್‌ಲೈಮ್‌ಟೆಕ್ಸ್ಟ್ ಅಥವಾ ನೋಟ್‌ಪ್ಯಾಡ್ ++ ಎಕ್ಸ್‌ಡಿ ಹೊಂದಿರುವವರಿಗೆ ನಾ ಇಮ್ಯಾಕ್ಸ್ ಆರಾಮದಾಯಕವಾಗಿದೆ
ಅಸಂಭವ ವಿಷಯವೆಂದರೆ ನೀವು ಟೈಪಿಂಗ್ ಕಲಿತಿಲ್ಲ, ಇದು ಗ್ನು ಇಮ್ಯಾಕ್ಸ್ ಮತ್ತು ಅದರ ಕೀಬೋರ್ಡ್ ಶಾರ್ಟ್‌ಕಟ್‌ಗಳನ್ನು ಚೆನ್ನಾಗಿ ನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಅದರ GUI ನಿಮಗೆ ಅದರ ಮೆನುಗಳನ್ನು ಬಳಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ (ಇದನ್ನು ವಿಂಡೋಸ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು, ಆದರೆ ಇದನ್ನು ಸಾಮಾನ್ಯ ಮೋಡ್‌ನಲ್ಲಿ ಮಾಡಲು ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ ಆದರೆ ಕಮಾಂಡ್ ಪ್ರಾಂಪ್ಟ್ ಮೋಡ್‌ನೊಂದಿಗೆ win32 ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಹಿಷ್ಕರಿಸುವುದಿಲ್ಲ).
ತುಂಬಾ ತಂಪಾದ ಟ್ಯುಟೋರಿಯಲ್. ಆದರೆ ಮೂಲಕ, ಪೈಥಾನ್ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಸಂಕಲಿಸಲಾಗಿಲ್ಲ, ಇದು ಅರ್ಥೈಸಲ್ಪಟ್ಟ ಭಾಷೆಯಾಗಿದೆ.
ಇದನ್ನು ಹುಸಿ ಕೋಡ್‌ಗೆ ಸಂಕಲಿಸಬಹುದು. ಇದು ಯಂತ್ರ ಭಾಷೆಯಲ್ಲ ಆದರೆ ಇಂಟರ್ಪ್ರಿಟರ್‌ಗೆ ಏನನ್ನಾದರೂ ಪ್ರತಿನಿಧಿಸುವ ಬೈಟ್‌ಗಳು, ಆದರೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕಂಪೈಲ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಈ ಅರ್ಥದಲ್ಲಿ, ಏನನ್ನಾದರೂ ಸಂಕಲಿಸಲಾಗಿದೆ ಎಂದು ಹೇಳಲು ಸಾಧ್ಯವಿದೆ.
ಬಹುಶಃ pytgk2 ಕಲಿಯುವುದು ಉತ್ತಮ ಏಕೆಂದರೆ ವಿಂಡೋಸ್‌ಗೆ ಲಭ್ಯವಿರುವ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿ 2.24 ಆಗಿದೆ. ಸರಣಿ 3 ಅದರ ಅನುಪಸ್ಥಿತಿಯಿಂದ ಎದ್ದು ಕಾಣುತ್ತದೆ. ಮತ್ತು ಕೆಟ್ಟ ನಾಲಿಗೆಗಳು ಪ್ರತಿ ಹೊಸ ಆವೃತ್ತಿಯಲ್ಲಿ ಗ್ನೋಮ್ ಎಲ್ಲಾ ಎಪಿಸ್ ಅನ್ನು ಮುರಿಯುತ್ತದೆ ಎಂದು ಹೇಳುತ್ತದೆ.
ನಾನು ಜಿಟಿಕೆ 3.4 / 3.6 ನೊಂದಿಗೆ ಮೋಕ್‌ಅಪ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಂ ಮಾಡುತ್ತೇನೆ ಮತ್ತು ಸತ್ಯವೆಂದರೆ ಅವರು ನಿಮ್ಮ ತಾಳ್ಮೆ ಮತ್ತು ನಿಮ್ಮ ತಲೆಯನ್ನು ಮುರಿಯುತ್ತಾರೆ, ನೀವು ಕೋಡ್ ಅನ್ನು ಮತ್ತೆ ಬರೆಯಬೇಕು, ಲಿನಕ್ಸ್ ಮಿಂಟ್ ಜನರು ಜಿಟಿಕೆ ಮತ್ತು ಗ್ನೋಮ್ ಯೋಜನೆಯ ಬಗ್ಗೆ ಏಕೆ ದೂರು ನೀಡುತ್ತಾರೆ ಎಂಬುದು ಈಗ ನನಗೆ ಅರ್ಥವಾಗಿದೆ.
MINT ಯವರಿಗೆ ನಾನು GTK 2.4 ನೊಂದಿಗೆ ಒಪ್ಪುತ್ತೇನೆ ಇದು ಸಂಭವಿಸಲಿಲ್ಲ.
ಉತ್ತಮ ಟ್ಯುಟೋರಿಯಲ್ ಮತ್ತು ಉಲ್ಲೇಖಗಳು.
ಕೋಡ್ ಅನ್ನು ಹಾಕಿರುವ ಕಾರಣ, ಪೈಥಾನ್ ಇಂಡೆಂಟೇಶನ್‌ಗಳು ಕಡ್ಡಾಯವಾಗಿದೆ ಮತ್ತು ಉದಾಹರಣೆ ಕೋಡ್‌ನಲ್ಲಿ ಇದನ್ನು ಗೌರವಿಸಬೇಕು.
ಧನ್ಯವಾದಗಳು!
ಪೈಥಾನ್‌ನಲ್ಲಿನ ಕಡ್ಡಾಯ ಗುರುತುಗಳು ಯಾವುವು ಎಂಬುದನ್ನು ನೀವು ವಿವರಿಸಬಹುದೇ? ನಾನು ನಿಮಗೆ ಸತ್ಯವನ್ನು ಹೇಳುತ್ತೇನೆ, ನಾನು ಅದನ್ನು ಕೇಳಿಲ್ಲ. ನಾನು ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಪೈಜಿಟಿಕೆ 2/3 ಫೋರಮ್‌ಗಳಿಗೆ ಕೆಟ್ಟದಾಗಿ ಬಳಸುತ್ತಿದ್ದೇನೆ ಮತ್ತು ಬಹುಶಃ ನಾನು ಅದನ್ನು ಕಡೆಗಣಿಸುತ್ತೇನೆ.
ಪೈಥಾನ್‌ನಲ್ಲಿ ನೀವು ಸಿ ಯಂತಹ ಕೀಲಿಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ ಅಥವಾ ಪ್ಯಾಸ್ಕಲ್‌ನಂತೆ ಬ್ಲಾಕ್ / ಸ್ಟಾರ್ಟ್ / ಎಂಡ್ ಬ್ಲಾಕ್ಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಆದರೆ ನೀವು ಕೋಡ್‌ಗೆ ನೀಡುವ ಇಂಡೆಂಟೇಶನ್ ಮೂಲಕ ಎಲ್ಲವನ್ನೂ ಅರ್ಥೈಸಲಾಗುತ್ತದೆ. ಅಂದರೆ, ಬ್ಲಾಕ್ಗಳನ್ನು ಇಂಡೆಂಟ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ಗುರುತಿಸಲಾಗಿದೆ. ಇದು ನಾನು ವಿಶೇಷವಾಗಿ ಪ್ರೀತಿಸುವ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ. ಕೀಲಿಗಳು ಮತ್ತು ಅಂತಹ ವಿಷಯಗಳನ್ನು ಬರೆಯುವುದನ್ನು ನೀವು ತಪ್ಪಿಸುತ್ತೀರಿ.
ನಾನು ಅದನ್ನು ಇಷ್ಟಪಡುವುದಿಲ್ಲ, xd ರೇಖೆಯನ್ನು ಚೆನ್ನಾಗಿ ಪಟ್ಟಿಮಾಡಲಾಗಿದೆಯೆ ಎಂದು ನೋಡುವುದಕ್ಕಿಂತ ಎರಡು ಸಣ್ಣ ಕೀಲಿಗಳನ್ನು ಅಥವಾ ಒಂದು std :: 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 ನಿಯಮಗಳನ್ನು ಹೊಂದಿದ್ದೀರಿ: ಡಿಲಿಮಿಟರ್ಗಳೊಂದಿಗೆ ಇಂಡೆಂಟ್ ಮಾಡಿ ಮತ್ತು ಆವರಿಸಿಕೊಳ್ಳಿ. ಆದರೆ ಅದು ಅನಗತ್ಯ. ಪೈಥಾನ್‌ನಲ್ಲಿ ಅಂತಹ ಕೋಡ್ ಅನ್ನು ಇಂಟರ್ಪ್ರಿಟರ್ ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ. ಮತ್ತು ನಿಮಗೆ ಒಂದೇ ನಿಯಮವಿದೆ: ಇಂಡೆಂಟ್. ಸುಲಭ.
ಆದರೆ ಹೇ, ಪ್ರತಿಯೊಬ್ಬರೂ ತಮ್ಮ ಅಭಿರುಚಿಯೊಂದಿಗೆ.
ಎರಡೂ ಒಳ್ಳೆಯದು, ಇಂಡೆಂಟ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಇಂಡೆಂಟ್ ಮಾಡಲಾಗಿಲ್ಲ, ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ನಾನು ಪೈಥಾನ್‌ನಂತೆಯೇ ಸೆಮಿಕೋಲನ್ ಶೈಲಿ ಅಥವಾ ಮಾಣಿಕ್ಯವನ್ನು ಬಯಸುತ್ತೇನೆ ಆದರೆ ಇಂಡೆಂಟೇಶನ್ ಅಗತ್ಯವಿಲ್ಲ.
ಇದನ್ನು ಚೆನ್ನಾಗಿ ಅರ್ಥೈಸಲಾಗಿದೆ: ಪಿ:
echo '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 {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 / g;'
ಶುಭಾಶಯಗಳು
ನನ್ನ ಪ್ರಕಾರ ಕಾರ್ಲೋಸ್ ಎಂದರೆ ಕೋಡ್ ಹೊರಬರುವಲ್ಲಿ ಯಾವುದೇ ಇಂಡೆಂಟ್‌ಗಳಿಲ್ಲ. ನಕಲು ಮತ್ತು ಅಂಟಿಸುವಿಕೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಪೋಸ್ಟ್ ರಚಿಸುವಾಗ ಟ್ಯಾಗ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ನನಗೆ ಗೊತ್ತಿಲ್ಲ
ಭಾಷಾ ಕೋಡ್ ನಮೂದಿಸಲು. ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಅವರು ಅದನ್ನು ಹಾಕಿದರೆ ಒಳ್ಳೆಯದು.ಸಮಸ್ಯೆ ಏನೆಂದು ನಾನು ಈಗಾಗಲೇ ನೋಡಿದ್ದೇನೆ: ಕೋಡ್ ಟ್ಯಾಗ್ ಎಲ್ಲಾ ಸ್ಥಳಗಳು ಮತ್ತು ಟ್ಯಾಬ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ (ಅದು ಹಾಗೆ ಮಾಡಬಾರದು !!!) ಆದರೆ ನೀವು ಅದರ ಮೇಲೆ ಒಂದು nbsp ಹಾಕಿದರೆ ಕೋಡ್ ಚೆನ್ನಾಗಿ ಕಾಣುತ್ತದೆ. ಹೆಕ್ಸ್ನಲ್ಲಿ ಎ 0 (ಡಿಸೆಂಬರ್ನಲ್ಲಿ 160) ಇದು ಫಾಂಟ್ ಅನ್ನು ಅವಲಂಬಿಸಿರಬಹುದು ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ (ನನಗೆ ಗೊತ್ತಿಲ್ಲ). ಇದನ್ನು ಬಳಸಿದರೆ ಅದು ಈ ರೀತಿ ಹೊರಬರುತ್ತದೆ:
def fib(n):
a, b = 0, 1
while a < n:
print(a)
a, b = b, a+b
ನನ್ನ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಅದು ಉತ್ತಮವಾಗಿ ಕಾಣುತ್ತದೆ, ಆದರೆ ನಾನು ಉತ್ತರಗಳನ್ನು ಪೋಸ್ಟ್ ಮಾಡುವಾಗ ನನಗೆ ಪೂರ್ವವೀಕ್ಷಣೆ ಇಲ್ಲ (ಮತ್ತು ಅದು ಇರಬೇಕು !!!) ಅದು ಹೊರಬರದಿದ್ದರೆ, ಅದು ನನ್ನ ತಪ್ಪು ಅಲ್ಲ
ಸೆಬಾಸ್ಟಿಯನ್ ಪಾಲ್ಸ್ಟರ್ಲ್ ತನ್ನ ಪಿಜಿಟಿಕೆ 3 ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನೀಡುವ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡಿ, ಸೆಬಾಸ್ಟಿಯನ್ ಲೇಬಲ್ಗಳನ್ನು ಇಡುವುದಿಲ್ಲ.
ಉದಾಹರಣೆ :
http://python-gtk-3-tutorial.readthedocs.org/en/latest/entry.html#example
ನೀವು ಸೆಬಾಸ್ಟಿಯನ್ ಅವರ ಎಲ್ಲಾ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ನೋಡಬಹುದು.
ನೀನು ಹೇಳುವುದು, ನನಗೆ ಗೊತ್ತಾಗುತ್ತಿಲ್ಲ. ನಾನು ಹೇಳುತ್ತಿರುವುದು ಇಲ್ಲಿ, ಪೋಸ್ಟ್‌ಗಳಲ್ಲಿ, HTML ಟ್ಯಾಗ್ «ಕೋಡ್ use ಅನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಆದ್ದರಿಂದ ನೀವು ಕೋಡ್ ಆಗಿ ಇರಿಸಿದ ಮತ್ತು ಅದು ಚೆನ್ನಾಗಿ ಇಂಡೆಂಟ್ ಆಗಿ ಹೊರಬರುತ್ತದೆ. ನೀವು ಉಲ್ಲೇಖಿಸುವ ಪುಟದಲ್ಲಿ, ನೀವು ಪುಟದ ಮೂಲಗಳನ್ನು ನೋಡಿದರೆ, ಅದು CODE ಅನ್ನು ಬಳಸುವುದಿಲ್ಲ ಆದರೆ ಇತರ HTML ಡಿಲಿಮಿಟರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ ಎಂದು ನೀವು ನೋಡುತ್ತೀರಿ.
ಇದು ನೀವು ಹಾಕಿದ ಕೋಡ್‌ಗೆ ವಿರುದ್ಧವಲ್ಲ ಆದರೆ ಈ ಸೈಟ್‌ನ ಪೋಸ್ಟ್ ಮಾಡುವ ವ್ಯವಸ್ಥೆಯಲ್ಲಿನ ನ್ಯೂನತೆಯನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ. ಇದು, ಬಹುಶಃ, ನಿರ್ವಾಹಕರು ಸರಿಪಡಿಸಬಹುದು.
ನಾನು ಟ್ಯಾಗ್‌ಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವಾಗ ನಾನು ಸ್ಪಷ್ಟವಾಗಿ HTML ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇನೆ, ಪೈಥಾನ್ ಬಗ್ಗೆ ಅಲ್ಲ. ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಪೈಥಾನ್‌ನಲ್ಲಿ ಇಂಡೆಂಟೇಶನ್ ಇಲ್ಲದೆ ಕೋಡ್ ಅನ್ನು ಹಾಕಿದರೆ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಹೊಸಬರು ಬಂದು ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿ ಕಂಡುಬರುವಂತೆ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ ಅದನ್ನು ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಅವನು ವಿಫಲಗೊಳ್ಳುತ್ತಾನೆ. ನೀವು ಹೊಸಬರಾಗಿರುವುದರಿಂದ ನೀವು ನಿರಾಶೆಗೊಳ್ಳಬಹುದು. ಮತ್ತೆ, ತಪ್ಪು ನಿಮ್ಮದಲ್ಲ; ಮತ್ತು ನನ್ನ ತಕ್ಷಣದ ಹಿಂದಿನ ಉತ್ತರದಲ್ಲಿ ನಾನು ಮಾಡಿದ್ದು ಬಳಕೆದಾರ-ಯಾರು-ಪೋಸ್ಟ್ಗಳ ಮಟ್ಟದಿಂದ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ನೀಡಿದೆ.
ನೀವು ಹೇಳಿದ್ದು ನಿಜ, ಕೋಡ್ ನಕಲಿಸುವ ಬದಲು ನಾನು ಫೋಟೋಗಳನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡಬೇಕು.
PyGTK 3 ನಲ್ಲಿ ಹೇಳಿಕೆಗಳನ್ನು ಹೇಗೆ ಸರಿಯಾಗಿ ಆದೇಶಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ತೋರಿಸಲು.
ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು ನಾನು ಪೈಡೆವ್ ಪ್ಲಗಿನ್ ಅಥವಾ ಪೈಚಾರ್ ಮೀ ನೊಂದಿಗೆ ಎಕ್ಲಿಪ್ಸ್ ಅನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ
ಮೇಲೆ ಕಾಮೆಂಟ್ ಮಾಡಿದಂತೆ, ಇಂಡೆಂಟೇಶನ್ ಸಮಸ್ಯೆಯಿಂದಾಗಿ ನಾನು ಪೈಥಾನ್ ಅನ್ನು ಇಷ್ಟಪಡುವುದಿಲ್ಲ. ನಾವು ನೋಡಿದಂತೆ, ಕಾಪಿ ಮತ್ತು ಪೇಸ್ಟ್ ಮಾಡುವುದರಿಂದ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ, ಅದು ಸಿ, ಜಾವಾ, ಪಿಎಚ್ಪಿ ಮುಂತಾದ ಇತರ ಭಾಷೆಗಳೊಂದಿಗೆ ಆಗುವುದಿಲ್ಲ.
ಓದಬಲ್ಲ ವಿಷಯ, ನಾವು ಕೋಡ್ ಬ್ಯೂಟಿಫೈಯರ್ ಅನ್ನು ಅನ್ವಯಿಸುತ್ತೇವೆ (ಹಾಗೆ http://indentcode.net/ ) ಮತ್ತು ಸಿದ್ಧ,
ಕೊಳಕು ನಿವಾರಿಸಲಾಗಿದೆ, ಆದರೆ ಯಾವುದೇ ಇಂಡೆಂಟೇಶನ್ ಇಲ್ಲದಿದ್ದರೆ ಮತ್ತು ತರ್ಕವನ್ನು ಬದಲಾಯಿಸಿದರೆ, ನಾವು ಧ್ವನಿಸುತ್ತೇವೆ ..
ನಾನು ಪಿಜಿಟಿಕೆಗೆ ಹೊಸಬನು, ಈ ಭಾಷೆಯಲ್ಲಿ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಸಾಧ್ಯವೇ?
ಟ್ಯುಟೋರಿಯಲ್ ಗೆ ಧನ್ಯವಾದಗಳು.
ಗ್ರೀಟಿಂಗ್ಸ್.