ತಮ್ಮ ಮೊದಲ ಪೈಥಾನ್ ಟ್ಯುಟೋರಿಯಲ್ ತೆರೆಯುವ ಹೆಚ್ಚಿನ ಜನರು ನೇರವಾಗಿ variables, loops ಮತ್ತು ಯಾವುದಾದರೂ ಒಂದು ವಸ್ತುವನ್ನು ನಿರ್ಮಿಸಲು ಬಯಸುತ್ತಾರೆ. ಆ ಆತುರವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದಾದದ್ದು. ಆದರೆ ಪೈಥಾನ್ ನಿಜವಾಗಿಯೂ ಏನಿದು ಮತ್ತು ಅದು ಅದರ ಕೆಳಗಿರುವ ಯಂತ್ರದೊಂದಿಗೆ ಹೇಗೆ ಸಂಬಂಧ ಹೊಂದಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನೀವು ಸ್ವಲ್ಪ ಸಮಯ ನೀಡಿದರೆ, ಭವಿಷ್ಯದಲ್ಲಿ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಯಾವುದೇ ಗೊಂದಲವಿಲ್ಲದೆ ಡಿಬಗ್ ಮಾಡಬಹುದು. ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳೆಲ್ಲವೂ ಒಂದೇ ಆಗಿರುವುದಿಲ್ಲ. ಅವು ವಿಭಿನ್ನ ಮಟ್ಟದ ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ (abstraction) ಹೊಂದಿವೆ, ಅನುಕೂಲಕ್ಕಾಗಿ ನಿಯಂತ್ರಣವನ್ನು (control) ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ಬಿಟ್ಟುಕೊಡುತ್ತವೆ ಮತ್ತು ಪ್ರೊಸೆಸರ್ ತಲುಪಲು ವಿಭಿನ್ನ ಮಾರ್ಗಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಪೈಥಾನ್ ಆ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಾನದಲ್ಲಿದೆ. ಆ ಸ್ಥಾನವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಪ್ರೋಗ್ರಾಂ ಮಾಡುವುದನ್ನು ಕಲಿಯುವ ಮೊದಲ ನೈಜ ಹೆಜ್ಜೆಯಾಗಿದೆ.
ಭಾಷೆಯ ಶ್ರೇಣಿ ವ್ಯವಸ್ಥೆ: ಪೈಥಾನ್ ಎಲ್ಲಿ ನೆಲೆಸಿದೆ
ಹಾರ್ಡ್ವೇರ್ಗೆ ಇರುವ ಹತ್ತಿರದಿಕೆಯ ಆಧಾರದ ಮೇಲೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ವಿಶಾಲವಾಗಿ ಮೂರು ವರ್ಗಗಳಾಗಿವೆ.
High-level languages ಸಿಲಿಕಾನ್ನಿಂದ ಅತ್ಯಂತ ದೂರದಲ್ಲಿವೆ. ಪೈಥಾನ್, Java ಮತ್ತು JavaScript ಜೊತೆಗೆ ಇದು ಇಲ್ಲಿದೆ. ಈ ಭಾಷೆಗಳು ಮಾನವ ಭಾಷೆಯನ್ನು ಹೋಲುವ ಸಿಂಟ್ಯಾಕ್ಸ್ (syntax) ಅನ್ನು ಬಳಸುತ್ತವೆ. ನೀವು ಮೆಮೊರಿ ಅಡ್ರೆಸ್ಗಳು ಮತ್ತು ಬೈನರಿ ಸೂಚನೆಗಳೊಂದಿಗೆ ಹೋರಾಡುವ ಬದಲು user_count = 5 ಅಥವಾ print("Hello") ಎಂದು ಬರೆಯುತ್ತೀರಿ. ಇವು CPU, ಮೆಮೊರಿ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಮತ್ತು ಚಿಪ್ಸೆಟ್ ವ್ಯತ್ಯಾಸಗಳ ವಿವರಗಳನ್ನು ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ (abstract) ಮಾಡುವುದರಿಂದ, ಅದೇ ಹೈ-ಲೆವೆಲ್ ಕೋಡ್ ಅನ್ನು ಯಾವುದೇ ಬದಲಾವಣೆ ಇಲ್ಲದೆ ಅಥವಾ ಅಲ್ಪ ಬದಲಾವಣೆಯೊಂದಿಗೆ Mac, Windows PC ಅಥವಾ Linux ಸರ್ವರ್ನಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು.
ಈ ಪೋರ್ಟಬಿಲಿಟಿ (portability) ಒಂದು ಬೆಲೆಯನ್ನು ತೆರಬೇಕಾಗುತ್ತದೆ. ಹೈ-ಲೆವೆಲ್ ಭಾಷೆಗಳಿಗೆ ಅನುವಾದಕನ ಅಗತ್ಯವಿದೆ. ಅವು ಪ್ರೊಸೆಸರ್ ಮೇಲೆ ನೇರವಾಗಿ ಚಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ನಿಮ್ಮ ಓದಬಲ್ಲ ಕೋಡ್ ಮತ್ತು ಯಂತ್ರದ ಎಲೆಕ್ಟ್ರಿಕಲ್ ಸಿಗ್ನಲ್ಗಳ ನಡುವಿನ ಅಂತರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ನಿಮಗೆ ಕಾಂಪೈಲರ್ (compiler) ಅಥವಾ ಇಂಟರ್ಪ್ರೆಟರ್ (interpreter) ಬೇಕಾಗುತ್ತದೆ. ಇದರ ಪ್ರಯೋಜನವೆಂದರೆ ಅಭಿವೃದ್ಧಿಯ ವೇಗ (speed of development). ನೀವು ಮೊದಲ ದಿನದಿಂದಲೇ ಉಪಯುಕ್ತ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಬರೆಯಲು ನೇರ ಹಾರ್ಡ್ವೇರ್ ನಿಯಂತ್ರಣವನ್ನು ತ್ಯಾಗ ಮಾಡುತ್ತೀರಿ.
Low-level languages ವಿರುದ್ಧ ತುದಿಯಲ್ಲಿವೆ. ಇವು ಮೂಲತಃ ಮಷಿನ್ ಕೋಡ್ (machine code) — ಅಂದರೆ ಪ್ರೊಸೆಸರ್ ನೇರವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಒಂದು ಮತ್ತು ಸೊನ್ನೆಗಳ ಕಚ್ಚಾ ಸರಣಿಗಳು. ಮಷಿನ್ ಕೋಡ್ ಬರೆಯುವುದು ಎಂದರೆ ಚಿಪ್ನಂತೆಯೇ ಯೋಚಿಸುವುದು ಎಂದರ್ಥ. ಯಾವ ಮೆಮೊರಿ ಅಡ್ರೆಸ್ ಅನ್ನು ಬಳಸಬೇಕು ಮತ್ತು ಯಾವ CPU ರಿಜಿಸ್ಟರ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರಬೇಕು ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸುತ್ತೀರಿ. ಹಾರ್ಡ್ವೇರ್ ತಕ್ಷಣವೇ ಮತ್ತು ಯಾವುದೇ ಅನುವಾದದ ಹೊರೆಯಿಲ್ಲದೆ (translation overhead) ಆಜ್ಞೆಯನ್ನು ಪಾಲಿಸುತ್ತದೆ.
ಇದರ ಬೆಲೆ ಅತಿ ಹೆಚ್ಚಿನ ಸಂಕೀರ್ಣತೆ. ಒಂದು ಸರಳ ಸಂಕಲನಕ್ಕೆ (addition) ಹಲವಾರು ರಿಜಿಸ್ಟರ್ಗಳ ಮ್ಯಾನುವಲ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಅಗತ್ಯವಿರಬಹುದು. ಒಂದು ತಪ್ಪಾದ ಬಿಟ್ ಇಡೀ ಸಿಸ್ಟಮ್ ಅನ್ನು ಯಾವುದೇ ಉಪಯುಕ್ತ ಎರರ್ ಮೆಸೇಜ್ ಇಲ್ಲದೆ ಕ್ರ್ಯಾಶ್ ಮಾಡಬಹುದು. ಶುದ್ಧ ಮಷಿನ್ ಕೋಡ್ ಅನ್ನು ಈಗ ಕೈಯಿಂದ ಬರೆಯುವುದು ಬಹಳ ಅಪರೂಪ, ಆದರೆ ಪ್ರತಿಯೊಂದು ಪ್ರೋಗ್ರಾಂ ಕೂಡ ಅಂತಿಮವಾಗಿ ಮಾತನಾಡಲೇಬೇಕಾದ ಭಾಷೆಯಾಗಿ ಇದು ಉಳಿದಿದೆ.
Assembly languages ಸಂಕುಚಿತ ಮಧ್ಯಮ ಹಂತದಲ್ಲಿವೆ. ಇವು ಬೈನರಿ ಸೂಚನೆಗಳ ಬದಲಿಗೆ ಮನೆಮೊನಿಕ್ಸ್ (mnemonics) ಎಂದು ಕರೆಯಲ್ಪಡುವ ಸಂಕ್ಷಿಪ್ತ ಮಾನವ-ಓದಬಲ್ಲ ಸಂಕೇತಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಒಂದು ಮತ್ತು ಸೊನ್ನೆಗಳ ಸರಣಿಯ ಬದಲಿಗೆ, ನೀವು ಡೇಟಾವನ್ನು ಚಲಾಯಿಸಲು MOV ಅಥವಾ ಸಂಕಲನ ಮಾಡಲು ADD ಎಂದು ಬರೆಯಬಹುದು. ಈ ಸಂಕೇತಗಳನ್ನು ಕಚ್ಚಾ ಬೈನರಿಗಿಂತ ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಸುಲಭ, ಆದರೆ ಅವು ನಿರ್ದಿಷ್ಟ ಪ್ರೊಸೆಸರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ಗೆ ಬದ್ಧವಾಗಿರುತ್ತವೆ. Intel x86 ಚಿಪ್ಗಾಗಿ ಬರೆದ ಅಸೆಂಬ್ಲಿ ಪ್ರೋಗ್ರಾಂ ARM ಪ್ರೊಸೆಸರ್ನಲ್ಲಿ ಚಲಿಸುವುದಿಲ್ಲ.
ಅಸೆಂಬ್ಲರ್ (assembler) ಈ ಮನೆಮೊನಿಕ್ಸ್ ಅನ್ನು ಮಷಿನ್ ಕೋಡ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಅಸೆಂಬ್ಲಿ ಪ್ರೋಗ್ರಾಮರ್ಗಳಿಗೆ ಪೈಥಾನ್ ನೀಡಬಹುದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ, ಆದರೆ ಇದು ಪ್ರೊಸೆಸರ್ನ ಆಂತರಿಕ ಕಾರ್ಯವೈಖರಿಯ ಬಗ್ಗೆ ಆಳವಾದ ಜ್ಞಾನವನ್ನು ಬಯಸುತ್ತದೆ. ಇದು ಬೈನರಿಗಿಂತ ಮಾನವನ ಆಲೋಚನೆಗೆ ಹತ್ತಿರವಾಗಿದೆ, ಆದರೂ ಪ್ರೊಸೆಸರ್ನ ಮೂಲ ಭಾಷೆಯಲ್ಲೇ ಮಾತನಾಡುತ್ತದೆ.
ಕೋಡ್ ಹೇಗೆ ಕ್ರಿಯೆಯಾಗುತ್ತದೆ
ಪ್ರತಿಯೊಂದು ಪ್ರೋಗ್ರಾಂ ಕೂಡ ಅಂತಿಮವಾಗಿ ಮಷಿನ್ ಸೂಚನೆಗಳಾಗಿಯೇ ಬದಲಾಗಬೇಕು. ಸೋರ್ಸ್ ಕೋಡ್ನಿಂದ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್ವರೆಗಿನ ಹಾದಿಯು ಎರಡು ತಂತ್ರಗಳಲ್ಲಿ ಒಂದನ್ನು ಅನುಸರಿಸುತ್ತದೆ.
ಒಂದು compiler ನಿಮ್ಮ ಇಡೀ ಕೋಡ್ಬೇಸ್ ಅನ್ನು ಒಂದೇ ಬಾರಿಗೆ ಅನುವಾದಿಸುತ್ತದೆ. ನೀವು ನೂರು ಸಾಲುಗಳಿರುವ ಫೈಲ್ ಅನ್ನು ನೀಡಿದರೆ, ಅದು ಏನನ್ನೂ ಚಲಾಯಿಸುವ ಮೊದಲು ಎಲ್ಲಾ ನೂರು ಸಾಲುಗಳನ್ನು ಓದಿ ವಿಶ್ಲೇಷಿಸುತ್ತದೆ. ಇದು ಇಡೀ ಪ್ರೋಗ್ರಾಂಾದ್ಯಂತ ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷಗಳಿಗಾಗಿ ಹುಡುಕುತ್ತದೆ. ಐವತ್ತನೇ ಸಾಲಿನಲ್ಲಿ ಟೈಪೋ (typo) ಕಂಡುಬಂದಲ್ಲಿ? ಕಾಂಪೈಲರ್ ನಿಲ್ಲುತ್ತದೆ, ಸಮಸ್ಯೆಯನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ನೀವು ಅದನ್ನು ಸರಿಪಡಿಸುವವರೆಗೆ ಚಾಲನೆಯಾಗುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ತಯಾರಿಸಲು ನಿರಾಕರಿಸುತ್ತದೆ.
C ಮತ್ತು C++ ನಂತಹ ಭಾಷೆಗಳು ಈ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತವೆ. ಇದರ ಫಲಿತಾಂಶವು ಸಾಮಾನ್ಯವಾಗಿ ಕಚ್ಚಾ ವೇಗಕ್ಕಾಗಿ (raw speed) ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲಾದ ಸ್ಟ್ಯಾಂಡ್ಅಲೋನ್ ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ (executable) ಫೈಲ್ ಆಗಿರುತ್ತದೆ. ಕಾಂಪೈಲರ್ ಮೊದಲೇ ಇಡೀ ಕೋಡ್ಬೇಸ್ ಅನ್ನು ಸೂಕ್ಷ್ಮವಾಗಿ ಪರಿಶೀಲಿಸುವುದರಿಂದ, ಪ್ರೋಗ್ರಾಂ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲೇ ಇದು ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುತ್ತದೆ. ಇದರ ವಹಿವಾಟು (trade-off) ಸ್ವಲ್ಪ ವಿಳಂಬವಾಗಿದೆ. ಎಡಿಟ್-ಕಾಂಪೈಲ್-ರನ್ (edit-compile-run) ಚಕ್ರಕ್ಕೆ ಸಮಯ ಬೇಕಾಗುತ್ತದೆ. ಒಂದು ಸಾಲನ್ನು ಬದಲಾಯಿಸಿದರೆ, ಇಡೀ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಮರುನಿರ್ಮಿಸಲು (rebuild) ನೀವು ಕಾಯಬೇಕಾಗಬಹುದು.
ಒಂದು interpreter ಮೂಲಭೂತವಾಗಿ ವಿಭಿನ್ನವಾದ ವಿಧಾನವನ್ನು ಅನುಸರಿಸುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸಾಲು ಸಾಲಾಗಿ ಓದುತ್ತದೆ, ಪ್ರತಿ ಹೇಳಿಕೆಯನ್ನು (statement) ಅನುವಾದಿಸುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಇದು ಇಡೀ ಫೈಲ್ ಪರಿಶೀಲನೆಗೆ ಮುಗಿಯುವವರೆಗೆ ಕಾಯುವುದಿಲ್ಲ. ಪೈಥಾನ್ REPL ನಲ್ಲಿ ಒಂದು ಕಮಾಂಡ್ ಟೈಪ್ ಮಾಡಿ, Enter ಒತ್ತಿ, ಇಂಟರ್ಪ್ರೆಟರ್ ಆ ಒಂದೇ ಸಾಲನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡುತ್ತದೆ, ಅದನ್ನು ಸೂಚನೆಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ಅವುಗಳನ್ನು ಚಲಾಯಿಸುತ್ತದೆ.
ಇದು ಡಿಬಗ್ಗಿಂಗ್ನ ಸ್ವರೂಪವನ್ನೇ ಬದಲಾಯಿಸುತ್ತದೆ. ಇಂಟರ್ಪ್ರಿಟರ್ ಬಳಕೆಯಲ್ಲಿ, ತಪ್ಪುಗಳು ತಲುಪುವ ಸಾಲು ತಲುಪಿದಾಗ ಮಾತ್ರ ಎದುರಾಗುತ್ತವೆ, ಅದಕ್ಕಿಂತ ಮುಂಚೆಯೇ ಅಲ್ಲ. ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಎಂಬತ್ತ ಸಾಲುಗಳವರೆಗೆ ಪರಿಪೂರ್ಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು ಮತ್ತು ಎಂಬತ್ತೊಂದನೇ ಸಾಲಿನಲ್ಲಿ ಕ್ರ್ಯಾಶ್ ಆಗಬಹುದು. ಆ ತಕ್ಷಣದ ಪ್ರತಿಕ್ರಿಯೆಯು ಇಂಟರ್ಪ್ರಿಟರ್ಗಳನ್ನು ಕಲಿಯಲು ಹೆಚ್ಚು ಸುಲಭವಾಗಿಸುತ್ತದೆ. ನೀವು ಪ್ರಯೋಗ ಮಾಡಬಹುದು, ಫಲಿತಾಂಶಗಳನ್ನು ನೋಡಬಹುದು ಮತ್ತು ನೈಜ ಸಮಯದಲ್ಲಿ (real time) ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿಕೊಳ್ಳಬಹುದು. ಪೈಥಾನ್ನ ಪ್ರಮಾಣಿತ ಅನುಷ್ಠಾನವಾದ CPython, ವಾಸ್ತವವಾಗಿ ಹೈಬ್ರಿಡ್ ಮಾಡೆಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ: ಇದು ನಿಮ್ಮ ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ಬೈಟ್ಕೋಡ್ ಆಗಿ ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ, ನಂತರ ವರ್ಚುವಲ್ ಮೆಷಿನ್ ಮೂಲಕ ಆ ಬೈಟ್ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಒಳಗಿನ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಅನುವಾದದ ಹಂತವಿದ್ದರೂ ಸಹ, ಇದು ಸಾಲು-ಸಾಲಾಗಿ ಸಂವಾದಾತ್ಮಕವಾಗಿ (interactive) ಕಾರ್ಯನಿರ್ವಹಿಸುವಂತೆ ಭಾಸವಾಗುತ್ತದೆ.
ಪೈಥಾನ್ ಅನ್ನು ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆ ಎಂದು ಏಕೆ ಕರೆಯಲಾಗುತ್ತದೆ
ಪೈಥಾನ್ ಅನ್ನು ಹೆಚ್ಚಾಗಿ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆ ಎಂದು ವಿವರಿಸಲಾಗುತ್ತದೆ. ಈ ಹೆಸರು ಅದರ ಮೂಲ ಮತ್ತು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ. ನೀವು ಒಂದು ಸಣ್ಣ ಫೈಲ್ ಅನ್ನು — ಅಂದರೆ ಒಂದು ಸ್ಕ್ರಿಪ್ಟ್ — ಬರೆಯುತ್ತೀರಿ, ಅದು ಒಂದು ಕೆಲಸವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತದೆ, ಪಠ್ಯವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಅಥವಾ ಪ್ರತ್ಯೇಕ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡಿಸುತ್ತದೆ, ಮತ್ತು ನೀವು ಅದನ್ನು ನೇರವಾಗಿ ಬಳಸಬಹುದು. ಇಂಟರ್ಪ್ರಿಟರ್ ತಕ್ಷಣವೇ (on the fly) ಅನುವಾದವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ನಿರ್ವಹಿಸಲು ಪ್ರತ್ಯೇಕ ಕಂಪೈಲೇಶನ್ ಹಂತವಿಲ್ಲ, ಮತ್ತು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಯಾವುದೇ ಬಿಲ್ಡ್ ಆರ್ಟಿಫ್ಯಾಕ್ಟ್ಗಳಿಲ್ಲ.
ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಗಳು ಮತ್ತು ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವು ಈಗ ಗಣನೀಯವಾಗಿ ಅಸ್ಪಷ್ಟವಾಗಿದೆ. ಪೈಥಾನ್ ಈಗ ಬೃಹತ್ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಗಳು, ಡೇಟಾ ಸೈನ್ಸ್ ಪೈಪ್ಲೈನ್ಗಳು ಮತ್ತು ಮಷೀನ್ ಲರ್ನಿಂಗ್ ಸಿಸ್ಟಮ್ಗಳಿಗೆ ಶಕ್ತಿಯನ್ನು ನೀಡುತ್ತಿದೆ. ಆದರೂ, ಮೂಲ ಪರಿಕಲ್ಪನೆಯು ಹಾಗೆಯೇ ಉಳಿದಿದೆ. ನೀವು ಬಿಲ್ಡ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ನಿರ್ವಹಿಸುವ ಬದಲು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವತ್ತ ಗಮನಹರಿಸುತ್ತೀರಿ. ನೀವು ಸೂಚನೆ ನೀಡಿದ ತಕ್ಷಣ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇಂಟರ್ಪ್ರಿಟರ್ ಸಿದ್ಧವಾಗಿರುತ್ತದೆ.
ದೀರ್ಘಕಾಲ ಬಾಳಿಕೆ ಬರುವ ಅಡಿಪಾಯವನ್ನು ನಿರ್ಮಿಸುವುದು
ಈ ವ್ಯತ್ಯಾಸಗಳು ಕೇವಲ ಶೈಕ್ಷಣಿಕ ವಿಷಯಗಳಲ್ಲ. ನೀವು ಪೈಥಾನ್ ಬರೆಯುವ ಮೊದಲ ವಾರದಲ್ಲಿ ಎದುರಿಸುವ ವರ್ತನೆಯನ್ನು ಇವು ವಿವರಿಸುತ್ತವೆ. ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ಪೈಥಾನ್ SyntaxError ಅನ್ನು ತೋರಿಸಿದಾಗ, ಇಂಟರ್ಪ್ರಿಟರ್ ತಾನು ಅನುವಾದಿಸಲು ಸಾಧ್ಯವಾಗದ ಸಾಲನ್ನು ತಲುಪಿದೆ ಎಂಬುದು ಈಗ ನಿಮಗೆ ಅರ್ಥವಾಗುತ್ತದೆ. ಕೆಲವು ಕಾರ್ಯಗಳಿಗಾಗಿ ಪೈಥಾನ್ C ಗಿಂತ ನಿಧಾನವಾಗಿದೆ ಎಂದು ನೀವು ಓದಿದಾಗ, ಇಂಟರ್ಪ್ರಿಟೇಶನ್ ಮತ್ತು ಹೈ-ಲೆವೆಲ್ ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ನ (high-level abstraction) ಹೊರೆಯ ಬಗ್ಗೆ ನಿಮಗೆ ತಿಳಿಯುತ್ತದೆ. ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ಗಳ ಜೊತೆಗೆ .pyc ಫೈಲ್ಗಳು ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ನೀವು ಗಮನಿಸಿದಾಗ, ಪೈಥಾನ್ ಬೈಟ್ಕೋಡ್ ಅನ್ನು ಕ್ಯಾಶ್ (cache) ಮಾಡುತ್ತಿದೆ ಎಂದು ನೀವು ಗುರುತಿಸುತ್ತೀರಿ, ಇದರಿಂದ ಪ್ರತಿ ಬಾರಿ ರನ್ ಮಾಡುವಾಗ ಪಠ್ಯ ಫೈಲ್ ಅನ್ನು ಮತ್ತೆ ಮತ್ತೆ ಅನುವಾದಿಸುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.
ಭಾಷಾ ಶ್ರೇಣಿಯಲ್ಲಿ ಪೈಥಾನ್ ಎಲ್ಲಿದೆ ಎಂದು ತಿಳಿಯುವುದು ನಂತರ ಸರಿಯಾದ ಸಾಧನವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಪ್ರತಿ CPU ಸೈಕಲ್ ಮುಖ್ಯವಾಗುವಂತಹ ಸಾಧನದ ಡ್ರೈವರ್ (device driver) ಬರೆಯಬೇಕೆ? ಆಗ ನೀವು ಬಹುಶಃ C ಅಥವಾ ಅಸೆಂಬ್ಲಿ (assembly) ಅನ್ನು ಬಳಸುತ್ತೀರಿ. ಒಂದು ಮಧ್ಯಾಹ್ನದಲ್ಲಿ CSV ಫೈಲ್ ಅನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಬೇಕೆ ಅಥವಾ ವೆಬ್ API ಅನ್ನು ನಿರ್ಮಿಸಬೇಕೆ? ಪೈಥಾನ್ನ ಇಂಟರ್ಪ್ರಿಟರ್ ಮತ್ತು ಸುಲಭವಾಗಿ ಓದಬಹುದಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ನಿಖರವಾಗಿ ಇದಕ್ಕಾಗಿಯೇ ರೂಪಿಸಲಾಗಿದೆ.
ನಿಜವಾದ ಸಾರಾಂಶ
ಪೈಥಾನ್ನ ಶಕ್ತಿಯು ಅದರ ಸ್ಥಾನದಿಂದ ಬರುತ್ತದೆ. ಇದು ಹಾರ್ಡ್ವೇರ್ನಿಂದ ಬಹಳ ಎತ್ತರದಲ್ಲಿದೆ, ಯಂತ್ರದ ವೇಗಕ್ಕಿಂತ ಪ್ರೋಗ್ರಾಮರ್ನ ವೇಗಕ್ಕೆ ಪ್ರಾಮುಖ್ಯತೆ ನೀಡುವ ಇಂಟರ್ಪ್ರಿಟರ್ ಮೂಲಕ ಅನುವಾದಿಸಲ್ಪಡುತ್ತದೆ. ಈ ಹಿನ್ನೆಲೆ ತಿಳಿಯದೆಯೇ ನೀವು ಸಿಂಟ್ಯಾಕ್ಸ್ ಕಲಿಯಬಹುದು, ಆದರೆ ಒಳಗಿನ ಕಾರ್ಯವಿಧಾನವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವವರೆಗೆ ನೀವು ಚಾಣಾಕ್ಷತನದಿಂದ ಡಿಬಗ್ ಮಾಡಲು ಅಥವಾ ಅಂತಃಪ್ರಜ್ಞೆಯಿಂದ (intuitively) ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಈ ಮೂಲಭೂತ ಅಂಶಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ. ನೀವು ನಿಮ್ಮ ಮೊದಲ ನೈಜ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯುವಾಗ, ನೀವು ಕೇವಲ ಕಮಾಂಡ್ಗಳನ್ನು ಟೈಪ್ ಮಾಡುವುದಿಲ್ಲ; ಅವು ಯಂತ್ರವನ್ನು ಹೇಗೆ ತಲುಪುತ್ತವೆ ಎಂಬುದು ನಿಮಗೆ ನಿಖರವಾಗಿ ತಿಳಿದಿರುತ್ತದೆ.