ਜੇਕਰ ਤੁਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀ (ਐਰੇ) ਦੇ ਤੱਤਾਂ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ (ਬੇਤਰਤੀਬ ਢੰਗ ਨਾਲ ਕ੍ਰਮਬੱਧ) ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਇੱਥੇ ਦੋ ਫੰਕਸ਼ਨ ਹਨ: shuffle(), ਜੋ ਬੇਤਰਤੀਬੇ ਤੌਰ ‘ਤੇ ਮੂਲ ਸੂਚੀ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਦਾ ਹੈ, ਅਤੇ ਨਮੂਨਾ (), ਜੋ ਕਿ ਇੱਕ ਨਵੀਂ ਬੇਤਰਤੀਬੇ ਕ੍ਰਮਬੱਧ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸੈਂਪਲ() ਨੂੰ ਸਟ੍ਰਿੰਗਸ ਅਤੇ ਟੂਪਲਸ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
- ਮੂਲ ਸੂਚੀ ਨੂੰ ਬਦਲੋ:
random.shuffle() - ਇੱਕ ਨਵੀਂ, ਬਦਲੀ ਹੋਈ ਸੂਚੀ ਬਣਾਓ।:
random.sample() - ਤਾਰਾਂ ਅਤੇ ਟੂਪਲਾਂ ਨੂੰ ਸ਼ਫਲ ਕਰੋ
- ਬੇਤਰਤੀਬ ਨੰਬਰ ਬੀਜ ਨੂੰ ਠੀਕ ਕਰੋ
ਜੇਕਰ ਤੁਸੀਂ ਬੇਤਰਤੀਬ ਜਾਂ ਉਲਟ ਕ੍ਰਮ ਦੀ ਬਜਾਏ ਵੱਧਦੇ ਜਾਂ ਘਟਦੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।
ਮੂਲ ਸੂਚੀ ਨੂੰ ਬਦਲੋ:random.shuffle()
ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਵਿੱਚ ਫੰਕਸ਼ਨ shuffle() ਮੂਲ ਸੂਚੀ ਨੂੰ ਬੇਤਰਤੀਬ ਢੰਗ ਨਾਲ ਕ੍ਰਮਬੱਧ ਕਰ ਸਕਦਾ ਹੈ।
import random
l = list(range(5))
print(l)
# [0, 1, 2, 3, 4]
random.shuffle(l)
print(l)
# [1, 0, 4, 3, 2]
ਇੱਕ ਨਵੀਂ, ਬਦਲੀ ਹੋਈ ਸੂਚੀ ਬਣਾਓ।:random.sample()
ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਵਿੱਚ ਫੰਕਸ਼ਨ ਨਮੂਨਾ() ਦੀ ਵਰਤੋਂ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜੋ ਬੇਤਰਤੀਬ ਢੰਗ ਨਾਲ ਲੜੀਬੱਧ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਮੂਲ ਸੂਚੀ ਨੂੰ ਬਦਲੇ ਬਿਨਾਂ।
ਨਮੂਨਾ () ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਬੇਤਰਤੀਬੇ ਤੌਰ ‘ਤੇ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਤੱਤ ਨੂੰ ਚੁਣਦਾ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਪਹਿਲੀ ਦਲੀਲ ਇੱਕ ਸੂਚੀ ਹੈ, ਅਤੇ ਦੂਜਾ ਆਰਗੂਮੈਂਟ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਹੈ। ਵੇਰਵਿਆਂ ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ।
ਜੇਕਰ ਸੈਂਪਲ() ਦੁਆਰਾ ਚੁਣੇ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਹੈ, ਤਾਂ ਸਾਨੂੰ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਮਿਲਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਬੇਤਰਤੀਬੇ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ len() ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਮੂਲ ਵਸਤੂ ਨੂੰ ਬਦਲਿਆ ਨਹੀਂ ਜਾਵੇਗਾ।
l = list(range(5))
print(l)
# [0, 1, 2, 3, 4]
lr = random.sample(l, len(l))
print(lr)
# [0, 3, 1, 4, 2]
print(l)
# [0, 1, 2, 3, 4]
ਤਾਰਾਂ ਅਤੇ ਟੂਪਲਾਂ ਨੂੰ ਸ਼ਫਲ ਕਰੋ
ਸਤਰ ਅਤੇ ਟੂਪਲ ਅਟੱਲ ਹਨ, ਇਸਲਈ ਜੇਕਰ ਤੁਸੀਂ ਮੂਲ ਵਸਤੂ ਨੂੰ ਬਦਲਣ ਲਈ random.shuffle() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਗਲਤੀ ਮਿਲੇਗੀ।TypeError
s = 'abcde'
# random.shuffle(s)
# TypeError: 'str' object does not support item assignment
t = tuple(range(5))
print(t)
# (0, 1, 2, 3, 4)
# random.shuffle(t)
# TypeError: 'tuple' object does not support item assignment
ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਤਰ ਜਾਂ ਟੂਪਲ ਨੂੰ ਸ਼ਫਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ random.sample() ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜੋ ਇੱਕ ਨਵਾਂ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ।
ਇੱਥੋਂ ਤੱਕ ਕਿ ਜਦੋਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਜਾਂ ਟੂਪਲ ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, random.sample() ਇੱਕ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਇਸਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਜਾਂ ਟੂਪਲ ‘ਤੇ ਵਾਪਸ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ।
ਇੱਕ ਸਤਰ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਹ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਅੱਖਰਾਂ ਦੀ ਸੂਚੀ ਹੋਵੇਗੀ। ਉਹਨਾਂ ਨੂੰ ਦੁਬਾਰਾ ਇੱਕ ਸਿੰਗਲ ਸਤਰ ਵਿੱਚ ਜੋੜਨ ਲਈ, join() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।
sr = ''.join(random.sample(s, len(s)))
print(sr)
# bedca
tuples ਲਈ, tuple() ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜੋ ਇੱਕ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਟੂਪਲ ਬਣਾਉਂਦਾ ਹੈ।
tr = tuple(random.sample(t, len(l)))
print(tr)
# (0, 1, 2, 4, 3)
ਬੇਤਰਤੀਬ ਨੰਬਰ ਬੀਜ ਨੂੰ ਠੀਕ ਕਰੋ
ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਦੇ ਫੰਕਸ਼ਨ ਸੀਡ() ਨੂੰ ਇੱਕ ਆਰਬਿਟਰਰੀ ਪੂਰਨ ਅੰਕ ਦੇ ਕੇ, ਬੇਤਰਤੀਬ ਸੰਖਿਆ ਦੇ ਬੀਜ ਨੂੰ ਸਥਿਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਬੇਤਰਤੀਬ ਸੰਖਿਆ ਜਨਰੇਟਰ ਨੂੰ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਉਸੇ ਬੀਜ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇਸਨੂੰ ਹਮੇਸ਼ਾ ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਮੁੜ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
l = list(range(5))
random.seed(0)
random.shuffle(l)
print(l)
# [2, 1, 0, 4, 3]
l = list(range(5))
random.seed(0)
random.shuffle(l)
print(l)
# [2, 1, 0, 4, 3]
