ಪೈಥಾನ್‌ನಲ್ಲಿ ಹೇಳಿಕೆ ವೇಳೆ ಷರತ್ತುಬದ್ಧ. ಸಿಂಟ್ಯಾಕ್ಸ್, ಬೇರೆ/ಎಲಿಫ್ ಬ್ಲಾಕ್‌ಗಳು, ಉದಾಹರಣೆಗಳು

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

ಇಂದು ನಾವು if ಹೇಳಿಕೆಯ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ, ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಗಾಗಿ ಪ್ರಸ್ತುತ ಪರಿಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಈ ಮಾಹಿತಿಯ ಆಧಾರದ ಮೇಲೆ ಮುಂದಿನ ಕ್ರಮಗಳ ಬಗ್ಗೆ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ನಿಯಂತ್ರಣ ಹೇಳಿಕೆಗಳ ವಿಧಗಳು

ಸಾಮಾನ್ಯವಾಗಿ, ಪ್ರೋಗ್ರಾಂನ ಹರಿವನ್ನು ನಿಯಂತ್ರಿಸುವ ಏಕೈಕ ಹೇಳಿಕೆ ಇಲ್ಲದಿದ್ದರೆ. ಹಾಗೆಯೇ ಅವನು ಸ್ವತಃ ಆಪರೇಟರ್‌ಗಳ ದೊಡ್ಡ ಸರಪಳಿಯ ಒಂದು ಅಂಶವಾಗಿರಬಹುದು.

ಅದರ ಮರಣದಂಡನೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಯಂತ್ರಿಸುವ ಕುಣಿಕೆಗಳು ಮತ್ತು ಹೇಳಿಕೆಗಳು ಸಹ ಇವೆ. ಇಂದು ನಾವು ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್ ಮತ್ತು ಅದರಲ್ಲಿ ಭಾಗವಹಿಸಬಹುದಾದ ಸರಪಳಿಗಳ ಬಗ್ಗೆ ಮಾತ್ರ ಮಾತನಾಡುತ್ತೇವೆ.

ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ, ಶಾಖೆಯಂತಹ ವಿಷಯವಿದೆ. ಇದು ನಿಖರವಾಗಿ ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಷರತ್ತು ನಿಜವಾಗಿದ್ದರೆ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಆಜ್ಞೆಗಳ ಅನುಕ್ರಮವನ್ನು ಅರ್ಥೈಸುತ್ತದೆ. ಮಾನದಂಡಗಳು ವಿಭಿನ್ನವಾಗಿರಬಹುದು:

  1. ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಕ್ಕೆ ವೇರಿಯಬಲ್‌ನ ಸಮಾನತೆ.
  2. ನಿರ್ದಿಷ್ಟ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸುವುದು.
  3. ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಿತಿ (ಕುಸಿದಿದೆ ಅಥವಾ ಇಲ್ಲ).

ಸ್ಪೆಕ್ಟ್ರಮ್ ಹೆಚ್ಚು ದೊಡ್ಡದಾಗಿರಬಹುದು. ಷರತ್ತುಬದ್ಧ ಹೇಳಿಕೆಗಳು ಹಲವಾರು ವಿಧಗಳಲ್ಲಿ ಬರುತ್ತವೆ:

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

ಹೇಳಿಕೆ ವೇಳೆ

if ಹೇಳಿಕೆಯ ರಚನೆಯು ಎಲ್ಲಾ ಭಾಷೆಗಳಲ್ಲಿ ಹೋಲುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಪೈಥಾನ್‌ನಲ್ಲಿ, ಅದರ ಸಿಂಟ್ಯಾಕ್ಸ್ ಎಲ್ಲಕ್ಕಿಂತ ಸ್ವಲ್ಪ ಭಿನ್ನವಾಗಿದೆ:

ಒಂದು ವೇಳೆ ಸ್ಥಿತಿ:

    <входящее выражение 1>

    <входящее выражение 2>

<не входящее выражение>

