ಪೈಥಾನ್‌ನಲ್ಲಿ ಲೂಪ್ ಮಾಡುವಾಗ. ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಬಳಕೆಯ ಉದಾಹರಣೆಗಳು

ಕುಣಿಕೆಗಳು ಯಾವುದೇ ಭಾಷೆಯ ಮುಖ್ಯ ಸಾಧನಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ ಎರಡು ಮೂಲಭೂತ ಲೂಪ್‌ಗಳಿವೆ, ಅವುಗಳಲ್ಲಿ ಒಂದು ಸಮಯದಲ್ಲಿ. ಅದನ್ನು ಪರಿಗಣಿಸಿ, ಮತ್ತು ಚಿತ್ರದ ಉತ್ತಮ ತಿಳುವಳಿಕೆಗಾಗಿ, ಇನ್ನೊಂದು. ವಾಸ್ತವವಾಗಿ, ಇದೇ ರೀತಿಯ ಯಾವುದನ್ನಾದರೂ ಹೋಲಿಸಿದರೆ, ಯಾವುದೇ ವಸ್ತುವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ತುಂಬಾ ಸುಲಭ, ಅಲ್ಲವೇ?

ಚಕ್ರದ ಪರಿಕಲ್ಪನೆ

ಒಂದು ನಿರ್ದಿಷ್ಟ ಕ್ರಿಯೆಯನ್ನು ಹಲವಾರು ಬಾರಿ ನಿರ್ವಹಿಸಬೇಕಾದಾಗ ಲೂಪ್ ಅಗತ್ಯವಿದೆ. ಇದು ತುಂಬಾ ಸರಳವಾಗಿದೆ, ಏಕೆಂದರೆ ವಾಸ್ತವದಲ್ಲಿ ಚಕ್ರಗಳ ಅನ್ವಯಗಳ ವ್ಯಾಪ್ತಿಯು ಹೆಚ್ಚು ವಿಸ್ತಾರವಾಗಿದೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ ಎರಡು ಮುಖ್ಯ ವಿಧದ ಲೂಪ್‌ಗಳಿವೆ: ಫಾರ್ ಮತ್ತು ಫಾರ್. ಅತ್ಯಂತ ಜನಪ್ರಿಯವಾದದ್ದು.

ನಿರ್ದಿಷ್ಟ ಕ್ರಿಯೆಗಳ ಜೊತೆಗೆ, ನೀವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಹಂತದವರೆಗೆ ವಿವಿಧ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಲೂಪ್ ಮಾಡಬಹುದು. ಇದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಬಾರಿ ಆಗಿರಬಹುದು ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯು ನಿಜವಾಗಿರುವವರೆಗೆ.

ನಾವು ಲೂಪ್‌ಗಳ ಪ್ರಕಾರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಮತ್ತು ನಿರ್ದಿಷ್ಟವಾಗಿ, ಪುನರಾವರ್ತನೆ ಏನೆಂದು ನಾವು ಇನ್ನೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ಇದು ಪ್ರಸ್ತುತ ಅಪ್ಲಿಕೇಶನ್ ರನ್‌ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಚಕ್ರದಲ್ಲಿ ಕ್ರಿಯೆಯ ಒಂದು ಪುನರಾವರ್ತನೆ ಅಥವಾ ಕ್ರಿಯೆಗಳ ಅನುಕ್ರಮವಾಗಿದೆ.

ಸೈಕಲ್ ಫಾರ್

ನಮ್ಮ ಫಾರ್ ಲೂಪ್ ಅನೇಕ ಇತರ ಭಾಷೆಗಳಲ್ಲಿರುವಂತೆ ಕೌಂಟರ್ ಅಲ್ಲ. ಮೌಲ್ಯಗಳ ನಿರ್ದಿಷ್ಟ ಅನುಕ್ರಮವನ್ನು ಎಣಿಸುವುದು ಇದರ ಕಾರ್ಯವಾಗಿದೆ. ಇದರ ಅರ್ಥ ಏನು? ನಾವು ಅಂಶಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ. ಮೊದಲನೆಯದಾಗಿ, ಲೂಪ್ ಮೊದಲ, ಎರಡನೇ, ಮೂರನೇ, ಇತ್ಯಾದಿಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ಪೈಥಾನ್‌ನಲ್ಲಿನ ಈ ಲೂಪ್‌ನ ಪ್ರಯೋಜನವೆಂದರೆ ಲೂಪ್‌ನಿಂದ ಯಾವಾಗ ನಿರ್ಗಮಿಸಬೇಕು ಎಂಬುದನ್ನು ತಿಳಿಯಲು ನೀವು ಅಂಶದ ಸೂಚಿಯನ್ನು ನಿರ್ಧರಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಎಲ್ಲವನ್ನೂ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ.

