લૂપ પ્રોસેસિંગ માટે પાયથોન ડિક્શનરી (ડિક્ટ): કી(), વેલ્યુ(), આઈટમ()

પાયથોન ડિક્શનરી ઑબ્જેક્ટના ઘટકોને a for સ્ટેટમેન્ટ સાથે લૂપ કરવા માટે, શબ્દકોશ ઑબ્જેક્ટ પર નીચેની પદ્ધતિનો ઉપયોગ કરો, જેને શબ્દકોશમાંની બધી કી અને મૂલ્યોની સૂચિ મેળવવા માટે list() સાથે પણ જોડી શકાય છે.

• 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 વર્ગ પરત કરે છે. જો તમે યાદી બનાવવા માંગો છો, તો તમે list() ફંક્શનનો ઉપયોગ કરી શકો છો.

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():દરેક તત્વ મૂલ્ય માટે લૂપ પ્રોસેસિંગ માટે

જો તમે દરેક એલિમેન્ટ વેલ્યુ માટે ફોર-લૂપ પ્રોસેસિંગ કરવા માંગો છો, તો values() પદ્ધતિનો ઉપયોગ કરો.

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

મૂલ્યો() પદ્ધતિ dict_values ​​વર્ગ પરત કરે છે. જો તમે યાદી બનાવવા માંગો છો, તો તમે list() ફંક્શનનો ઉપયોગ કરી શકો છો.

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)આમ, તે ટ્યુપલ તરીકે પ્રાપ્ત કરી શકાય છે.

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 વર્ગ પરત કરે છે. જો તમે યાદી બનાવવા માંગો છો, તો તમે list() ફંક્શનનો ઉપયોગ કરી શકો છો. દરેક તત્વ એક ટ્યુપલ છે.
(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 સેટ ઓપરેશન્સ પણ કરી શકે છે.