ಪೈಥಾನ್‌ನಲ್ಲಿ 'ಫಾರ್' ಲೂಪ್‌ಗಳೊಂದಿಗೆ ಡಿಕ್ಷನರಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಪೈಥಾನ್ ನಿಘಂಟುಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆ

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

ಸ್ಪಷ್ಟಪಡಿಸಲು, 'ಫಾರ್' ಲೂಪ್‌ನಲ್ಲಿರುವ 'ಕೀ' ವಿಶೇಷ ಕೀವರ್ಡ್ ಅಲ್ಲ ಆದರೆ ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ನಿಘಂಟಿನಲ್ಲಿರುವ ಪ್ರತಿ ಕೀಲಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ವೇರಿಯಬಲ್ ಆಗಿದೆ. ಸ್ಪಷ್ಟ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಪೈಥಾನ್ ಕೋಡ್ ಬರೆಯಲು ಈ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಈ ಲೇಖನದಲ್ಲಿ, ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ಪೈಥಾನ್ ನಿಘಂಟು ಕೀಗಳನ್ನು ಹೇಗೆ ಗುರುತಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

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

ಒದಗಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಪೈಥಾನ್‌ನಲ್ಲಿ ಡಿಕ್ಷನರಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ವಿವರಿಸುತ್ತದೆ. ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಸರಳವನ್ನು ಬಳಸುತ್ತದೆ for ನಿಘಂಟಿನ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಲು ಲೂಪ್ d. ಪ್ರತಿ ಪುನರಾವರ್ತನೆಗೆ, ವೇರಿಯಬಲ್ key ನಿಘಂಟಿನಲ್ಲಿರುವ ಒಂದು ಕೀಲಿಯ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅನುಗುಣವಾದ ಮೌಲ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರವೇಶಿಸಲಾಗುತ್ತದೆ d[key]. ಈ ವಿಧಾನವು ಸರಳವಾಗಿದೆ ಮತ್ತು ಮೂಲಭೂತ ಕೀ-ಮೌಲ್ಯ ಮರುಪಡೆಯುವಿಕೆಗೆ ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುತ್ತದೆ items() ವಿಧಾನ, ಇದು ನಿಘಂಟಿನ ಕೀ-ಮೌಲ್ಯದ ಟುಪಲ್ ಜೋಡಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪ್ರದರ್ಶಿಸುವ ವೀಕ್ಷಣೆ ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಬಳಸಿಕೊಂಡು for key, value in d.items(), ಸ್ಕ್ರಿಪ್ಟ್ ಒಂದೇ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳೆರಡನ್ನೂ ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು, ಇದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಓದಬಲ್ಲದು.

ಮೂರನೇ ಲಿಪಿಯಲ್ಲಿ, ದಿ keys() ನಿಘಂಟಿನಲ್ಲಿರುವ ಎಲ್ಲಾ ಕೀಗಳ ವೀಕ್ಷಣೆ ವಸ್ತುವನ್ನು ಪಡೆಯಲು ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ನಂತರ ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಪಟ್ಟಿಯಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ list() ಕಾರ್ಯ. ಈ ಪಟ್ಟಿಯನ್ನು ಪುನರಾವರ್ತನೆ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಪ್ರತಿ ಕೀಲಿಯನ್ನು ನಿಘಂಟಿನಿಂದ ಅನುಗುಣವಾದ ಮೌಲ್ಯವನ್ನು ಹಿಂಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ. ನೀವು ಪ್ರತ್ಯೇಕವಾಗಿ ಕೀಲಿಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ಅಥವಾ ಪ್ರವೇಶಿಸಲು ಅಗತ್ಯವಿರುವಾಗ ಈ ವಿಧಾನವು ಉಪಯುಕ್ತವಾಗಿದೆ. ನಾಲ್ಕನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ def print_dict(d) ಅದು ನಿಘಂಟನ್ನು ವಾದವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದರ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಈ ರೀತಿಯ ಕಾರ್ಯಗಳು ತರ್ಕವನ್ನು ಎನ್ಕ್ಯಾಪ್ಸುಲೇಟ್ ಮಾಡಲು ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, ಐದನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ list() ಮತ್ತು range() ಒಂದು ಸೂಚ್ಯಂಕದೊಂದಿಗೆ ನಿಘಂಟಿನ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಕಾರ್ಯಗಳು. ದಿ len() ಕೀಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ಧರಿಸಲು ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳೆರಡಕ್ಕೂ ಸೂಚ್ಯಂಕ ಪ್ರವೇಶವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಸೂಚ್ಯಂಕ ಕಾರ್ಯಾಚರಣೆಗಳು ಅಥವಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳು ಅಗತ್ಯವಿರುವ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಈ ವಿಧಾನವು ಸಹಾಯಕವಾಗಬಹುದು.