ಮೊದಲಿಗೆ, ಆಪರೇಟರ್ ಅನ್ನು ಸ್ವತಃ ಘೋಷಿಸಲಾಗುತ್ತದೆ, ಅದರ ನಂತರ ಅದು ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುವ ಸ್ಥಿತಿಯನ್ನು ಬರೆಯಲಾಗುತ್ತದೆ. ಸ್ಥಿತಿಯು ನಿಜ ಅಥವಾ ಸುಳ್ಳಾಗಿರಬಹುದು.

ಇದರ ನಂತರ ಕಮಾಂಡ್‌ಗಳಿರುವ ಬ್ಲಾಕ್ ಇರುತ್ತದೆ. ಅದು ತಕ್ಷಣವೇ ಪೂರೈಸಬೇಕಾದ ಮಾನದಂಡವನ್ನು ಅನುಸರಿಸಿದರೆ, ಅನುಗುಣವಾದ ಆಜ್ಞೆಗಳ ಅನುಕ್ರಮವನ್ನು if block ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ನೀವು ಅದರಲ್ಲಿ ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಬಹುದು.

ಗಮನ! ಬ್ಲಾಕ್ ಕಮಾಂಡ್‌ಗಳ ಎಲ್ಲಾ ಒಳಗಿನ ಇಂಡೆಂಟೇಶನ್ ಒಂದೇ ಗಾತ್ರದಲ್ಲಿರಬೇಕು. ಬ್ಲಾಕ್ ಗಡಿಗಳನ್ನು ಇಂಡೆಂಟ್‌ಗಳಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ. 

ಭಾಷಾ ದಾಖಲಾತಿಯ ಪ್ರಕಾರ, ಇಂಡೆಂಟೇಶನ್ 4 ಸ್ಥಳಗಳು. 

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

ಸ್ಥಿತಿಯ ನಂತರದ ಹೇಳಿಕೆಯನ್ನು ಇಂಡೆಂಟ್ ಮಾಡದಿದ್ದರೆ, ಅದನ್ನು if block ಎಂದು ಪರಿಗಣಿಸಲಾಗುವುದಿಲ್ಲ. ನಮ್ಮ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ಈ ಸಾಲು . ಆದ್ದರಿಂದ, ಚೆಕ್ ಫಲಿತಾಂಶವನ್ನು ಲೆಕ್ಕಿಸದೆ, ಈ ಸಾಲನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಈ ಆಪರೇಟರ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಉದಾಹರಣೆಗಾಗಿ ಕೋಡ್ ತುಣುಕು ಇಲ್ಲಿದೆ.

ಸಂಖ್ಯೆ = ಇಂಟ್ (ಇನ್ಪುಟ್ ("ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ: "))

ಸಂಖ್ಯೆ > 10 ಆಗಿದ್ದರೆ:

    ಮುದ್ರಣ ("ಸಂಖ್ಯೆಯು 10 ಕ್ಕಿಂತ ಹೆಚ್ಚಿದೆ")

ಈ ಪ್ರೋಗ್ರಾಂ ಬಳಕೆದಾರರನ್ನು ಸಂಖ್ಯೆಗಾಗಿ ಪ್ರೇರೇಪಿಸುತ್ತದೆ ಮತ್ತು ಅದು 10 ಕ್ಕಿಂತ ಹೆಚ್ಚಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದಲ್ಲಿ, ಅದು ಸೂಕ್ತವಾದ ಮಾಹಿತಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು 5 ನೇ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿದರೆ, ಪ್ರೋಗ್ರಾಂ ಸರಳವಾಗಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಅದು ಇಲ್ಲಿದೆ.

ಆದರೆ ನೀವು 100 ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ, ಅದು ಹತ್ತಕ್ಕಿಂತ ಹೆಚ್ಚು ಎಂದು ಇಂಟರ್ಪ್ರಿಟರ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತಾರೆ ಮತ್ತು ಅದನ್ನು ವರದಿ ಮಾಡುತ್ತಾರೆ.

