ಪೈಥಾನ್ ಲೂಪ್‌ನಲ್ಲಿ ಸೂಚ್ಯಂಕವನ್ನು ಹೇಗೆ ಪ್ರವೇಶಿಸುವುದು

ಪೈಥಾನ್ ಲೂಪ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು:

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

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

ಪೈಥಾನ್ ಲೂಪ್ ಇಂಡೆಕ್ಸಿಂಗ್‌ನ ವಿವರವಾದ ವಿವರಣೆ

ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ನಾವು ಬಳಸುತ್ತೇವೆ enumerate() ಪಟ್ಟಿಯ ಮೂಲಕ ಲೂಪ್ ಮಾಡಲು ಕಾರ್ಯ xs ಏಕಕಾಲದಲ್ಲಿ ಸೂಚ್ಯಂಕವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವಾಗ. ದಿ start ನ ವಾದ enumerate() 1ಕ್ಕೆ ಹೊಂದಿಸಲಾಗಿದೆ, ಡೀಫಾಲ್ಟ್ 0 ಬದಲಿಗೆ ಸೂಚ್ಯಂಕವು 1 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. enumerate() ಕಾರ್ಯವು ಜೋಡಿ ಸೂಚ್ಯಂಕ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಅದನ್ನು ನಾವು ಅನ್ಪ್ಯಾಕ್ ಮಾಡುತ್ತೇವೆ index ಮತ್ತು x ಲೂಪ್ ಹೆಡರ್ನಲ್ಲಿ. ದಿ print ಫಂಕ್ಷನ್ ನಂತರ ಈ ಮೌಲ್ಯಗಳನ್ನು ಅಪೇಕ್ಷಿತ ಔಟ್‌ಪುಟ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಅನುಗುಣವಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ.

ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಸೂಚ್ಯಂಕವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ಮೂಲಕ ಅದೇ ಫಲಿತಾಂಶವನ್ನು ಸಾಧಿಸುತ್ತದೆ. ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ index ಲೂಪ್ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲು 1 ಗೆ. ಲೂಪ್ ಒಳಗೆ, ನಾವು ಪ್ರಸ್ತುತ ಸೂಚ್ಯಂಕ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಬಳಸಿ ಮುದ್ರಿಸುತ್ತೇವೆ format ತಂತಿಗಳ ವಿಧಾನ, ಮತ್ತು ನಂತರ ಹೆಚ್ಚಳ index 1 ಮೂಲಕ += ಆಪರೇಟರ್. ಮೂರನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುತ್ತದೆ range() ಮತ್ತು len() 1 ರಿಂದ ಉದ್ದದವರೆಗಿನ ಸೂಚ್ಯಂಕ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಚಲಿಸುವ ಲೂಪ್ ಅನ್ನು ರಚಿಸಲು xs. ಲೂಪ್ ಒಳಗೆ, ನಾವು ಬಳಸಿ ಪಟ್ಟಿ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇವೆ xs[index - 1] ಪ್ರತಿ ಸೂಚ್ಯಂಕಕ್ಕೆ ಸರಿಯಾದ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು.

xs = [8, 23, 45]
for index, x in enumerate(xs, start=1):
    print("item #{} = {}".format(index, x))

xs = [8, 23, 45]
index = 1
for x in xs:
    print("item #{} = {}".format(index, x))
    index += 1

xs = [8, 23, 45]
for index in range(1, len(xs) + 1):
    print("item #{} = {}".format(index, xs[index - 1]))

ಪರ್ಯಾಯ ಇಂಡೆಕ್ಸಿಂಗ್ ವಿಧಾನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

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

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