లూప్ ప్రాసెసింగ్ కోసం పైథాన్ నిఘంటువు (డిక్ట్): కీలు(), విలువలు(), అంశాలు()

స్టేట్‌మెంట్ కోసం పైథాన్ డిక్షనరీ ఆబ్జెక్ట్‌లోని మూలకాల ద్వారా లూప్ చేయడానికి, డిక్షనరీ ఆబ్జెక్ట్‌పై కింది పద్ధతిని ఉపయోగించండి, డిక్షనరీలోని అన్ని కీలు మరియు విలువల జాబితాను పొందేందుకు జాబితా()తో కూడా కలపవచ్చు.

• keys():ప్రతి మూలకం కీ కోసం లూప్ ప్రాసెసింగ్ కోసం
• values():ప్రతి మూలకం విలువ కోసం లూప్ ప్రాసెసింగ్ కోసం
• items():ప్రతి మూలకం యొక్క కీ మరియు విలువ కోసం లూప్ ప్రాసెసింగ్ కోసం

కింది నిఘంటువు వస్తువు ఒక ఉదాహరణ.

d = {'key1': 1, 'key2': 2, 'key3': 3}

డిక్షనరీ ఆబ్జెక్ట్‌ని ఫర్ స్టేట్‌మెంట్‌గా మార్చడం ద్వారా కీలను పొందవచ్చు.

for k in d:
    print(k)
# key1
# key2
# key3

keys():ప్రతి మూలకం కీ కోసం లూప్ ప్రాసెసింగ్ కోసం

పైన చెప్పినట్లుగా, డిక్షనరీ ఆబ్జెక్ట్‌ని ఫర్ స్టేట్‌మెంట్‌లో ఉన్నట్లుగా తిప్పడం ద్వారా కీలను పొందవచ్చు, కానీ కీస్() పద్ధతిని కూడా ఉపయోగించవచ్చు.

for k in d.keys():
    print(k)
# key1
# key2
# key3

కీలు() పద్ధతి dict_keys తరగతిని అందిస్తుంది. మీరు జాబితాను తయారు చేయాలనుకుంటే, మీరు జాబితా() ఫంక్షన్‌ని ఉపయోగించవచ్చు.

keys = d.keys()
print(keys)
print(type(keys))
# dict_keys(['key1', 'key2', 'key3'])
# <class 'dict_keys'>

k_list = list(d.keys())
print(k_list)
print(type(k_list))
# ['key1', 'key2', 'key3']
# <class 'list'>

DICT_KEYS సెట్ ఆపరేషన్‌లను చేయగలదు.

values():ప్రతి మూలకం విలువ కోసం లూప్ ప్రాసెసింగ్ కోసం

మీరు ప్రతి మూలకం విలువ కోసం లూప్ ప్రాసెసింగ్ చేయాలనుకుంటే, విలువలు() పద్ధతిని ఉపయోగించండి.

for v in d.values():
    print(v)
# 1
# 2
# 3

విలువలు() పద్ధతి dict_values ​​తరగతిని అందిస్తుంది. మీరు జాబితాను తయారు చేయాలనుకుంటే, మీరు జాబితా() ఫంక్షన్‌ని ఉపయోగించవచ్చు.

values = d.values()
print(values)
print(type(values))
# dict_values([1, 2, 3])
# <class 'dict_values'>

v_list = list(d.values())
print(v_list)
print(type(v_list))
# [1, 2, 3]
# <class 'list'>

విలువలు అతివ్యాప్తి చెందవచ్చు కాబట్టి, dict_values ​​యొక్క సెట్ ఆపరేషన్‌కు మద్దతు లేదు.

items():ప్రతి మూలకం యొక్క కీ మరియు విలువ కోసం లూప్ ప్రాసెసింగ్ కోసం

మీరు ప్రతి మూలకం యొక్క కీ మరియు విలువ రెండింటి కోసం లూప్ ప్రక్రియను నిర్వహించాలనుకుంటే, అంశాలను() పద్ధతిని ఉపయోగించండి.

for k, v in d.items():
    print(k, v)
# key1 1
# key2 2
# key3 3

(key, value)అందువలన, ఇది ఒక tuple గా స్వీకరించవచ్చు.

for t in d.items():
    print(t)
    print(type(t))
    print(t[0])
    print(t[1])
    print('---')
# ('key1', 1)
# <class 'tuple'>
# key1
# 1
# ---
# ('key2', 2)
# <class 'tuple'>
# key2
# 2
# ---
# ('key3', 3)
# <class 'tuple'>
# key3
# 3
# ---

అంశాలు() పద్ధతి dict_items తరగతిని అందిస్తుంది. మీరు జాబితాను తయారు చేయాలనుకుంటే, మీరు జాబితా() ఫంక్షన్‌ని ఉపయోగించవచ్చు. ప్రతి మూలకం ఒక టుపుల్.
(key, value)

items = d.items()
print(items)
print(type(items))
# dict_items([('key1', 1), ('key2', 2), ('key3', 3)])
# <class 'dict_items'>

i_list = list(d.items())
print(i_list)
print(type(i_list))
# [('key1', 1), ('key2', 2), ('key3', 3)]
# <class 'list'>

print(i_list[0])
print(type(i_list[0]))
# ('key1', 1)
# <class 'tuple'>

DICT_ITEMS సెట్ కార్యకలాపాలను కూడా చేయగలదు.