ಗಮನ! ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಷರತ್ತು ತಪ್ಪಾಗಿದ್ದರೆ, ಪ್ರೋಗ್ರಾಂ ನಿಲ್ಲುತ್ತದೆ, ಏಕೆಂದರೆ ಸೂಚನೆಯ ನಂತರ ಯಾವುದೇ ಆಜ್ಞೆಗಳನ್ನು ನೀಡಲಾಗುವುದಿಲ್ಲ.

ಮೇಲಿನ ಕೋಡ್‌ನಲ್ಲಿ ಒಂದೇ ಒಂದು ಆಜ್ಞೆಯಿದೆ. ಆದರೆ ಅವುಗಳಲ್ಲಿ ಹಲವು ಇವೆ. ಇಂಡೆಂಟ್ ಮಾಡುವುದು ಒಂದೇ ಅವಶ್ಯಕತೆಯಾಗಿದೆ.

ಈಗ ಈ ಆಜ್ಞೆಗಳ ಅನುಕ್ರಮವನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ.

ಸಂಖ್ಯೆ = ಇಂಟ್ (ಇನ್ಪುಟ್ ("ಸಂಖ್ಯೆಯನ್ನು ಬರೆಯಿರಿ:"))

ಸಂಖ್ಯೆ > 10 ಆಗಿದ್ದರೆ:

    ಮುದ್ರಣ ("ಮೊದಲ ಸಾಲು")

    ಮುದ್ರಣ ("ಎರಡನೇ ಸಾಲು")

    ಮುದ್ರಣ ("ಮೂರನೇ ಸಾಲು")

ಮುದ್ರಿಸು ("ನಮೂದಿಸಿದ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಿಸದೆಯೇ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಸಾಲು")

ಮುದ್ರಣ ("ಅಪ್ಲಿಕೇಶನ್ ಅಂತ್ಯ")

ನೀವು 2, 5, 10, 15, 50 ಮೌಲ್ಯಗಳನ್ನು ನಮೂದಿಸಿದರೆ ಔಟ್ಪುಟ್ ಏನಾಗುತ್ತದೆ ಎಂದು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸಿ.

ನೀವು ನೋಡುವಂತೆ, ಬಳಕೆದಾರರು ನಮೂದಿಸಿದ ಸಂಖ್ಯೆಯು ಹತ್ತಕ್ಕಿಂತ ಹೆಚ್ಚಿದ್ದರೆ, ಮೂರು ಸಾಲುಗಳು ಔಟ್‌ಪುಟ್ ಆಗಿರುತ್ತವೆ + "ಪ್ರತಿ ಬಾರಿಯೂ ರನ್ ಮಾಡಿ ..." ಮತ್ತು ಒಂದು "ಅಂತ್ಯ" ಪಠ್ಯದೊಂದಿಗೆ ಒಂದು, ಮತ್ತು ಹತ್ತಕ್ಕಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ, ಕೇವಲ ಒಂದು, ಜೊತೆಗೆ ವಿಭಿನ್ನ ಪಠ್ಯ. ನಿಜವಾಗಿದ್ದರೆ 3,4,5 ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಬಳಕೆದಾರರು ಯಾವ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೂ ಕೊನೆಯ ಎರಡು ಸಾಲುಗಳನ್ನು ಬರೆಯಲಾಗುತ್ತದೆ.

ನೀವು ನೇರವಾಗಿ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಹೇಳಿಕೆಗಳನ್ನು ಬಳಸಿದರೆ, ಫಲಿತಾಂಶವು ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ. ಪರಿಶೀಲನಾ ಮಾನದಂಡವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಂತರ, ಎಂಟರ್ ಒತ್ತಿದರೆ ಇಂಟರ್ಪ್ರಿಟರ್ ತಕ್ಷಣವೇ ಬಹು-ಸಾಲಿನ ಮೋಡ್ ಅನ್ನು ಆನ್ ಮಾಡುತ್ತದೆ.

ನಾವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಗಳ ಅನುಕ್ರಮವನ್ನು ಬರೆದಿದ್ದೇವೆ ಎಂದು ಭಾವಿಸೋಣ.

>>>

>>> n = 100

>>> ವೇಳೆ n > 10:

...

ಅದರ ನಂತರ, ನಾವು >>> ಅನ್ನು ಎಲಿಪ್ಸಿಸ್ನಿಂದ ಬದಲಾಯಿಸಿರುವುದನ್ನು ನೋಡುತ್ತೇವೆ. ಇದರರ್ಥ ಮಲ್ಟಿಲೈನ್ ಇನ್‌ಪುಟ್ ಮೋಡ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ. ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ನೀವು Enter ಅನ್ನು ಒತ್ತಿದರೆ, ಸೂಚನೆಯ ಎರಡನೇ ಹಂತದ ಇನ್ಪುಟ್ಗೆ ನಿಮ್ಮನ್ನು ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ. 

ಮತ್ತು ಈ ಬ್ಲಾಕ್‌ನಿಂದ ನಿರ್ಗಮಿಸಲು, ನೀವು ಬ್ಲಾಕ್‌ಗೆ ಇನ್ನೊಂದು ನಿರ್ಮಾಣವನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ if.

>>>

>>> n = 100

>>> ವೇಳೆ n > 10:

… ಪ್ರಿಂಟ್ (“ಎನ್ವಿ 10”)

...

ಷರತ್ತು ನಿಜವಾಗದಿದ್ದರೆ, ಪ್ರೋಗ್ರಾಂ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಇದು ಒಂದು ಸಮಸ್ಯೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ವೈಫಲ್ಯದ ಕಾರಣದಿಂದಾಗಿ ಅಂತಹ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮುಚ್ಚಲಾಗಿದೆ ಎಂದು ಬಳಕೆದಾರರು ಗ್ರಹಿಸಬಹುದು. ಆದ್ದರಿಂದ, ಬಳಕೆದಾರರಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುವುದು ಅವಶ್ಯಕ. ಇದಕ್ಕಾಗಿ, ಲಿಂಕ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಇದ್ದರೆ-ಇಲ್ಲ.

ಅಭಿವ್ಯಕ್ತಿ ಆಪರೇಟರ್ ಇದ್ದರೆ-ಇಲ್ಲ

ಈ ಆಪರೇಟರ್ ಲಿಂಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ: ಅಭಿವ್ಯಕ್ತಿಯು ಒಂದು ನಿರ್ದಿಷ್ಟ ನಿಯಮಕ್ಕೆ ಹೊಂದಿಕೆಯಾದರೆ, ಈ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಿ, ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ, ನಂತರ ಇತರರು. ಅಂದರೆ, ಪ್ರೋಗ್ರಾಂನ ಹರಿವನ್ನು ಎರಡು ರಸ್ತೆಗಳಾಗಿ ವಿಭಜಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಸಿಂಟ್ಯಾಕ್ಸ್ ಅರ್ಥಗರ್ಭಿತವಾಗಿದೆ:

ಒಂದು ವೇಳೆ ಸ್ಥಿತಿ:

    # ನಿರ್ಬಂಧಿಸಿದರೆ

    ಹೇಳಿಕೆ 1

    ಹೇಳಿಕೆ 2

    ಮತ್ತು ಇತ್ಯಾದಿ

ಬೇರೆ:

    # ಬೇರೆ ಬ್ಲಾಕ್

    ಹೇಳಿಕೆ 3

    ಹೇಳಿಕೆ 4

    ಮತ್ತು ಇತ್ಯಾದಿ:

ಈ ಆಪರೇಟರ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸೋಣ. ಮೊದಲನೆಯದಾಗಿ, ಪ್ರಮಾಣಿತ ಹೇಳಿಕೆಯನ್ನು ಥ್ರೆಡ್ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಹೌದು, ಇದು ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ ಸ್ಥಿತಿ "ಸರಿ ಅಥವಾ ತಪ್ಪು". ಮುಂದಿನ ಕ್ರಮಗಳು ಚೆಕ್ ಫಲಿತಾಂಶಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ನಿಜವಾಗಿದ್ದರೆ, ಸ್ಥಿತಿಯನ್ನು ಅನುಸರಿಸುವ ಸೂಚನೆಗಳ ಅನುಕ್ರಮದಲ್ಲಿರುವ ಸೂಚನೆಯನ್ನು ನೇರವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಹೌದು, ಅದು ಸುಳ್ಳಾಗಿದ್ದರೆ, ಆಗ ಬೇರೆ

ಈ ರೀತಿಯಾಗಿ ನೀವು ದೋಷಗಳನ್ನು ನಿಭಾಯಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು ತ್ರಿಜ್ಯವನ್ನು ನಮೂದಿಸಬೇಕಾಗುತ್ತದೆ. ನಿಸ್ಸಂಶಯವಾಗಿ, ಇದು ಪ್ಲಸ್ ಚಿಹ್ನೆಯೊಂದಿಗೆ ಮಾತ್ರ ಸಂಖ್ಯೆಯಾಗಿರಬಹುದು ಅಥವಾ ಅದು ಶೂನ್ಯ ಮೌಲ್ಯವಾಗಿದೆ. ಅದು 0 ಕ್ಕಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ, ಧನಾತ್ಮಕ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಲು ನಿಮ್ಮನ್ನು ಕೇಳುವ ಸಂದೇಶವನ್ನು ನೀವು ನೀಡಬೇಕಾಗುತ್ತದೆ. 

ಈ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕೋಡ್ ಇಲ್ಲಿದೆ. ಆದರೆ ಇಲ್ಲಿ ಒಂದು ತಪ್ಪಿದೆ. ಯಾವುದನ್ನು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸಿ. 

ತ್ರಿಜ್ಯ = ಇಂಟ್ (ಇನ್ಪುಟ್ ("ತ್ರಿಜ್ಯವನ್ನು ನಮೂದಿಸಿ: "))

ತ್ರಿಜ್ಯ >= 0 ಆಗಿದ್ದರೆ:

    ಪ್ರಿಂಟ್ ("ಸುತ್ತಳತೆ = ", 2 * 3.14 * ತ್ರಿಜ್ಯ)

    ಮುದ್ರಿಸು ("ಪ್ರದೇಶ = ", 3.14 * ತ್ರಿಜ್ಯ ** 2)

    ಬೇರೆ:

        ಮುದ್ರಿಸು ("ದಯವಿಟ್ಟು ಧನಾತ್ಮಕ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ")

ಇಂಡೆಂಟೇಶನ್ ಹೊಂದಿಕೆಯಾಗದ ದೋಷ. ಒಂದು ವೇಳೆ ಮತ್ತು ಬೇರೆ ಅವುಗಳಿಲ್ಲದೆ ಅಥವಾ ಅವುಗಳ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಇರಬೇಕು (ಅವು ಗೂಡುಕಟ್ಟಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ).

ಮತ್ತೊಂದು ಬಳಕೆಯ ಸಂದರ್ಭವನ್ನು ನೀಡೋಣ (ಆಪರೇಟರ್ ಜೋಡಣೆಯೊಂದಿಗೆ ಎಲ್ಲವೂ ಸರಿಯಾಗಿರುತ್ತದೆ) - ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಅಂಶ.

ಪಾಸ್ವರ್ಡ್ = ಇನ್ಪುಟ್ ("ಪಾಸ್ವರ್ಡ್ ನಮೂದಿಸಿ:")

ಪಾಸ್ವರ್ಡ್ == «sshh» ವೇಳೆ:

    ಮುದ್ರಿಸು ("ಸ್ವಾಗತ")

ಬೇರೆ:

    ಮುದ್ರಣ ("ಪ್ರವೇಶ ನಿರಾಕರಿಸಲಾಗಿದೆ")