>>> spisok = [10, 40, 20, 30]

>>> spisok ನಲ್ಲಿ ಅಂಶಕ್ಕಾಗಿ:

… ಪ್ರಿಂಟ್ (ಅಂಶ + 2)

...

12

42

22

32

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ ಅಂಶ ಫಾರ್ ಆಜ್ಞೆಯ ನಂತರ. ಸಾಮಾನ್ಯವಾಗಿ, ಹೆಸರು ಯಾವುದಾದರೂ ಆಗಿರಬಹುದು. ಉದಾಹರಣೆಗೆ, ಜನಪ್ರಿಯ ಪದನಾಮವೆಂದರೆ i. ಮತ್ತು ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ, ಈ ವೇರಿಯಬಲ್ ಅನ್ನು ಪಟ್ಟಿಯಿಂದ ನಿರ್ದಿಷ್ಟ ವಸ್ತುವನ್ನು ನಿಯೋಜಿಸಲಾಗುವುದು, ಅದನ್ನು ನಾವು ಸೂಕ್ತವಾದ ಪದ ಎಂದು ಕರೆಯುತ್ತೇವೆ.

ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಪಟ್ಟಿಯು 10,40,20,30 ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮವಾಗಿದೆ. ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ, ಅನುಗುಣವಾದ ಮೌಲ್ಯವು ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಲೂಪ್ ಪ್ರಾರಂಭವಾದ ತಕ್ಷಣ, ವೇರಿಯಬಲ್ ಅಂಶ ಮೌಲ್ಯ 10 ಅನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಮುಂದಿನ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ, ಹತ್ತು ಸಂಖ್ಯೆ 40 ಆಗಿ ಬದಲಾಗುತ್ತದೆ, ಮೂರನೇ ಬಾರಿ ಅದು ಸಂಖ್ಯೆ 20 ಆಗಿ ಬದಲಾಗುತ್ತದೆ, ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಲೂಪ್ನ ಕೊನೆಯ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ, ಅದು 30 ಆಗಿ ಬದಲಾಗುತ್ತದೆ.

ಚಕ್ರದ ಅಂತ್ಯದ ಸಂಕೇತವು ಪಟ್ಟಿಯಲ್ಲಿರುವ ಅಂಶಗಳ ಅಂತ್ಯವಾಗಿದೆ.

ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿರುವಂತೆ, ಮೌಲ್ಯಗಳ ಶ್ರೇಷ್ಠ ಎಣಿಕೆಯನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಲೂಪ್ ಅಗತ್ಯವಿದ್ದರೆ, ನಮಗೆ ಅಗತ್ಯವಿರುವ ಮೌಲ್ಯದವರೆಗೆ ನೈಸರ್ಗಿಕ ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮದೊಂದಿಗೆ ನೀವು ಪಟ್ಟಿಯನ್ನು ರಚಿಸಬೇಕು.

>>> spisok = [1,2,3,4,5]

ಅಥವಾ ಕಾರ್ಯವನ್ನು ಬಳಸಿ ಲೆನ್(), ಪಟ್ಟಿಯ ಉದ್ದವನ್ನು ನಿರ್ಧರಿಸಲು. ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಲೂಪ್ ಅನ್ನು ಬಳಸುವುದು ಉತ್ತಮ ಅದೇ ಸಮಯದಲ್ಲಿ, ಏಕೆಂದರೆ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ನೀವು ಪಟ್ಟಿಯಲ್ಲಿನ ಮೌಲ್ಯಗಳ ಅನುಕ್ರಮವನ್ನು ಬದಲಾಯಿಸಬೇಕಾದರೆ, ಲೂಪ್ ಮಾಡಿ ಫಾರ್ ಮತ್ತು ಇಲ್ಲಿ ರಕ್ಷಣೆಗೆ ಬರುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ, ಪಟ್ಟಿಯ ಪ್ರತಿಯೊಂದು ಅಂಶಕ್ಕೂ ಸೂಕ್ತವಾದ ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಬೇಕು.

