OrderedDict નો ઉપયોગ કેવી રીતે કરવો, પાયથોન ઓર્ડર કરેલ શબ્દકોશ.

પાયથોન શબ્દકોશો (પ્રકારના ડિક્ટના ઑબ્જેક્ટ્સ) તત્વોના ક્રમને સાચવતા નથી; CPython 3.6 થી આમ કરે છે, પરંતુ તે અમલીકરણ આધારિત છે અને અન્ય અમલીકરણોમાં અનિશ્ચિત છે; ભાષા સ્પષ્ટીકરણે 3.7 થી ઓર્ડર જાળવી રાખ્યો છે.

OrderedDict પ્રમાણભૂત પુસ્તકાલયના સંગ્રહ મોડ્યુલમાં એક શબ્દકોશ તરીકે પ્રદાન કરવામાં આવે છે જે ઓર્ડરને સાચવે છે. આનો ઉપયોગ કરવો સલામત છે.

• OrderedDict — collections — Container datatypes — Python 3.10.0 Documentation

સંગ્રહ મોડ્યુલ આયાત કરો. તે પ્રમાણભૂત પુસ્તકાલયમાં શામેલ છે અને તેને ઇન્સ્ટોલ કરવાની જરૂર નથી.

import collections

જો તમે નીચેના લખો છો, તો તમે સંગ્રહોને છોડી શકો છો. નીચેના ઉદાહરણોમાં.

from collections import OrderedDict

નીચે OrderedDict નો ઉપયોગ કેવી રીતે કરવો તેનું વર્ણન છે.

• OrderedDict ઑબ્જેક્ટ બનાવવું
• OrderedDict એ ડિક્ટનો પેટા વર્ગ છે
• તત્વોને શરૂઆત અથવા અંતમાં ખસેડો
• કોઈપણ સ્થાન પર એક નવું તત્વ ઉમેરો.
• તત્વોને ફરીથી ગોઠવો (પુનઃક્રમાંકિત કરો).
• કી અથવા મૂલ્ય દ્વારા તત્વોને સૉર્ટ કરો

OrderedDict ઑબ્જેક્ટ બનાવવું

Constructor collections.OrderedDict() નો ઉપયોગ OrderedDict ઑબ્જેક્ટ બનાવવા માટે થઈ શકે છે.

એક ખાલી OrderedDict ઑબ્જેક્ટ બનાવો અને મૂલ્યો ઉમેરો.

od = collections.OrderedDict()

od['k1'] = 1
od['k2'] = 2
od['k3'] = 3

print(od)
# OrderedDict([('k1', 1), ('k2', 2), ('k3', 3)])

કન્સ્ટ્રક્ટરને દલીલો સ્પષ્ટ કરવી પણ શક્ય છે.

તમે કીવર્ડ દલીલોનો ઉપયોગ કરી શકો છો, કી-વેલ્યુ જોડીના સિક્વન્સ (જેમ કે ટ્યુપલ્સ (કી, મૂલ્ય)), વગેરે. જ્યાં સુધી તે કી-વેલ્યુ જોડી હોય ત્યાં સુધી બાદમાં સૂચિ અથવા ટ્યુપલ હોઈ શકે છે.

print(collections.OrderedDict(k1=1, k2=2, k3=3))
print(collections.OrderedDict([('k1', 1), ('k2', 2), ('k3', 3)]))
print(collections.OrderedDict((['k1', 1], ['k2', 2], ['k3', 3])))
# OrderedDict([('k1', 1), ('k2', 2), ('k3', 3)])
# OrderedDict([('k1', 1), ('k2', 2), ('k3', 3)])
# OrderedDict([('k1', 1), ('k2', 2), ('k3', 3)])

સંસ્કરણ 3.5 સુધી, કીવર્ડ દલીલોનો ક્રમ સાચવવામાં આવ્યો ન હતો, પરંતુ સંસ્કરણ 3.6 થી, તે હવે સાચવેલ છે.

સંસ્કરણ 3.6 માં બદલાયેલ છે: PEP 468 ની સ્વીકૃતિ સાથે, OrderedDict કન્સ્ટ્રક્ટરનો ક્રમ અને અપડેટ() પદ્ધતિને પાસ કરેલ કીવર્ડ દલીલો સાચવવામાં આવે છે.
collections — Container datatypes — Python 3.10.0 Documentation

