ಪರಿವಿಡಿ[ಮರೆಮಾಡಿ][ತೋರಿಸಿ]
ನಾವು ಲೂಪ್ ಮಾಡುವಾಗ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ಪೈಥಾನ್ನಲ್ಲಿ ಆಸಕ್ತಿದಾಯಕ ಊಹೆಯ ಆಟವನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ ಮುನ್ನಡೆಯುತ್ತೇವೆ.
ಹಿಂದಿನ ಎಲ್ಲಾ ಪರಿಕಲ್ಪನೆಗಳು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತವೆ ಆದ್ದರಿಂದ ಮತ್ತಷ್ಟು ಚಲಿಸುವ ಮೊದಲು ಹಿಂದಿನ ಉಪನ್ಯಾಸಗಳನ್ನು ಪರಿಷ್ಕರಿಸಲು ನಾನು ನಿಮಗೆ ಶಿಫಾರಸು ಮಾಡುತ್ತೇನೆ.
ಅದರಲ್ಲಿ ಧುಮುಕೋಣ.
ಲೂಪ್ಸ್ ಮಾಡುವಾಗ
ಪೈಥಾನ್ನಲ್ಲಿ ಲೂಪ್ಗಳನ್ನು ಹೇಗೆ ಬಳಸಬೇಕೆಂದು ನಾವು ಕಲಿಯಲಿದ್ದೇವೆ. ಕೋಡ್ನ ಬ್ಲಾಕ್ ಅನ್ನು ಹಲವಾರು ಬಾರಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಾವು ಲೂಪ್ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಅವು ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಕ್ರಮಗಳು ಮತ್ತು ಆಟಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಾಮಾನ್ಯವಾಗಿ ಉಪಯುಕ್ತವಾಗಿವೆ.
ಆದ್ದರಿಂದ, ಮೂಲಭೂತ ವಿಷಯಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ಸ್ವಲ್ಪ ಸಮಯದ ಲೂಪ್ ಅನ್ನು ಬರೆಯಲು, ನಾವು "ವೇಳೆ" ಕಾರ್ಯದ ನಂತರ ಸ್ಥಿತಿಯನ್ನು ಬರೆಯುತ್ತೇವೆ.
ವೇರಿಯೇಬಲ್ "i" ಅನ್ನು ಪರಿಚಯಿಸೋಣ ಮತ್ತು ಅದನ್ನು 1 ಗೆ ಹೊಂದಿಸೋಣ
i = 1
while i <= 5:
print(i)
ಈಗ, "i" ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸದಿದ್ದರೆ ಮೇಲಿನ ಲೂಪ್ ಅನಂತ ಲೂಪ್ ಆಗಿರುವುದರಿಂದ "i" ಅನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಲಾಗುತ್ತದೆ.
i = i + 1
ಮೇಲಿನ ಸ್ಥಿತಿಯು ನಿಜವಾಗುವವರೆಗೆ ಈ ಪ್ರೋಗ್ರಾಂ "i" ನ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. "i" ನ ಮೌಲ್ಯವು 5 ಕ್ಕಿಂತ ಹೆಚ್ಚಾದ ತಕ್ಷಣ, ಲೂಪ್ ಒಡೆಯುತ್ತದೆ.
ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಯಾವುದೇ ಇಂಡೆಂಟ್ ಇಲ್ಲದೆ ಇನ್ನೊಂದು ಹೇಳಿಕೆಯನ್ನು ಸೇರಿಸಲು ನನಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡಿ.
print("done")
ಇದು ಇಂಡೆಂಟ್ ಆಗದ ಕಾರಣ, ಲೂಪ್ನೊಂದಿಗೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ.
ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:
ಸ್ವಲ್ಪವೇ ಲೂಪ್ನೊಂದಿಗೆ ಆಡೋಣ.
"i" ನೊಂದಿಗೆ ಗುಣಿಸುವ "ನಕ್ಷತ್ರ" ದೊಂದಿಗೆ ನಾನು ಲೂಪ್ನಲ್ಲಿ ಮತ್ತೊಂದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸೇರಿಸುತ್ತಿದ್ದೇನೆ. ಇದು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಮೇಲೆ ಹೇಗೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.
i = 1
while i <= 5:
print('*' * i)
ಈಗ, ನಕ್ಷತ್ರ ಚಿಹ್ನೆಗಳ ಸಂಖ್ಯೆ 5 ಮೀರುವವರೆಗೆ ನಕ್ಷತ್ರ ಚಿಹ್ನೆಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.
ಈಗ, ನಾವು ಲೂಪ್ ಅನ್ನು ಬಳಸಲು ಹಾಕುತ್ತಿದ್ದೇವೆ. ಊಹಿಸುವ ಆಟವನ್ನು ನಿರ್ಮಿಸೋಣ.
ಲೂಪ್ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆಟವನ್ನು ಊಹಿಸುವುದು
ಪರಿಕಲ್ಪನೆಯು ಪ್ರೋಗ್ರಾಂ ತನ್ನ ಮೆಮೊರಿಯಲ್ಲಿ ರಹಸ್ಯ ಸಂಖ್ಯೆಯನ್ನು ಉಳಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಊಹಿಸಲು ನಮ್ಮನ್ನು ಕೇಳುತ್ತದೆ. ಆ ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಲು ನಾವು 3 ಪ್ರಯತ್ನಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ನೀವು ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಿದರೆ, ನಿಮ್ಮನ್ನು ಅಭಿನಂದಿಸಲಾಗುತ್ತದೆ. ನಾವು ನಮ್ಮ ತಲೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸೋಣ.
ನಮ್ಮ ರಹಸ್ಯ ಸಂಖ್ಯೆಗಾಗಿ ನಾವು ವೇರಿಯಬಲ್ ಅನ್ನು ಪರಿಚಯಿಸುತ್ತಿದ್ದೇವೆ.
secret_number = 6
ಈಗ, ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಲು ಬಳಕೆದಾರರನ್ನು ಪದೇ ಪದೇ ಕೇಳಲು ನಾವು ಸ್ವಲ್ಪ ಸಮಯದ ಲೂಪ್ ಅನ್ನು ಬರೆಯಬೇಕಾಗಿದೆ. ಅದಕ್ಕೂ ಮೊದಲು, ಅನುಮತಿಸಲಾದ ಪ್ರಯತ್ನಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿಸಲು ನಾವು ಇನ್ನೊಂದು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪರಿಚಯಿಸಬೇಕಾಗಿದೆ.
guess_count = 0
while guess_count < 3:
guess = int(input('guess: '))
guess_count +=1
if guess == secret_number
print("Congratulations! You won")
ಈ ಪ್ರೋಗ್ರಾಂ ಬಳಕೆದಾರರಿಂದ ಪೂರ್ಣಾಂಕದ ಇನ್ಪುಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದನ್ನು "ಊಹೆ" ನಲ್ಲಿ ಉಳಿಸುತ್ತದೆ. ಅದು ನಂತರ ಅದನ್ನು ರಹಸ್ಯ_ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಹೋಲಿಸುತ್ತದೆ ಹೋಲಿಕೆ ಆಪರೇಟರ್ ಮತ್ತು ಎರಡೂ ಸಮಾನವಾಗಿದ್ದರೆ, ಅದು ಹಿಂತಿರುಗುತ್ತದೆ “ಅಭಿನಂದನೆಗಳು!
ನೀನು ಗೆದ್ದೆ". ಆದರೆ ಈ ಪ್ರೋಗ್ರಾಂ ಕೆಲವು ನ್ಯೂನತೆಗಳನ್ನು ಹೊಂದಿದೆ. ಮೊದಲ ಪ್ರಯತ್ನದಲ್ಲಿ ನೀವು ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಿದರೆ, ನಿಮ್ಮನ್ನು ಅಭಿನಂದಿಸಿದ ನಂತರ ಇನ್ನೂ ಎರಡು ಬಾರಿ ಊಹಿಸಲು ಅದು ನಿಮ್ಮನ್ನು ಕೇಳುತ್ತದೆ. ಲೂಪ್ ಅನ್ನು ಮುರಿಯಲು "ಬ್ರೇಕ್" ಹೇಳಿಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಬಹುದು.
ಒಮ್ಮೆ ನೋಡಿ!
ಈಗ, ನಾವು ಮೂರು ಪ್ರಯತ್ನಗಳಲ್ಲಿ ಸಂಖ್ಯೆಯನ್ನು ಊಹಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ "ಬೇರೆ" ಹೇಳಿಕೆಯನ್ನು ಸೇರಿಸಲಿದ್ದೇವೆ.
ಈಗ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು while ಲೂಪ್ನಿಂದ ಬೇರೆ ಹೇಳಿಕೆಯನ್ನು ಸೇರಿಸುತ್ತೇವೆ, ಅದು if ಸ್ಟೇಟ್ಮೆಂಟ್ನೊಂದಿಗೆ ಲೂಪ್ ಅನ್ನು ಒಡೆಯದಿದ್ದರೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.
ಇದು ನಿಮಗೆ ಮೋಜಿನ ಚಟುವಟಿಕೆಯಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಪೈಥಾನ್ನಲ್ಲಿ ಪ್ರವೀಣರಾಗಲು ನೀವು ಇದೇ ರೀತಿಯ ಚಟುವಟಿಕೆಗಳಲ್ಲಿ ನಿಮ್ಮನ್ನು ತೊಡಗಿಸಿಕೊಳ್ಳಬಹುದು.
ಅಂತಿಮಗೊಳಿಸು
ಇದು ಈ ಉಪನ್ಯಾಸದ ಅಂತ್ಯವಾಗಿತ್ತು. ನೀವು ಇಲ್ಲಿಯವರೆಗೆ ಅದನ್ನು ಆನಂದಿಸಿದ್ದೀರಿ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಮುಂದಿನದರಲ್ಲಿ ನಿಮ್ಮನ್ನು ಭೇಟಿಯಾಗುತ್ತೇನೆ. ಅಲ್ಲಿಯವರೆಗೆ ಅಭ್ಯಾಸ ಮಾಡುತ್ತಿರಿ.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