ಲೂಪ್ ಮಾಡುವಾಗ

ಸೈಕಲ್ ಭಿನ್ನವಾಗಿ ಫಾರ್, ಇದು ಅನುಕ್ರಮ, ಲೂಪ್‌ನ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಸರಳವಾಗಿ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ಹಾಗೆಯೇ ಹೆಚ್ಚು ಉಪಯೋಗಗಳನ್ನು ಹೊಂದಿದೆ. ಈ ರೀತಿಯ ಚಕ್ರಗಳ ಹೆಸರನ್ನು "ಇನ್ನೂ" ಎಂದು ಅನುವಾದಿಸಲಾಗಿದೆ. ಅಂದರೆ, "ರವರೆಗೆ".

ಇದು ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಕಂಡುಬರುವ ಸಾರ್ವತ್ರಿಕ ಲೂಪ್ ಆಗಿದೆ. ಮತ್ತು ಕೆಲವು ವಿಧಗಳಲ್ಲಿ ಇದು ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್ ಅನ್ನು ಹೋಲುತ್ತದೆ ಹೌದು, ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಷರತ್ತನ್ನು ಪೂರೈಸಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್‌ಗೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ ಮಾತ್ರ, ಹಾಗೆಯೇ ಒಮ್ಮೆ ಅಲ್ಲ, ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಚೆಕ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಮತ್ತು ಷರತ್ತು ತಪ್ಪಾಗಿದ್ದರೆ ಮಾತ್ರ, ಲೂಪ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಅನುಸರಿಸುವ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಸರಳ ಪದಗಳಲ್ಲಿ, ಅವನು ಕೆಲಸ ಮಾಡುವ ಪರಿಸ್ಥಿತಿಯು ಇನ್ನು ಮುಂದೆ ಮಾನ್ಯವಾಗಿಲ್ಲದಿದ್ದರೆ.

ನಾವು ಒಂದು ಚಕ್ರವನ್ನು ಸೆಳೆಯುತ್ತಿದ್ದರೆ ಹಾಗೆಯೇ ಸರಳವಾಗಿ, ಅಂತಹ ಯೋಜನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

ಕಾರ್ಯಕ್ರಮದ ಮುಖ್ಯ ಶಾಖೆ (ಇದು ಲೂಪ್ ಹೊರಗೆ ಚಲಿಸುತ್ತದೆ) ನೀಲಿ ಆಯತಗಳೊಂದಿಗೆ ಈ ಚಿತ್ರದಲ್ಲಿ ಚಿತ್ರಿಸಲಾಗಿದೆ. ವೈಡೂರ್ಯವು ಚಕ್ರದ ದೇಹವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಪ್ರತಿಯಾಗಿ, ರೋಂಬಸ್ ಎನ್ನುವುದು ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಪರಿಶೀಲಿಸುವ ಸ್ಥಿತಿಯಾಗಿದೆ.

ಸೈಕಲ್ ಹಾಗೆಯೇ ಎರಡು ವಿನಾಯಿತಿಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು:

