જો તમે પાયથોનમાં સૂચિ (એરે) ના ઘટકોને શફલ (રેન્ડમલી સૉર્ટ) કરવા માંગતા હો, તો પ્રમાણભૂત લાઇબ્રેરીના રેન્ડમ મોડ્યુલનો ઉપયોગ કરો.
ત્યાં બે કાર્યો છે: શફલ(), જે રેન્ડમલી મૂળ યાદીને સૉર્ટ કરે છે, અને સેમ્પલ(), જે નવી રેન્ડમલી સૉર્ટ કરેલી સૂચિ આપે છે. સેમ્પલ() શબ્દમાળાઓ અને ટ્યૂપલ્સ માટે વાપરી શકાય છે.
- મૂળ સૂચિને શફલ કરો:
random.shuffle() - નવી, શફલ્ડ સૂચિ બનાવો.:
random.sample() - શફલ શબ્દમાળાઓ અને tuples
- રેન્ડમ નંબરના બીજને ઠીક કરો
જો તમે રેન્ડમને બદલે ચડતા અથવા ઉતરતા ક્રમમાં અથવા વિપરીત ક્રમમાં સૉર્ટ કરવા માંગતા હો, તો નીચેનો લેખ જુઓ.
મૂળ સૂચિને શફલ કરો: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]
શફલ શબ્દમાળાઓ અને tuples
સ્ટ્રીંગ્સ અને ટ્યુપલ્સ અપરિવર્તનશીલ છે, તેથી જો તમે મૂળ ઑબ્જેક્ટ બદલવા માટે 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
ટ્યૂપલ્સ માટે, ટ્યૂપલ() નો ઉપયોગ કરો, જે સૂચિમાંથી ટ્યૂપલ બનાવે છે.
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]