d = {'x': 1, 'y': 2, 'z': 3}
for key in d:
    print(key, 'corresponds to', d[key])

d = {'x': 1, 'y': 2, 'z': 3}
for key, value in d.items():
    print(f'{key} corresponds to {value}')

d = {'x': 1, 'y': 2, 'z': 3}
keys = d.keys()
for key in keys:
    print(f'Key: {key} -> Value: {d[key]}')

def print_dict(d):
    for key in d:
        print(f'{key} corresponds to {d[key]}')

d = {'x': 1, 'y': 2, 'z': 3}
print_dict(d)

d = {'x': 1, 'y': 2, 'z': 3}
keys = list(d.keys())
for i in range(len(keys)):
    print(f'{keys[i]} corresponds to {d[keys[i]]}')

ಡಿಕ್ಷನರಿ ಪುನರಾವರ್ತನೆಗೆ ಆಳವಾಗಿ ಡೈವಿಂಗ್

ಪೈಥಾನ್‌ನಲ್ಲಿ ಡಿಕ್ಷನರಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯ ಮತ್ತೊಂದು ನಿರ್ಣಾಯಕ ಅಂಶವೆಂದರೆ ವಿಭಿನ್ನ ವಿಧಾನಗಳು ಮತ್ತು ಅವುಗಳ ಬಳಕೆಯ ಸಂದರ್ಭಗಳನ್ನು ಸರಳವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು for ಕುಣಿಕೆಗಳು. ಉದಾಹರಣೆಗೆ, ದಿ dict.get() ಕೀಲಿಯು ಕಂಡುಬರದಿದ್ದರೆ ಕೀಲೋಪವನ್ನು ಹೆಚ್ಚಿಸದೆ ನಿಘಂಟಿನಿಂದ ಮೌಲ್ಯಗಳನ್ನು ಹಿಂಪಡೆಯಲು ನೀವು ಬಯಸಿದಾಗ ವಿಧಾನವು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ. ನಿಘಂಟಿನಲ್ಲಿ ಕೀಲಿಯು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಹಿಂತಿರುಗಲು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಈ ವಿಧಾನವು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಬಳಸಿ dict.get(key, default), ನೀವು ಕಾಣೆಯಾದ ಕೀಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ನಿಭಾಯಿಸಬಹುದು, ಇದು ಡೇಟಾ ಸಂಸ್ಕರಣೆ ಮತ್ತು ಅಪೂರ್ಣ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಅವಶ್ಯಕವಾಗಿದೆ.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಿಘಂಟು ಗ್ರಹಿಕೆಗಳು ಪುನರಾವರ್ತನೀಯ ಡೇಟಾದಿಂದ ನಿಘಂಟುಗಳನ್ನು ರಚಿಸಲು ಸಂಕ್ಷಿಪ್ತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಲಿಸ್ಟ್ ಕಾಂಪ್ರಹೆನ್ಷನ್‌ಗಳಂತೆಯೇ, ನಿಘಂಟು ಗ್ರಹಿಕೆಗಳು ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತವೆ {key: value for item in iterable}. ನಿಘಂಟುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿವರ್ತಿಸಲು ಅಥವಾ ಫಿಲ್ಟರ್ ಮಾಡಲು ಈ ವಿಧಾನವು ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ. ಮತ್ತೊಂದು ಸುಧಾರಿತ ತಂತ್ರವು ಒಳಗೊಂಡಿರುತ್ತದೆ defaultdict ನಿಂದ ವರ್ಗ collections ಘಟಕ. ಅಂತರ್ನಿರ್ಮಿತ ನಿಘಂಟಿನ ಈ ಉಪವರ್ಗವು ನಿಘಂಟಿಗಾಗಿ ಡೀಫಾಲ್ಟ್ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ int ಅಥವಾ list. ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಕೀಲಿಯನ್ನು ಪ್ರವೇಶಿಸಿದಾಗ, defaultdict ಡಿಫಾಲ್ಟ್ ಪ್ರಕಾರದೊಂದಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಮೂದನ್ನು ರಚಿಸುತ್ತದೆ, ಇದು ನಿಘಂಟು ನಮೂದುಗಳ ಪ್ರಾರಂಭದ ಅಗತ್ಯವಿರುವ ಕೋಡಿಂಗ್ ಮಾದರಿಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.