1. ಲೂಪ್ನ ಆರಂಭದಲ್ಲಿ ತಾರ್ಕಿಕ ಅಭಿವ್ಯಕ್ತಿ ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸದಿದ್ದರೆ, ಅದು ಸರಳವಾಗಿ ಪ್ರಾರಂಭವಾಗುವುದಿಲ್ಲ, ಮರಣದಂಡನೆಯ ಮೊದಲು ಪೂರ್ಣಗೊಂಡಿದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಈ ಪರಿಸ್ಥಿತಿಯು ಸಾಮಾನ್ಯವಾಗಿದೆ, ಏಕೆಂದರೆ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಅಪ್ಲಿಕೇಶನ್ ಲೂಪ್ ದೇಹದಲ್ಲಿನ ಅಭಿವ್ಯಕ್ತಿಗಳ ಉಪಸ್ಥಿತಿಯನ್ನು ಒದಗಿಸದಿರಬಹುದು.
2. ಅಭಿವ್ಯಕ್ತಿ ಯಾವಾಗಲೂ ನಿಜವಾಗಿದ್ದರೆ, ಇದು ಲೂಪ್ಗೆ ಕಾರಣವಾಗಬಹುದು. ಅಂದರೆ, ಚಕ್ರದ ಅಂತ್ಯವಿಲ್ಲದ ಸ್ಕ್ರೋಲಿಂಗ್‌ಗೆ. ಆದ್ದರಿಂದ, ಅಂತಹ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ, ಯಾವಾಗಲೂ ಲೂಪ್ ಅಥವಾ ಪ್ರೋಗ್ರಾಂನಿಂದ ನಿರ್ಗಮನ ಹೇಳಿಕೆ ಇರಬೇಕು. ಆದಾಗ್ಯೂ, ಪ್ರೋಗ್ರಾಂ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯ ಸತ್ಯ ಅಥವಾ ಸುಳ್ಳನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾದರೆ ಈ ಪರಿಸ್ಥಿತಿಯು ಉದ್ಭವಿಸುತ್ತದೆ. ಅವಳು ಇದನ್ನು ಮಾಡಲು ವಿಫಲವಾದರೆ, ಪ್ರೋಗ್ರಾಂನ ಮುಕ್ತಾಯದೊಂದಿಗೆ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಅಥವಾ ನೀವು ದೋಷವನ್ನು ನಿಭಾಯಿಸಬಹುದು, ಮತ್ತು ಅದು ಸಂಭವಿಸಿದಲ್ಲಿ, ನಿರ್ದಿಷ್ಟ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ದೋಷವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದಕ್ಕೆ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಆಯ್ಕೆಗಳು ಇರಬಹುದು. ಉದಾಹರಣೆಗೆ, ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ನಮೂದಿಸಲು ಪ್ರೋಗ್ರಾಂ ಬಳಕೆದಾರರನ್ನು ಕೇಳಬಹುದು. ಆದ್ದರಿಂದ, ಒಬ್ಬ ವ್ಯಕ್ತಿಯು ನಕಾರಾತ್ಮಕ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸಿದರೆ ಅದು ಧನಾತ್ಮಕವಾಗಿರಬಹುದು ಅಥವಾ ಸಂಖ್ಯೆಗಳು ಮಾತ್ರ ಇರಬೇಕಾದ ಅಕ್ಷರಗಳನ್ನು ನಮೂದಿಸಿದರೆ, ಪ್ರೋಗ್ರಾಂ ಅದರ ಬಗ್ಗೆ ಹೇಳಬಹುದು.

ಲೂಪ್ ಉದಾಹರಣೆಗಳು

ಈ ಸಂದರ್ಭದಲ್ಲಿ ದೋಷವನ್ನು ನಿಭಾಯಿಸುವ ಕೋಡ್‌ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ.

n = ಇನ್ಪುಟ್ ("ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ನಮೂದಿಸಿ:") 

ಆದರೆ ಟೈಪ್ (ಎನ್) != ಇಂಟ್:

    ಪ್ರಯತ್ನಿಸಿ:

        n = int(n)

    ಮೌಲ್ಯ ದೋಷವನ್ನು ಹೊರತುಪಡಿಸಿ:

        ಮುದ್ರಣ ("ತಪ್ಪು ನಮೂದು!")

        n = ಇನ್ಪುಟ್ ("ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ನಮೂದಿಸಿ:") 

n % 2 == 0 ಆಗಿದ್ದರೆ:

    ಮುದ್ರಣ ("ಸಹ")

ಬೇರೆ:

    ಮುದ್ರಣ ("ಬೆಸ")

ಸಂಕೀರ್ಣ ಕೋಡ್ ರಚನೆಗಳನ್ನು ಘೋಷಿಸಲು ಪೈಥಾನ್ ಕಾಲನ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

ಮೇಲಿನ ಕೋಡ್‌ನಲ್ಲಿ, ಸಂಖ್ಯೆಯು ಪೂರ್ಣಾಂಕವಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬೇಕಾದ ಷರತ್ತು ಎಂದು ನಾವು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ. ಹೌದು ಎಂದಾದರೆ, ತಪ್ಪನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ನಂತರ ನಿಜ.