સામાન્ય શબ્દકોશો (ડિક્ટ ટાઈપ ઑબ્જેક્ટ્સ) પણ કન્સ્ટ્રક્ટરને પસાર કરી શકાય છે, પરંતુ અમલીકરણના કિસ્સામાં જ્યાં ડિક્ટ પ્રકાર ક્રમને સાચવતો નથી, તેમાંથી બનાવેલ OrderedDict પણ ઓર્ડરને સાચવશે નહીં.

print(collections.OrderedDict({'k1': 1, 'k2': 2, 'k3': 3}))
# OrderedDict([('k1', 1), ('k2', 2), ('k3', 3)])

OrderedDict એ ડિક્ટનો પેટા વર્ગ છે

OrderedDict એ ડિક્ટનો પેટા વર્ગ છે.

print(issubclass(collections.OrderedDict, dict))
# True

OrderedDict પણ dict જેવી જ પદ્ધતિઓ ધરાવે છે, અને તત્વો મેળવવા, બદલવા, ઉમેરવા અને દૂર કરવા માટેની પદ્ધતિઓ dict જેવી જ છે.

print(od['k1'])
# 1

od['k2'] = 200
print(od)
# OrderedDict([('k1', 1), ('k2', 200), ('k3', 3)])

od.update(k4=4, k5=5)
print(od)
# OrderedDict([('k1', 1), ('k2', 200), ('k3', 3), ('k4', 4), ('k5', 5)])

del od['k4'], od['k5']
print(od)
# OrderedDict([('k1', 1), ('k2', 200), ('k3', 3)])

વિગતો માટે નીચેનો લેખ જુઓ.

• સંબંધિત લેખો:શબ્દકોશમાં ઘટકો ઉમેરવા અને Python માં શબ્દકોશમાં જોડાવા

તત્વોને શરૂઆત અથવા અંતમાં ખસેડો

તત્વને શરૂઆત અથવા અંતમાં ખસેડવા માટે તમે OrderedDict ની પોતાની પદ્ધતિ move_to_end() નો ઉપયોગ કરી શકો છો.

પ્રથમ દલીલ તરીકે કીનો ઉલ્લેખ કરો. ડિફૉલ્ટ અંત તરફ જવાનું છે, પરંતુ જો છેલ્લી બીજી દલીલ ખોટી હોય, તો તેને શરૂઆતમાં ખસેડવામાં આવશે.

od.move_to_end('k1')
print(od)
# OrderedDict([('k2', 200), ('k3', 3), ('k1', 1)])

od.move_to_end('k1', False)
print(od)
# OrderedDict([('k1', 1), ('k2', 200), ('k3', 3)])

કોઈપણ સ્થાન પર એક નવું તત્વ ઉમેરો.

મનસ્વી સ્થિતિમાં ઉમેરવામાં આવેલા નવા ઘટક સાથે નવો OrderedDict ઑબ્જેક્ટ બનાવવાનું શક્ય છે. ખાસ કરીને, આ નીચેના પ્રવાહમાં કરી શકાય છે.

1. વ્યુ ઑબ્જેક્ટ્સની સૂચિ બનાવો જે list() નો ઉપયોગ કરીને આઇટમ() પદ્ધતિથી મેળવી શકાય છે.
2. સૂચિની insert() પદ્ધતિમાં કી-વેલ્યુ જોડીનો ટુપલ (કી, મૂલ્ય) ઉમેરો
3. તેને કન્સ્ટ્રક્ટર કલેક્શનમાં મોકલીને નવો ઑબ્જેક્ટ બનાવો. OrderedDict()

l = list(od.items())
print(l)
# [('k1', 1), ('k2', 200), ('k3', 3)]

l.insert(1, ('kx', -1))
print(l)
# [('k1', 1), ('kx', -1), ('k2', 200), ('k3', 3)]

od = collections.OrderedDict(l)
print(od)
# OrderedDict([('k1', 1), ('kx', -1), ('k2', 200), ('k3', 3)])

