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 dict ਦਾ ਇੱਕ ਉਪ-ਕਲਾਸ ਹੈ
• ਤੱਤਾਂ ਨੂੰ ਸ਼ੁਰੂ ਜਾਂ ਅੰਤ ਵਿੱਚ ਭੇਜੋ
• ਕਿਸੇ ਵੀ ਸਥਿਤੀ ‘ਤੇ ਇੱਕ ਨਵਾਂ ਤੱਤ ਸ਼ਾਮਲ ਕਰੋ।
• ਤੱਤਾਂ ਨੂੰ ਮੁੜ ਵਿਵਸਥਿਤ ਕਰੋ (ਮੁੜ ਕ੍ਰਮਬੱਧ)
• ਕੁੰਜੀ ਜਾਂ ਮੁੱਲ ਦੁਆਰਾ ਤੱਤਾਂ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰੋ

ਇੱਕ 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

ਸਾਧਾਰਨ ਸ਼ਬਦਕੋਸ਼ (ਡਿਕਟ ਟਾਈਪ ਆਬਜੈਕਟ) ਵੀ ਕੰਸਟਰਕਟਰ ਨੂੰ ਪਾਸ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਪਰ ਲਾਗੂ ਕਰਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਜਿੱਥੇ ਡਿਕਟ ਕਿਸਮ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਰੱਖਦੀ, ਇਸ ਤੋਂ ਤਿਆਰ ਕੀਤੀ ਆਰਡਰਡਿਕਟ ਵੀ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਰੱਖੇਗੀ।

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

OrderedDict dict ਦਾ ਇੱਕ ਉਪ-ਕਲਾਸ ਹੈ

OrderedDict dict ਦਾ ਇੱਕ ਉਪ-ਕਲਾਸ ਹੈ।

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

ਵੇਰਵਿਆਂ ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ।

• ਸੰਬੰਧਿਤ ਲੇਖ:ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ ਤੱਤ ਜੋੜਨਾ ਅਤੇ ਪਾਇਥਨ ਵਿੱਚ ਸ਼ਬਦਕੋਸ਼ਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣਾ

ਤੱਤਾਂ ਨੂੰ ਸ਼ੁਰੂ ਜਾਂ ਅੰਤ ਵਿੱਚ ਭੇਜੋ

ਤੁਸੀਂ ਕਿਸੇ ਤੱਤ ਨੂੰ ਸ਼ੁਰੂਆਤ ਜਾਂ ਅੰਤ ਵਿੱਚ ਲਿਜਾਣ ਲਈ 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)])

ਕਿਸੇ ਵੀ ਸਥਿਤੀ ‘ਤੇ ਇੱਕ ਨਵਾਂ ਤੱਤ ਸ਼ਾਮਲ ਕਰੋ।

ਆਰਬਿਟਰੇਰੀ ਪੋਜੀਸ਼ਨ ‘ਤੇ ਨਵੇਂ ਐਲੀਮੈਂਟ ਦੇ ਨਾਲ ਇੱਕ ਨਵਾਂ ਆਰਡਰਡਿਕਟ ਆਬਜੈਕਟ ਬਣਾਉਣਾ ਸੰਭਵ ਹੈ। ਖਾਸ ਤੌਰ ‘ਤੇ, ਇਹ ਹੇਠਲੇ ਪ੍ਰਵਾਹ ਵਿੱਚ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ.

1. ਸੂਚੀ () ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਈਟਮਾਂ() ਵਿਧੀ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾ ਸਕਣ ਵਾਲੇ ਵਿਊ ਆਬਜੈਕਟ ਦੀ ਸੂਚੀ ਬਣਾਓ।
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. ਸੂਚੀ () ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਈਟਮਾਂ() ਵਿਧੀ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾ ਸਕਣ ਵਾਲੇ ਵਿਊ ਆਬਜੈਕਟ ਦੀ ਸੂਚੀ ਬਣਾਓ।
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() ਦੀ ਆਰਗੂਮੈਂਟ ਕੁੰਜੀ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਟੂਪਲ (ਕੁੰਜੀ, ਮੁੱਲ) ਤੋਂ ਇੱਕ ਕੁੰਜੀ ਜਾਂ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਕ੍ਰਮ ਨੂੰ ਉਲਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ sorted() ਦੇ ਉਲਟ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸਹੀ ‘ਤੇ ਸੈੱਟ ਕਰੋ।

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