ಕೋಡ್ನ ಎರಡನೇ ಭಾಗದಲ್ಲಿ, ಅಲ್ಲಿ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ if, ವಿಭಜನೆಯ ಕಾರ್ಯಾಚರಣೆಯ ನಂತರ ಉಳಿದವನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಾವು % ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ. ಮುಂದಿನ ಹಂತವು ಸಂಖ್ಯೆಯು ಸಮವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು. ಇಲ್ಲದಿದ್ದರೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಉಳಿದವು ಒಂದಾಗಿದೆ. ಅದರಂತೆ, ಸಂಖ್ಯೆ ಬೆಸವಾಗಿದೆ. 

ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಬಳಕೆದಾರರು ನಮೂದಿಸಿದ ಸ್ಟ್ರಿಂಗ್ ಸಂಖ್ಯೆಯೇ ಎಂದು ಮೇಲಿನ ಕೋಡ್ ಮೊದಲು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹೌದು ಎಂದಾದರೆ, ಎರಡರಿಂದ ವಿಭಜನೆಯ ಉಳಿದಿದೆಯೇ ಎಂದು ನೋಡಲು ಎರಡನೇ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡಲಾಗುತ್ತದೆ. ಆದರೆ ಬಳಕೆದಾರರು ನಮೂದಿಸಿದ ಮೌಲ್ಯವು ಸಂಖ್ಯಾತ್ಮಕವಾಗುವವರೆಗೆ ಎರಡನೇ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ.

ಅಂದರೆ, ಸ್ಥಿತಿಯು ಸಂಭವಿಸುವವರೆಗೆ ಲೂಪ್ ಅನ್ನು ನಿಯಮಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಈ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ಇದು ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. 

ಅಂದರೆ, ನೀವು ವಿರುದ್ಧವಾಗಿ ಹೋಗಬಹುದು: ಈವೆಂಟ್ ತಪ್ಪಾಗುವವರೆಗೆ ನಿರ್ದಿಷ್ಟ ಕ್ರಿಯೆಯನ್ನು ಲೂಪ್ ಮಾಡಿ.

ಕೋಡ್ ಪಾರ್ಸಿಂಗ್

ಈಗ ಈ ಕೋಡ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ನೋಡೋಣ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಅದನ್ನು ಹಂತ ಹಂತವಾಗಿ ವಿಶ್ಲೇಷಿಸುತ್ತೇವೆ.

