ਪਾਈਥਨ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਵਿੱਚ ਫੰਕਸ਼ਨਾਂ ਦੀ ਚੋਣ(), ਨਮੂਨਾ(), ਅਤੇ ਵਿਕਲਪਾਂ () ਨੂੰ ਸੂਚੀ, ਟੂਪਲ, ਸਟ੍ਰਿੰਗ, ਜਾਂ ਹੋਰ ਕ੍ਰਮ ਵਸਤੂ (ਰੈਂਡਮ ਸੈਂਪਲਿੰਗ) ਤੋਂ ਬੇਤਰਤੀਬ ਢੰਗ ਨਾਲ ਚੁਣਨ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
choice() ਇੱਕ ਸਿੰਗਲ ਐਲੀਮੈਂਟ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਸੈਂਪਲ() ਅਤੇ ਵਿਕਲਪ() ਨੂੰ ਕਈ ਤੱਤਾਂ ਦੀ ਸੂਚੀ ਮਿਲਦੀ ਹੈ। ਨਮੂਨਾ() ਬਿਨਾਂ ਕਿਸੇ ਡੁਪਲੀਕੇਟ ਦੇ ਗੈਰ-ਰਿਕਵਰੇਬਲ ਐਕਸਟਰੈਕਸ਼ਨ ਹੈ, ਵਿਕਲਪਾਂ () ਡੁਪਲੀਕੇਟ ਨਾਲ ਰਿਕਵਰੀਯੋਗ ਐਕਸਟਰੈਕਸ਼ਨ ਹੈ।
ਹੇਠਾਂ ਦਿੱਤੀ ਜਾਣਕਾਰੀ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ।
- ਬੇਤਰਤੀਬੇ ਇੱਕ ਤੱਤ ਦੀ ਚੋਣ ਕਰੋ.:
random.choice() - ਬੇਤਰਤੀਬੇ ਕਈ ਤੱਤਾਂ ਦੀ ਚੋਣ ਕਰੋ (ਕੋਈ ਡੁਪਲੀਕੇਟ ਨਹੀਂ):
random.sample() - ਬੇਤਰਤੀਬੇ ਕਈ ਤੱਤਾਂ ਦੀ ਚੋਣ ਕਰੋ (ਡੁਪਲੀਕੇਟ ਦੇ ਨਾਲ):
random.choices() - ਬੇਤਰਤੀਬ ਨੰਬਰ ਬੀਜ ਨੂੰ ਠੀਕ ਕਰੋ
ਬੇਤਰਤੀਬੇ ਇੱਕ ਤੱਤ ਦੀ ਚੋਣ ਕਰੋ.:random.choice()
ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਦੇ ਫੰਕਸ਼ਨ choose() ਦੇ ਨਾਲ, ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਤੱਤ ਨੂੰ ਬੇਤਰਤੀਬ ਢੰਗ ਨਾਲ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
import random
l = [0, 1, 2, 3, 4]
print(random.choice(l))
# 1
ਇਹੀ ਟੂਪਲਾਂ ਅਤੇ ਤਾਰਾਂ ‘ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਸਤਰ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇੱਕ ਸਿੰਗਲ ਅੱਖਰ ਚੁਣਿਆ ਗਿਆ ਹੈ.
print(random.choice(('xxx', 'yyy', 'zzz')))
# yyy
print(random.choice('abcde'))
# b
ਗਲਤੀ ਜੇਕਰ ਇੱਕ ਖਾਲੀ ਸੂਚੀ, ਟੂਪਲ, ਜਾਂ ਸਤਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤੀ ਗਈ ਹੈ।
# print(random.choice([]))
# IndexError: Cannot choose from an empty sequence
ਬੇਤਰਤੀਬੇ ਕਈ ਤੱਤਾਂ ਦੀ ਚੋਣ ਕਰੋ (ਕੋਈ ਡੁਪਲੀਕੇਟ ਨਹੀਂ):random.sample()
ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਦੇ ਫੰਕਸ਼ਨ ਨਮੂਨੇ () ਦੇ ਨਾਲ, ਤੁਸੀਂ ਇੱਕ ਸੂਚੀ ਵਿੱਚੋਂ ਬੇਤਰਤੀਬੇ ਵਿੱਚ ਕਈ ਤੱਤ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ। ਤੱਤਾਂ ਦੀ ਕੋਈ ਡੁਪਲੀਕੇਸ਼ਨ ਨਹੀਂ ਹੈ (ਨਾਨ-ਰਿਕਵਰੇਬਲ ਐਕਸਟਰੈਕਸ਼ਨ)।
ਪਹਿਲੀ ਦਲੀਲ ਇੱਕ ਸੂਚੀ ਹੈ, ਅਤੇ ਦੂਜਾ ਆਰਗੂਮੈਂਟ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਹੈ। ਸੂਚੀ ਵਾਪਸ ਕਰ ਦਿੱਤੀ ਗਈ ਹੈ।
import random
l = [0, 1, 2, 3, 4]
print(random.sample(l, 3))
# [2, 4, 0]
print(type(random.sample(l, 3)))
# <class 'list'>
ਜੇਕਰ ਦੂਜੀ ਆਰਗੂਮੈਂਟ 1 ‘ਤੇ ਸੈੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇੱਕ ਤੱਤ ਵਾਲੀ ਸੂਚੀ ਵੀ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਜੇਕਰ ਇਹ 0 ‘ਤੇ ਸੈੱਟ ਹੈ, ਤਾਂ ਸੂਚੀ ਖਾਲੀ ਹੈ। ਜੇਕਰ ਦੂਜੀ ਆਰਗੂਮੈਂਟ 1 ਹੈ, ਤਾਂ ਇੱਕ ਤੱਤ ਵਾਲੀ ਸੂਚੀ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਜੇਕਰ ਇਹ 0 ਹੈ, ਤਾਂ ਇੱਕ ਖਾਲੀ ਸੂਚੀ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਜੇਕਰ ਪਹਿਲੀ ਆਰਗੂਮੈਂਟ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਤੋਂ ਵੱਧ ਹੈ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਆਉਂਦੀ ਹੈ।
print(random.sample(l, 1))
# [3]
print(random.sample(l, 0))
# []
# print(random.sample(l, 10))
# ValueError: Sample larger than population or is negative
ਜੇਕਰ ਪਹਿਲੀ ਆਰਗੂਮੈਂਟ ਇੱਕ ਟੂਪਲ ਜਾਂ ਇੱਕ ਸਤਰ ਹੈ, ਤਾਂ ਜੋ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਉਹ ਅਜੇ ਵੀ ਇੱਕ ਸੂਚੀ ਹੈ।
print(random.sample(('xxx', 'yyy', 'zzz'), 2))
# ['xxx', 'yyy']
print(random.sample('abcde', 2))
# ['b', 'e']
ਜੇਕਰ ਤੁਸੀਂ ਟੂਪਲ ਜਾਂ ਸਟ੍ਰਿੰਗ ‘ਤੇ ਵਾਪਸ ਜਾਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ tuple(), join() ਦੀ ਵਰਤੋਂ ਕਰੋ।
print(tuple(random.sample(('xxx', 'yyy', 'zzz'), 2)))
# ('xxx', 'yyy')
print(''.join(random.sample('abcde', 2)))
# dc
ਨੋਟ ਕਰੋ ਕਿ ਮੁੱਲ ਦਾ ਨਿਰਣਾ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ ਜੇਕਰ ਮੂਲ ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਵਿੱਚ ਸਮਾਨ ਮੁੱਲ ਵਾਲੇ ਤੱਤ ਸ਼ਾਮਲ ਹਨ, ਤਾਂ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਉਹੀ ਮੁੱਲ ਚੁਣਿਆ ਜਾਵੇਗਾ।
l_dup = [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3]
print(random.sample(l_dup, 3))
# [3, 1, 1]
ਜੇ ਤੁਸੀਂ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਤੋਂ ਬਚਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਨੂੰ ਸੈੱਟ (ਸੈੱਟ ਕਿਸਮ) ਵਿੱਚ ਬਦਲਣ ਲਈ ਸੈੱਟ() ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਸਿਰਫ਼ ਵਿਲੱਖਣ ਤੱਤ ਕੱਢ ਸਕਦੇ ਹੋ, ਅਤੇ ਫਿਰ ਸੈਂਪਲ() ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।
print(set(l_dup))
# {0, 1, 2, 3}
print(random.sample(set(l_dup), 3))
# [1, 3, 2]
ਬੇਤਰਤੀਬੇ ਕਈ ਤੱਤਾਂ ਦੀ ਚੋਣ ਕਰੋ (ਡੁਪਲੀਕੇਟ ਦੇ ਨਾਲ):random.choices()
ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਦੇ ਫੰਕਸ਼ਨ ਵਿਕਲਪਾਂ () ਤੁਹਾਨੂੰ ਸੂਚੀ ਤੋਂ ਬੇਤਰਤੀਬੇ ਤੌਰ ‘ਤੇ ਕਈ ਤੱਤਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਨਮੂਨੇ () ਦੇ ਉਲਟ, ਇਹ ਡੁਪਲੀਕੇਟ ਤੱਤਾਂ ਨੂੰ ਚੁਣਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।
choices() ਪਾਈਥਨ 3.6 ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ। ਇਹ ਪੁਰਾਣੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਉਪਲਬਧ ਨਹੀਂ ਹੈ।
ਆਰਗੂਮੈਂਟ k ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਡੁਪਲੀਕੇਸ਼ਨ ਦੀ ਇਜਾਜ਼ਤ ਹੈ, ਇਸਲਈ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਅਸਲ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਤੋਂ ਵੱਧ ਹੋ ਸਕਦੀ ਹੈ।
ਕਿਉਂਕਿ k ਇੱਕ ਕੀਵਰਡ-ਓਨਲੀ ਆਰਗੂਮੈਂਟ ਹੈ, ਇਸ ਲਈ ਇੱਕ ਕੀਵਰਡ ਨਿਰਧਾਰਤ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ, ਜਿਵੇਂ ਕਿ k=3।
import random
l = [0, 1, 2, 3, 4]
print(random.choices(l, k=3))
# [2, 1, 0]
print(random.choices(l, k=10))
# [3, 4, 1, 4, 4, 2, 0, 4, 2, 0]
k ਦਾ ਮੂਲ ਮੁੱਲ 1 ਹੈ; ਜੇਕਰ ਇਸਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ 1 ਤੱਤ ਵਾਲੀ ਸੂਚੀ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
print(random.choices(l))
# [1]
ਆਰਗੂਮੈਂਟ ਵਜ਼ਨ ਦੀ ਵਰਤੋਂ ਵਜ਼ਨ (ਸੰਭਾਵਨਾ) ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ ਹਰੇਕ ਤੱਤ ਨੂੰ ਚੁਣਿਆ ਜਾਵੇਗਾ, ਅਤੇ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਕਿਸਮ int ਜਾਂ ਫਲੋਟ ਹੋ ਸਕਦੀ ਹੈ।
print(random.choices(l, k=3, weights=[1, 1, 1, 10, 1]))
# [0, 2, 3]
print(random.choices(l, k=3, weights=[1, 1, 0, 0, 0]))
# [0, 1, 1]
ਆਰਗੂਮੈਂਟ cum_weights ਨੂੰ ਇੱਕ ਸੰਚਤ ਵਜ਼ਨ ਵਜੋਂ ਵੀ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਨਿਮਨਲਿਖਤ ਨਮੂਨਾ ਕੋਡ ਵਿੱਚ ਕਮ_ਵਜ਼ਨ ਉਪਰੋਕਤ ਪਹਿਲੇ ਵਜ਼ਨ ਦੇ ਬਰਾਬਰ ਹੈ।
print(random.choices(l, k=3, cum_weights=[1, 2, 3, 13, 14]))
# [3, 2, 3]
ਆਰਗੂਮੈਂਟ ਵਜ਼ਨ ਅਤੇ ਕਮ_ਵੇਟਸ ਦੋਵਾਂ ਲਈ ਡਿਫੌਲਟ ਕੋਈ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹਰੇਕ ਤੱਤ ਨੂੰ ਇੱਕੋ ਸੰਭਾਵਨਾ ਨਾਲ ਚੁਣਿਆ ਗਿਆ ਹੈ।
ਜੇਕਰ ਆਰਗੂਮੈਂਟ ਵਜ਼ਨ ਜਾਂ ਕਮ_ਵੇਟਸ ਦੀ ਲੰਬਾਈ (ਐਲੀਮੈਂਟਸ ਦੀ ਸੰਖਿਆ) ਅਸਲ ਸੂਚੀ ਤੋਂ ਵੱਖਰੀ ਹੈ, ਤਾਂ ਇੱਕ ਤਰੁੱਟੀ ਹੁੰਦੀ ਹੈ।
# print(random.choices(l, k=3, weights=[1, 1, 1, 10, 1, 1, 1]))
# ValueError: The number of weights does not match the population_
ਇੱਕੋ ਸਮੇਂ ‘ਤੇ ਵਜ਼ਨ ਅਤੇ ਕਮ_ਵੇਟ ਨਿਰਧਾਰਤ ਕਰਨਾ ਵੀ ਇੱਕ ਗਲਤੀ ਹੈ।
# print(random.choices(l, k=3, weights=[1, 1, 1, 10, 1], cum_weights=[1, 2, 3, 13, 14]))
# TypeError: Cannot specify both weights and cumulative weights
ਅਸੀਂ ਹੁਣ ਤੱਕ ਨਮੂਨਾ ਕੋਡ ਵਿੱਚ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ ਪਹਿਲੀ ਦਲੀਲ ਵਜੋਂ ਇੱਕ ਸੂਚੀ ਨਿਰਧਾਰਤ ਕੀਤੀ ਹੈ, ਪਰ ਇਹੀ ਟੂਪਲਾਂ ਅਤੇ ਸਤਰਾਂ ‘ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ।
ਬੇਤਰਤੀਬ ਨੰਬਰ ਬੀਜ ਨੂੰ ਠੀਕ ਕਰੋ
ਬੇਤਰਤੀਬ ਮੋਡੀਊਲ ਦੇ ਫੰਕਸ਼ਨ ਸੀਡ() ਨੂੰ ਇੱਕ ਆਰਬਿਟਰਰੀ ਪੂਰਨ ਅੰਕ ਦੇ ਕੇ, ਬੇਤਰਤੀਬ ਸੰਖਿਆ ਦੇ ਬੀਜ ਨੂੰ ਫਿਕਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਬੇਤਰਤੀਬ ਸੰਖਿਆ ਜਨਰੇਟਰ ਨੂੰ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਉਸੇ ਬੀਜ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੱਤ ਹਮੇਸ਼ਾ ਉਸੇ ਤਰੀਕੇ ਨਾਲ ਚੁਣੇ ਜਾਂਦੇ ਹਨ।
random.seed(0)
print(random.choice(l))
# 3
random.seed(0)
print(random.choice(l))
# 3
