പൈത്തണിലെ 'ഫോർ' ലൂപ്പുകൾ ഉപയോഗിച്ച് നിഘണ്ടു ആവർത്തനം മനസ്സിലാക്കുന്നു

പൈത്തൺ നിഘണ്ടുകളിലൂടെ ആവർത്തിക്കുന്നു

പൈത്തണിൽ, നിഘണ്ടുക്കൾ, കീ-വാല്യൂ ജോഡികൾ സംഭരിക്കാൻ ഡവലപ്പർമാരെ അനുവദിക്കുന്ന ബഹുമുഖ ഡാറ്റാ ഘടനകളാണ്. ഈ നിഘണ്ടുക്കളിൽ ആവർത്തിക്കുന്നത് 'ഫോർ' ലൂപ്പുകൾ ഉപയോഗിച്ച് കാര്യക്ഷമമായി ചെയ്യാൻ കഴിയുന്ന ഒരു സാധാരണ ജോലിയാണ്. ഈ പ്രക്രിയ നേരായതായി തോന്നിയേക്കാം, പക്ഷേ ലൂപ്പിനുള്ളിലെ ഘടകങ്ങളെ പൈത്തൺ എങ്ങനെ വ്യാഖ്യാനിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള ചോദ്യങ്ങൾ ഉയർത്തുന്നു, പ്രത്യേകിച്ച് 'കീ' പോലുള്ള വേരിയബിളുകളുടെ പങ്ക്.

വ്യക്തമാക്കുന്നതിന്, 'ഫോർ' ലൂപ്പിലെ 'കീ' എന്നത് ഒരു പ്രത്യേക കീവേഡല്ല, മറിച്ച് ആവർത്തന സമയത്ത് നിഘണ്ടുവിലെ ഓരോ കീയും എടുക്കുന്ന ഒരു വേരിയബിളാണ്. വ്യക്തവും ഫലപ്രദവുമായ പൈത്തൺ കോഡ് എഴുതുന്നതിന് ഈ ആശയം മനസ്സിലാക്കുന്നത് നിർണായകമാണ്. ഈ ലേഖനത്തിൽ, ആവർത്തന സമയത്ത് പൈത്തൺ നിഘണ്ടു കീകൾ എങ്ങനെ തിരിച്ചറിയുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു എന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും.

നിഘണ്ടു ആവർത്തന സാങ്കേതിക വിദ്യകൾ മനസ്സിലാക്കുന്നു

പൈത്തണിലെ നിഘണ്ടുക്കളിലൂടെ ആവർത്തിക്കുന്നതിനുള്ള വ്യത്യസ്ത രീതികൾ നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ ചിത്രീകരിക്കുന്നു. ആദ്യ സ്ക്രിപ്റ്റ് ഒരു ലളിതമായ ഉപയോഗിക്കുന്നു 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() ഒരു നിഘണ്ടുവിൽ നിന്ന് മൂല്യങ്ങൾ വീണ്ടെടുക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ, കീ കണ്ടെത്തിയില്ലെങ്കിൽ, ഒരു KeyError ഉന്നയിക്കാതെ തന്നെ ഈ രീതി ഉപയോഗപ്രദമാകും. നിഘണ്ടുവിൽ കീ നിലവിലില്ലെങ്കിൽ തിരികെ നൽകുന്നതിന് സ്ഥിരസ്ഥിതി മൂല്യം വ്യക്തമാക്കാൻ ഈ രീതി നിങ്ങളെ അനുവദിക്കുന്നു. ഉപയോഗിക്കുന്നത് dict.get(key, default), നിങ്ങൾക്ക് നഷ്‌ടമായ കീകൾ സുരക്ഷിതമായി കൈകാര്യം ചെയ്യാൻ കഴിയും, ഇത് ഡാറ്റ പ്രോസസ്സിംഗിനും അപൂർണ്ണമായ ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിനും അത്യാവശ്യമാണ്.

കൂടാതെ, ആവർത്തിക്കാവുന്ന ഡാറ്റയിൽ നിന്ന് നിഘണ്ടുക്കൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു സംക്ഷിപ്ത മാർഗം നിഘണ്ടു മനസ്സിലാക്കലുകൾ നൽകുന്നു. ലിസ്റ്റ് കോംപ്രിഹെൻഷനുകൾ പോലെ, നിഘണ്ടു ഗ്രഹണങ്ങൾ വാക്യഘടന ഉപയോഗിക്കുന്നു {key: value for item in iterable}. നിഘണ്ടുക്കൾ കാര്യക്ഷമമായി രൂപാന്തരപ്പെടുത്തുന്നതിനോ ഫിൽട്ടർ ചെയ്യുന്നതിനോ ഈ രീതി പ്രയോജനകരമാണ്. മറ്റൊരു നൂതന സാങ്കേതികത ഉൾപ്പെടുന്നു defaultdict മുതൽ ക്ലാസ് collections മൊഡ്യൂൾ. ബിൽറ്റ്-ഇൻ നിഘണ്ടുവിലെ ഈ ഉപവിഭാഗം, നിഘണ്ടുവിനായി ഒരു സ്ഥിരസ്ഥിതി തരം വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. int അഥവാ list. നിലവിലില്ലാത്ത ഒരു കീ ആക്സസ് ചെയ്യുമ്പോൾ, defaultdict ഡിഫോൾട്ട് തരം ഉപയോഗിച്ച് സ്വയമേവ ഒരു എൻട്രി സൃഷ്ടിക്കുന്നു, ഇത് നിഘണ്ടു എൻട്രികൾ ആരംഭിക്കേണ്ട കോഡിംഗ് പാറ്റേണുകൾ ലളിതമാക്കുന്നു.