1. ಮೊದಲಿಗೆ, ಬಳಕೆದಾರರು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತಾರೆ, ಅದನ್ನು ವೇರಿಯಬಲ್ n ನಿಂದ ಸ್ವೀಕರಿಸಲಾಗುತ್ತದೆ. 
2. ಲೂಪ್ ಅನ್ನು ಬಳಸುವುದು ಹಾಗೆಯೇ ಈ ವೇರಿಯಬಲ್ ಪ್ರಕಾರವನ್ನು ಪರಿಶೀಲಿಸಲಾಗಿದೆ. ಮೊದಲ ಪ್ರವೇಶದಲ್ಲಿ, ಇದು ಸಮಾನವಾಗಿಲ್ಲ ಇಂಟ್. ಆದ್ದರಿಂದ, ಪರೀಕ್ಷೆಯ ಪರಿಣಾಮವಾಗಿ, ಈ ಸ್ಥಿತಿಯು ನಿಜವೆಂದು ಕಂಡುಬರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಲೂಪ್ ದೇಹವನ್ನು ನಮೂದಿಸಲಾಗಿದೆ.
3. ಆಪರೇಟರ್ ಸಹಾಯದಿಂದ ಪ್ರಯತ್ನಿಸಿ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಂಖ್ಯೆಗೆ ಪರಿವರ್ತಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೇವೆ. ಇದನ್ನು ಮಾಡಿದರೆ, ಯಾವುದೇ ದೋಷ ಸಂಭವಿಸುವುದಿಲ್ಲ. ಅದರಂತೆ, ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಆದ್ದರಿಂದ, ಇಂಟರ್ಪ್ರಿಟರ್ ಲೂಪ್ನ ಆರಂಭಕ್ಕೆ ಹಿಂದಿರುಗುತ್ತಾನೆ, ಮತ್ತು ಚೆಕ್ನ ಫಲಿತಾಂಶಗಳ ಪ್ರಕಾರ, ಅದು ಪೂರ್ಣಾಂಕವಾಗಿ ಮಾರ್ಪಟ್ಟಿದೆ ಎಂದು ತಿರುಗುತ್ತದೆ. ಆದ್ದರಿಂದ ನಾವು 7 ನೇ ಹಂತಕ್ಕೆ ಹೋಗೋಣ
4. ಪರಿವರ್ತನೆಯು ವಿಫಲವಾದರೆ, ಮೌಲ್ಯದೋಷವನ್ನು ಎಸೆಯಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂ ಹರಿವನ್ನು ಹೊರತುಪಡಿಸಿ ಹ್ಯಾಂಡ್ಲರ್ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.
5. ಬಳಕೆದಾರರು ಹೊಸ ಮೌಲ್ಯವನ್ನು ನಮೂದಿಸುತ್ತಾರೆ, ಅದನ್ನು ವೇರಿಯೇಬಲ್ n ಗೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ.
6. ಇಂಟರ್ಪ್ರಿಟರ್ ಹಂತ 2 ಗೆ ಹಿಂತಿರುಗುತ್ತಾನೆ ಮತ್ತು ಮತ್ತೊಮ್ಮೆ ಪರಿಶೀಲಿಸುತ್ತಾನೆ. ಇದು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವಾಗಿದ್ದರೆ, ಹಂತ 7 ಕ್ಕೆ ಹೋಗಿ. ಇಲ್ಲದಿದ್ದರೆ, ಹಂತ 3 ರ ಪ್ರಕಾರ ಪರಿವರ್ತನೆಯನ್ನು ಮತ್ತೊಮ್ಮೆ ಪ್ರಯತ್ನಿಸಲಾಗುತ್ತದೆ.
7. ಆಪರೇಟರ್ ಸಹಾಯದಿಂದ if ಸಂಖ್ಯೆಯನ್ನು 2 ರಿಂದ ಭಾಗಿಸಿದ ನಂತರ ಶೇಷವಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ. 
8. ಇಲ್ಲದಿದ್ದರೆ, "ಸಹ" ಪಠ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
9. ಇಲ್ಲದಿದ್ದರೆ, "ಬೆಸ" ಪಠ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

ಈಗ ಅಂತಹ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಚಕ್ರವು ಎಷ್ಟು ಬಾರಿ ಹಾದುಹೋಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಪ್ರಯತ್ನಿಸಿ?

ಒಟ್ಟು = 100 

ನಾನು = 0

ನಾನು <5:

    n = int(ಇನ್ಪುಟ್())

    ಒಟ್ಟು = ಒಟ್ಟು - ಎನ್

    ನಾನು = ನಾನು + 1 

ಮುದ್ರಣ ("ಉಳಿದಿರುವ", ಒಟ್ಟು)

ಸರಿಯಾದ ಉತ್ತರ 5. ಆರಂಭದಲ್ಲಿ, ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯ i - ಶೂನ್ಯ. ವೇರಿಯೇಬಲ್ ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ಇಂಟರ್ಪ್ರಿಟರ್ ಪರಿಶೀಲಿಸುತ್ತದೆ i 4 ಅಥವಾ ಕಡಿಮೆ. ಹೌದು ಎಂದಾದರೆ, ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ನಿಜವಾದ, ಮತ್ತು ಲೂಪ್ ಪ್ರಕಾರವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಮೌಲ್ಯವನ್ನು ಒಂದರಿಂದ ಹೆಚ್ಚಿಸಲಾಗಿದೆ.

