పైథాన్ ఆర్డర్ డిక్షనరీ అయిన OrderedDict ను ఎలా ఉపయోగించాలి.

వ్యాపారం

పైథాన్ నిఘంటువులు (టైప్ డిక్ట్ యొక్క వస్తువులు) మూలకాల క్రమాన్ని భద్రపరచవు; CPython 3.6 నుండి అలా చేసింది, అయితే ఇది ఇతర అమలులలో అమలుపై ఆధారపడి ఉంటుంది మరియు నిరవధికంగా ఉంటుంది; భాష స్పెసిఫికేషన్ 3.7 నుండి ఆర్డర్‌ను భద్రపరచింది.

ఆర్డర్‌ని భద్రపరిచే నిఘంటువు వలె ప్రామాణిక లైబ్రరీ యొక్క సేకరణల మాడ్యూల్‌లో OrderedDict అందించబడింది. దీన్ని ఉపయోగించడం సురక్షితం.

సేకరణల మాడ్యూల్‌ను దిగుమతి చేయండి. ఇది ప్రామాణిక లైబ్రరీలో చేర్చబడింది మరియు ఇన్‌స్టాల్ చేయవలసిన అవసరం లేదు.

import collections

మీరు కింది వాటిని వ్రాసినట్లయితే, మీరు సేకరణలను వదిలివేయవచ్చు. క్రింది ఉదాహరణలలో.

from collections import OrderedDict

OrderedDictని ఎలా ఉపయోగించాలో క్రింది వివరణ ఉంది.

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

OrderedDict ఆబ్జెక్ట్‌ను సృష్టిస్తోంది

కన్స్ట్రక్టర్ సేకరణలు.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

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

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 కూడా డిక్ట్ వలె అదే పద్ధతులను కలిగి ఉంది మరియు మూలకాలను పొందడం, మార్చడం, జోడించడం మరియు తొలగించడం వంటి పద్ధతులు డిక్ట్ వలె ఉంటాయి.

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)])

వివరాల కోసం క్రింది కథనాన్ని చూడండి.

మూలకాలను ప్రారంభం లేదా ముగింపుకు తరలించండి

మూలకాన్ని ప్రారంభం లేదా ముగింపుకు తరలించడానికి మీరు 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. జాబితా()ని ఉపయోగించి ఐటెమ్() పద్ధతితో పొందగలిగే వీక్షణ వస్తువులను జాబితా చేయండి.
  2. జాబితా యొక్క ఇన్సర్ట్() పద్ధతిలో కీ-విలువ జతల యొక్క టుపుల్ (కీ, విలువ)ని జోడించండి
  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. జాబితా()ని ఉపయోగించి ఐటెమ్() పద్ధతితో పొందగలిగే వీక్షణ వస్తువులను జాబితా చేయండి.
  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)])

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

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()కి పంపండి.

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

మీరు క్రమాన్ని రివర్స్ చేయాలనుకుంటే, క్రమబద్ధీకరించబడిన() యొక్క రివర్స్ ఆర్గ్యుమెంట్‌ను ఒప్పుకు సెట్ చేయండి.

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)])