insert() એ પ્રથમ દલીલ તરીકે દાખલ કરવાની સ્થિતિ અને બીજી દલીલ તરીકે દાખલ કરવા માટેનું તત્વ સ્પષ્ટ કરે છે.

ઉદાહરણમાં, એક નવો ઑબ્જેક્ટ મૂળ ચલને અસાઇન કરવામાં આવે છે, અને મૂળ ઑબ્જેક્ટમાં જ કોઈ નવા ઘટકો ઉમેરવામાં આવતાં નથી.

તત્વોને ફરીથી ગોઠવો (પુનઃક્રમાંકિત કરો).

તત્વોને બદલવું એ ઉપરના ઉદાહરણની જેમ જ પ્રક્રિયા છે.

1. વ્યુ ઑબ્જેક્ટ્સની સૂચિ બનાવો જે list() નો ઉપયોગ કરીને આઇટમ() પદ્ધતિથી મેળવી શકાય છે.
2. સૂચિમાં ઘટકો બદલો
3. તેને કન્સ્ટ્રક્ટર કલેક્શનમાં મોકલીને નવો ઑબ્જેક્ટ બનાવો. OrderedDict()

l = list(od.items())
print(l)
# [('k1', 1), ('kx', -1), ('k2', 200), ('k3', 3)]

l[0], l[2] = l[2], l[0]
print(l)
# [('k2', 200), ('kx', -1), ('k1', 1), ('k3', 3)]

od = collections.OrderedDict(l)
print(od)
# OrderedDict([('k2', 200), ('kx', -1), ('k1', 1), ('k3', 3)])

જો તમે કીનો ઉલ્લેખ કરવા અને તેને બદલવા માંગતા હો, તો નીચે બતાવ્યા પ્રમાણે કીની યાદીમાંથી ઇન્ડેક્સ (પોઝિશન) મેળવવા માટે index() પદ્ધતિનો ઉપયોગ કરો.

l = list(od.items())
k = list(od.keys())
print(k)
# ['k2', 'kx', 'k1', 'k3']

print(k.index('kx'))
# 1

l[k.index('kx')], l[k.index('k3')] = l[k.index('k3')], l[k.index('kx')]
print(l)
# [('k2', 200), ('k3', 3), ('k1', 1), ('kx', -1)]

od = collections.OrderedDict(l)
print(od)
# OrderedDict([('k2', 200), ('k3', 3), ('k1', 1), ('kx', -1)])

કી અથવા મૂલ્ય દ્વારા તત્વોને સૉર્ટ કરો

વ્યુ ઑબ્જેક્ટના આધારે સૉર્ટ કરેલ કી-વેલ્યુ જોડીના ટ્યુપલ્સ (કી, મૂલ્ય) ની સૂચિ બનાવો જે વસ્તુઓ() પદ્ધતિ દ્વારા મેળવી શકાય છે, અને નવો ઑબ્જેક્ટ બનાવવા માટે તેને કન્સ્ટ્રક્ટર કલેક્શન્સ. OrderedDict() પર મોકલો.

સૉર્ટિંગ એક અનામી ફંક્શન (લેમ્બડા એક્સપ્રેશન) નો ઉલ્લેખ કરીને કરવામાં આવે છે જે બિલ્ટ-ઇન ફંક્શન સોર્ટેડ() ની દલીલ કી તરીકે ટ્યુપલ (કી, મૂલ્ય) માંથી કી અથવા મૂલ્ય પરત કરે છે.

જો તમે ઓર્ડરને રિવર્સ કરવા માંગો છો, તો sorted() ની રિવર્સ દલીલને true પર સેટ કરો.

print(od)
# OrderedDict([('k2', 200), ('k3', 3), ('k1', 1), ('kx', -1)])

od_sorted_key = collections.OrderedDict(
    sorted(od.items(), key=lambda x: x[0])
)
print(od_sorted_key)
# OrderedDict([('k1', 1), ('k2', 200), ('k3', 3), ('kx', -1)])

od_sorted_value = collections.OrderedDict(
    sorted(od.items(), key=lambda x: x[1], reverse=True)
)
print(od_sorted_value)
# OrderedDict([('k2', 200), ('k3', 3), ('k1', 1), ('kx', -1)])