ಪಾಸ್ವರ್ಡ್ sshh ಆಗಿದ್ದರೆ ಈ ಸೂಚನೆಯು ವ್ಯಕ್ತಿಯನ್ನು ಮತ್ತಷ್ಟು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. ಅಕ್ಷರಗಳು ಮತ್ತು ಸಂಖ್ಯೆಗಳ ಯಾವುದೇ ಸಂಯೋಜನೆಯಿದ್ದರೆ, ಅದು "ಪ್ರವೇಶ ನಿರಾಕರಿಸಲಾಗಿದೆ" ಎಂಬ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಹೇಳಿಕೆ-ಅಭಿವ್ಯಕ್ತಿ if-elif-else

ಹಲವಾರು ಷರತ್ತುಗಳು ನಿಜವಲ್ಲದಿದ್ದರೆ ಮಾತ್ರ, ಬ್ಲಾಕ್‌ನಲ್ಲಿರುವ ಹೇಳಿಕೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಬೇರೆ. ಈ ಅಭಿವ್ಯಕ್ತಿ ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಷರತ್ತು_1 ವೇಳೆ:

    # ನಿರ್ಬಂಧಿಸಿದರೆ

    ಹೇಳಿಕೆ

    ಹೇಳಿಕೆ

    ಹೆಚ್ಚಿನ ಹೇಳಿಕೆ

ಎಲಿಫ್ ಸ್ಥಿತಿ_2:

    # ಮೊದಲ ಎಲಿಫ್ ಬ್ಲಾಕ್

    ಹೇಳಿಕೆ

    ಹೇಳಿಕೆ

    ಹೆಚ್ಚಿನ ಹೇಳಿಕೆ

ಎಲಿಫ್ ಸ್ಥಿತಿ_3:

    # ಎರಡನೇ ಎಲಿಫ್ ಬ್ಲಾಕ್

    ಹೇಳಿಕೆ

    ಹೇಳಿಕೆ

    ಹೆಚ್ಚಿನ ಹೇಳಿಕೆ

...

ಬೇರೆ

    ಹೇಳಿಕೆ

    ಹೇಳಿಕೆ

    ಹೆಚ್ಚಿನ ಹೇಳಿಕೆ

ನೀವು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಷರತ್ತುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ನೆಸ್ಟೆಡ್ ಹೇಳಿಕೆಗಳು

ಬಹು ಷರತ್ತುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇನ್ನೊಂದು ಮಾರ್ಗವೆಂದರೆ if ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಸ್ಥಿತಿ ಪರಿಶೀಲನೆಗಳನ್ನು ಸೇರಿಸುವುದು.

ಆಪರೇಟರ್ if ಮತ್ತೊಂದು ಷರತ್ತು ಬ್ಲಾಕ್ ಒಳಗೆ

gre_score = int (ಇನ್‌ಪುಟ್ (“ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಕ್ರೆಡಿಟ್ ಮಿತಿಯನ್ನು ನಮೂದಿಸಿ”))

per_grad = int (ಇನ್ಪುಟ್ ("ನಿಮ್ಮ ಕ್ರೆಡಿಟ್ ರೇಟಿಂಗ್ ಅನ್ನು ನಮೂದಿಸಿ:"))

per_grad > 70:

    # ಹೊರಗಿದ್ದರೆ ಬ್ಲಾಕ್

        ಗ್ರೇ_ಸ್ಕೋರ್ > 150 ಆಗಿದ್ದರೆ:

            # ಒಳ ಇದ್ದರೆ ಬ್ಲಾಕ್

    ಮುದ್ರಣ ("ಅಭಿನಂದನೆಗಳು, ನೀವು ಸಾಲವನ್ನು ಸ್ವೀಕರಿಸಿದ್ದೀರಿ")

ಬೇರೆ:

    ಪ್ರಿಂಟ್ ("ಕ್ಷಮಿಸಿ, ನೀವು ಸಾಲಕ್ಕೆ ಅರ್ಹರಲ್ಲ")