ಮೊದಲ ಪುನರಾವರ್ತನೆಯ ನಂತರ, ವೇರಿಯೇಬಲ್ನ ಮೌಲ್ಯವು 1 ಆಗುತ್ತದೆ. ಒಂದು ಚೆಕ್ ಅನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಈ ಸಂಖ್ಯೆಯು ಮತ್ತೆ 5 ಕ್ಕಿಂತ ಕಡಿಮೆಯಿದೆ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತದೆ. ಅದರ ಪ್ರಕಾರ, ಲೂಪ್ ದೇಹವನ್ನು ಎರಡನೇ ಬಾರಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಹಂತಗಳು ಒಂದೇ ಆಗಿರುವುದರಿಂದ, ಮೌಲ್ಯವು ಒಂದರಿಂದ ಹೆಚ್ಚಾಗುತ್ತದೆ ಮತ್ತು ವೇರಿಯೇಬಲ್ ಈಗ 2 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ.

ಈ ಮೌಲ್ಯವು ಐದಕ್ಕಿಂತ ಕಡಿಮೆಯಾಗಿದೆ. ನಂತರ ಲೂಪ್ ಅನ್ನು ಮೂರನೇ ಬಾರಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ವೇರಿಯಬಲ್ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ i 1 ಮತ್ತು ಅದಕ್ಕೆ 3 ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಇದು ಮತ್ತೆ ಐದಕ್ಕಿಂತ ಕಡಿಮೆಯಾಗಿದೆ. ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಲೂಪ್ನ ಆರನೇ ಪುನರಾವರ್ತನೆಗೆ ಬರುತ್ತದೆ, ಅದರಲ್ಲಿ ವೇರಿಯಬಲ್ನ ಮೌಲ್ಯ i 5 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ (ಎಲ್ಲಾ ನಂತರ, ಇದು ಮೂಲತಃ ಶೂನ್ಯವಾಗಿತ್ತು, ನಮಗೆ ನೆನಪಿರುವಂತೆ). ಅಂತೆಯೇ, ಈ ಸ್ಥಿತಿಯು ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತೀರ್ಣವಾಗುವುದಿಲ್ಲ, ಮತ್ತು ಲೂಪ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಹೊರಗಿರುವ ಮುಂದಿನ ಹಂತಕ್ಕೆ ಪರಿವರ್ತನೆ (ಅಥವಾ ಪ್ರೋಗ್ರಾಂ ಮುಕ್ತಾಯ, ಕೆಳಗಿನ ಹಂತಗಳನ್ನು ಒದಗಿಸದಿದ್ದರೆ) ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ.

ಚಕ್ರವು ವಿರುದ್ಧ ದಿಕ್ಕಿನಲ್ಲಿಯೂ ಸಂಭವಿಸಬಹುದು. ಪ್ರತಿ ನಂತರದ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ, ವೇರಿಯಬಲ್‌ನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯದಿಂದ ಒಂದನ್ನು ಕಳೆಯುವ ಕೋಡ್‌ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ. 

ಒಟ್ಟು = 100 

ಒಟ್ಟು > 0:

    n = int(ಇನ್ಪುಟ್())

    ಒಟ್ಟು = ಒಟ್ಟು - ಎನ್ 

ಮುದ್ರಣ ("ಸಂಪನ್ಮೂಲ ಖಾಲಿಯಾಗಿದೆ")

ಈ ಪ್ರೋಗ್ರಾಂ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸಿ! ಅದನ್ನು ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ ಒಟ್ಟು ಪ್ರೋಗ್ರಾಂ ಸಂಪನ್ಮೂಲಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. ಪ್ರತಿ ಬಾರಿ ಇಂಟರ್ಪ್ರಿಟರ್ ಸಂಪನ್ಮೂಲ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, "ಸಂಪನ್ಮೂಲ ದಣಿದಿದೆ" ಎಂಬ ಪಠ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಮುಚ್ಚುತ್ತದೆ. ಮತ್ತು ಲೂಪ್ನ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ, ಬಳಕೆದಾರರು ಸೂಚಿಸುವ ಸಂಖ್ಯೆಯಿಂದ ಸಂಪನ್ಮೂಲವು ಕಡಿಮೆಯಾಗುತ್ತದೆ.

ಮತ್ತು ಈಗ ಮನೆಕೆಲಸ. ಮೇಲಿನ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಇದರಿಂದ ವೇರಿಯಬಲ್ ಭೌತಿಕವಾಗಿ ಋಣಾತ್ಮಕವಾಗುವುದಿಲ್ಲ.