ಈ ಪ್ರೋಗ್ರಾಂ ಕ್ರೆಡಿಟ್ ರೇಟಿಂಗ್ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡುತ್ತದೆ. ಇದು 70 ಕ್ಕಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ, ಬಳಕೆದಾರರು ಕ್ರೆಡಿಟ್‌ಗೆ ಅರ್ಹರಲ್ಲ ಎಂದು ಪ್ರೋಗ್ರಾಂ ವರದಿ ಮಾಡುತ್ತದೆ. ಅದು ಹೆಚ್ಚಿದ್ದರೆ, ಪ್ರಸ್ತುತ ಕ್ರೆಡಿಟ್ ಮಿತಿಯು 150 ಕ್ಕಿಂತ ಹೆಚ್ಚಿದೆಯೇ ಎಂದು ನೋಡಲು ಎರಡನೇ ಪರಿಶೀಲನೆಯನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ. ಹೌದು ಎಂದಾದರೆ, ಸಾಲವನ್ನು ನೀಡಲಾಗಿದೆ ಎಂಬ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ಎರಡೂ ಮೌಲ್ಯಗಳು ತಪ್ಪಾಗಿದ್ದರೆ, ಬಳಕೆದಾರರು ಸಾಲವನ್ನು ಪಡೆಯುವ ಸಾಧ್ಯತೆಯನ್ನು ಹೊಂದಿಲ್ಲ ಎಂಬ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. 

ಈಗ ಆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಪುನಃ ಮಾಡೋಣ.

gre_score = int(ಇನ್‌ಪುಟ್ ("ಪ್ರಸ್ತುತ ಮಿತಿಯನ್ನು ನಮೂದಿಸಿ: "))

per_grad = ಇಂಟ್ (ಇನ್‌ಪುಟ್ ("ಕ್ರೆಡಿಟ್ ಸ್ಕೋರ್ ನಮೂದಿಸಿ: "))

per_grad > 70:

    ಗ್ರೇ_ಸ್ಕೋರ್ > 150 ಆಗಿದ್ದರೆ:

        ಮುದ್ರಣ ("ಅಭಿನಂದನೆಗಳು, ನೀವು ಸಾಲವನ್ನು ಸ್ವೀಕರಿಸಿದ್ದೀರಿ")

    ಬೇರೆ:

        ಪ್ರಿಂಟ್ ("ನಿಮ್ಮ ಕ್ರೆಡಿಟ್ ಮಿತಿ ಕಡಿಮೆಯಾಗಿದೆ")

ಬೇರೆ:

    ಪ್ರಿಂಟ್ ("ಕ್ಷಮಿಸಿ, ನೀವು ಕ್ರೆಡಿಟ್‌ಗೆ ಅರ್ಹರಲ್ಲ")

ಕೋಡ್ ಸ್ವತಃ ಹೋಲುತ್ತದೆ, ಆದರೆ ನೆಸ್ಟೆಡ್ if ಅದರ ಸ್ಥಿತಿಯು ತಪ್ಪಾಗಿ ಹೊರಹೊಮ್ಮಿದರೆ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಸಹ ಒದಗಿಸುತ್ತದೆ. ಅಂದರೆ, ಕಾರ್ಡ್‌ನಲ್ಲಿನ ಮಿತಿಯು ಸಾಕಷ್ಟಿಲ್ಲ, ಆದರೆ ಕ್ರೆಡಿಟ್ ಇತಿಹಾಸವು ಉತ್ತಮವಾಗಿದೆ, "ನಿಮಗೆ ಕಡಿಮೆ ಕ್ರೆಡಿಟ್ ರೇಟಿಂಗ್ ಇದೆ" ಎಂಬ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

if-else ಒಂದು ಷರತ್ತು ಒಳಗೆ ಹೇಳಿಕೆ ಬೇರೆ

ಪರೀಕ್ಷಾ ಅಂಕಗಳ ಆಧಾರದ ಮೇಲೆ ವಿದ್ಯಾರ್ಥಿಯ ಗ್ರೇಡ್ ಅನ್ನು ನಿರ್ಧರಿಸುವ ಇನ್ನೊಂದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮಾಡೋಣ.

ಸ್ಕೋರ್ = ಇಂಟ್ (ಇನ್‌ಪುಟ್ ("ನಿಮ್ಮ ಸ್ಕೋರ್ ನಮೂದಿಸಿ: "))

ಸ್ಕೋರ್ >= 90 ಆಗಿದ್ದರೆ:

    ಪ್ರಿಂಟ್ ("ಶ್ರೇಷ್ಠ! ನಿಮ್ಮ ಗ್ರೇಡ್ A")

ಬೇರೆ:

    ಸ್ಕೋರ್ >= 80 ಆಗಿದ್ದರೆ:

ಪ್ರಿಂಟ್ ("ಗ್ರೇಟ್! ನಿಮ್ಮ ಗ್ರೇಡ್ ಬಿ")

    ಬೇರೆ:

ಸ್ಕೋರ್ >= 70 ಆಗಿದ್ದರೆ:

    ಪ್ರಿಂಟ್ ("ಒಳ್ಳೆಯದು! ನಿಮ್ಮ ಗ್ರೇಡ್ ಸಿ")

ಬೇರೆ:

    ಸ್ಕೋರ್ >= 60 ಆಗಿದ್ದರೆ:

ಪ್ರಿಂಟ್ (“ನಿಮ್ಮ ಗ್ರೇಡ್ ಡಿ. ಇದು ವಿಷಯವನ್ನು ಪುನರಾವರ್ತಿಸಲು ಯೋಗ್ಯವಾಗಿದೆ.”)

    ಬೇರೆ:

ಮುದ್ರಣ ("ನೀವು ಪರೀಕ್ಷೆಯಲ್ಲಿ ವಿಫಲರಾಗಿದ್ದೀರಿ")

ಸ್ಕೋರ್ 90 ಕ್ಕಿಂತ ಹೆಚ್ಚಿದೆಯೇ ಅಥವಾ ಸಮಾನವಾಗಿದೆಯೇ ಎಂದು ನೋಡಲು ಅಪ್ಲಿಕೇಶನ್ ಮೊದಲು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹೌದು ಎಂದಾದರೆ, ಅದು A ಗ್ರೇಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ಸ್ಥಿತಿಯು ತಪ್ಪಾಗಿದ್ದರೆ, ನಂತರದ ತಪಾಸಣೆಗಳನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ. ಮೊದಲ ನೋಟದಲ್ಲಿ ಅಲ್ಗಾರಿದಮ್ ಬಹುತೇಕ ಒಂದೇ ಆಗಿರುವುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ. ಆದ್ದರಿಂದ ಒಳಗೆ ಪರಿಶೀಲಿಸುವ ಬದಲು ಬೇರೆ ಸಂಯೋಜನೆಯನ್ನು ಬಳಸುವುದು ಉತ್ತಮ ವೇಳೆ-ಎಲಿಫ್-ಬೇರೆ.

ಆದ್ದರಿಂದ ಆಪರೇಟರ್ if ಬಹಳ ಮುಖ್ಯವಾದ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ - ಇದು ಅಗತ್ಯವಿದ್ದಲ್ಲಿ ಮಾತ್ರ ಕೆಲವು ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಅದು ಇಲ್ಲದೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳುವುದು ಅಸಾಧ್ಯ, ಏಕೆಂದರೆ ಸರಳವಾದ ಅಲ್ಗಾರಿದಮ್‌ಗಳಿಗೆ ಸಹ "ನೀವು ಎಡಕ್ಕೆ ಹೋದರೆ, ನೀವು ಅದನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೀರಿ, ಮತ್ತು ನೀವು ಬಲಕ್ಕೆ ಹೋದರೆ, ನೀವು ಇದನ್ನು ಮತ್ತು ಅದನ್ನು ಮಾಡಬೇಕಾಗಿದೆ" ನಂತಹ ಫೋರ್ಕ್‌ಗಳು ಬೇಕಾಗುತ್ತವೆ.

ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