પાયથોન, અલ્પવિરામથી અલગ કરેલ સ્ટ્રિંગને વિભાજિત કરવા માટે વિભાજિત કરો, વ્હાઇટસ્પેસ દૂર કરો અને સૂચિમાં કન્વર્ટ કરો

પાયથોનમાં સૂચિમાં અલ્પવિરામથી અલગ કરેલ સ્ટ્રિંગને વિભાજિત કરતી વખતે, જો વચ્ચે કોઈ જગ્યાઓ ન હોય, તો ફક્ત split() કામ કરશે. જો ત્યાં જગ્યાઓ હોય, તો વધારાની જગ્યાઓ દૂર કરવા માટે તેને strip() સાથે જોડવાનું ઉપયોગી છે. વધુમાં, સૂચિ સમજણ સંકેતનો ઉપયોગ એ લખવાની એક સ્માર્ટ રીત છે.

આ વિભાગમાં, અમે પ્રથમ નીચેની બાબતો સમજાવીએ છીએ.

• ઉલ્લેખિત સીમાંક સાથે સ્ટ્રિંગને વિભાજિત કરો અને તેને સૂચિ તરીકે પરત કરોsplit()
• સ્ટ્રિંગની શરૂઆત અને અંતમાંથી વધારાના અક્ષરો દૂર કરો.strip()
• ઘટકોને સૂચિબદ્ધ કરવા માટે કાર્યો અને પદ્ધતિઓ લાગુ કરવા માટે સૂચી સમજણ સંકેત.

તે નીચે બતાવ્યા પ્રમાણે, ખાલી જગ્યાઓ અને અલ્પવિરામ દ્વારા વિભાજિત તારોની યાદી કેવી રીતે બનાવવી તે પણ બતાવે છે.
one, two, three'

વધુમાં, અમે નીચેની ચર્ચા કરીશું

• નંબરોની સૂચિ તરીકે તેને કેવી રીતે મેળવવું
• સૂચિમાં જોડાવા અને તેને ફરીથી સ્ટ્રિંગ બનાવવા માટે join() નો ઉપયોગ કેવી રીતે કરવો

split():ઉલ્લેખિત સીમાંક સાથે સ્ટ્રિંગને વિભાજિત કરો અને તેને સૂચિ તરીકે પરત કરો

શબ્દમાળાઓ માટે પદ્ધતિ split() નો ઉપયોગ કરીને, તમે સ્પષ્ટ કરેલ સીમાંક સાથે સ્ટ્રિંગને વિભાજિત કરી શકો છો અને તેને સૂચિ (એરે) તરીકે મેળવી શકો છો. ઉલ્લેખિત સીમાંક નીચેની દલીલ દ્વારા સ્પષ્ટ કરી શકાય છે.sep

• str.split() — Built-in Types — Python 3.10.1 Documentation

જો દલીલ sep અવગણવામાં આવે છે અને કોઈ સીમાંકક ઉલ્લેખિત નથી, તો તે સ્ટ્રિંગને જગ્યાઓ દ્વારા વિભાજિત કરે છે અને સૂચિ પરત કરે છે. સળંગ જગ્યાઓ અને ટૅબ્સ પણ સૂચિને વિભાજિત કરશે, તેથી જો તમે ટૅબ-સીમાંકિત શબ્દમાળાઓની સૂચિ બનાવવા માંગતા હો, તો તમે દલીલ વિના split() નો ઉપયોગ કરી શકો છો.

s = 'one two three'
l = s.split()
print(l)
# ['one', 'two', 'three']

s = 'one two        three'
l = s.split()
print(l)
# ['one', 'two', 'three']

s = 'one\ttwo\tthree'
l = s.split()
print(l)
# ['one', 'two', 'three']

જો સેપ આર્ગ્યુમેન્ટમાં સીમાંકનો ઉલ્લેખ કરવામાં આવ્યો હોય, તો તે યાદીને તે શબ્દમાળા દ્વારા વિભાજિત કરે છે અને યાદી પરત કરે છે.

s = 'one::two::three'
l = s.split('::')
print(l)
# ['one', 'two', 'three']

અલ્પવિરામથી વિભાજિત સ્ટ્રિંગના કિસ્સામાં, જો ત્યાં કોઈ વધારાની સફેદ જગ્યા ન હોય, તો કોઈ સમસ્યા નથી, પરંતુ જો તમે અલ્પવિરામ + સફેદ જગ્યા દ્વારા અલગ કરાયેલી સ્ટ્રિંગ માટે ડિલિમિટર તરીકે અલ્પવિરામ સાથે split() ચલાવો છો, તો તમે સમાપ્ત થઈ જશો. શરૂઆતમાં બાકી સફેદ જગ્યા સાથે સ્ટ્રિંગ્સની સૂચિ સાથે ઉપર.

s = 'one,two,three'
l = s.split(',')
print(l)
# ['one', 'two', 'three']

s = 'one, two, three'
l = s.split(',')
print(l)
# ['one', ' two', ' three']

તમે નીચે પ્રમાણે ડિલિમિટર તરીકે અલ્પવિરામ + જગ્યાનો ઉપયોગ કરી શકો છો, પરંતુ જો મૂળ શબ્દમાળામાં જગ્યાઓની સંખ્યા અલગ હશે તો તે કામ કરશે નહીં., '

s = 'one, two, three'
l = s.split(', ')
print(l)
# ['one', 'two', 'three']

s = 'one, two,  three'
l = s.split(', ')
print(l)
# ['one', 'two', ' three']

સ્ટ્રિંગ મેથડ સ્ટ્રિપ(), જે આગળ સમજાવવામાં આવશે, તેનો ઉપયોગ બે જગ્યાઓ સાથે વ્યવહાર કરવા માટે થઈ શકે છે.

strip():સ્ટ્રિંગની શરૂઆત અને અંતમાંથી વધારાના અક્ષરો દૂર કરો.

strip() એ સ્ટ્રિંગની શરૂઆત અને અંતમાંથી વધારાના અક્ષરો દૂર કરવાની પદ્ધતિ છે.

• str.strip() — Built-in Types — Python 3.10.1 Documentation

જો દલીલ અવગણવામાં આવે છે, તો વ્હાઇટસ્પેસ અક્ષરો દૂર કરીને નવી સ્ટ્રિંગ પરત કરવામાં આવે છે. મૂળ શબ્દમાળા પોતે બદલાતી નથી.

s = '  one  '
print(s.strip())
# one

print(s)
#   one  

જો કોઈ શબ્દમાળા દલીલ તરીકે ઉલ્લેખિત હોય, તો સ્ટ્રિંગમાં રહેલા અક્ષરો દૂર કરવામાં આવશે.

s = '-+-one-+-'
print(s.strip('-+'))
# one

આ કિસ્સામાં, ખાલી જગ્યાઓ દૂર કરવામાં આવતી નથી. તેથી, જો તમે વ્હાઇટસ્પેસને પણ દૂર કરવા માંગતા હો, તો નીચે બતાવ્યા પ્રમાણે, દલીલ તરીકે સ્પેસ સહિતની સ્ટ્રિંગ પસાર કરો.-+ '

s = '-+- one -+-'
print(s.strip('-+'))
#  one 

s = '-+- one -+-'
print(s.strip('-+ '))
# one

strip() બંને છેડાને હેન્ડલ કરે છે, પરંતુ નીચેના કાર્યો પણ ઉપલબ્ધ છે.

• lstrip():પ્રક્રિયા માત્ર શરૂઆત
• rstrip():ફક્ત લાઇનના અંત પર પ્રક્રિયા કરો.

સૂચિ સમજણ સંકેત: ઘટકોને સૂચિબદ્ધ કરવા માટે કાર્યો અને પદ્ધતિઓ લાગુ કરો

જો તમે સૂચિના ઘટકો પર ફંક્શન અથવા પદ્ધતિ લાગુ કરવા માંગતા હો, તો જો તમે અંતમાં સૂચિ મેળવવા માંગતા હોવ તો લૂપને બદલે સૂચિ સમજણ સંકેતનો ઉપયોગ કરવો સ્માર્ટ છે.

• સંબંધિત લેખો:પાયથોન લિસ્ટ કોમ્પ્રીહેન્સન્સ નોટેશનનો ઉપયોગ કરીને

અહીં, અમે સ્પ્લિટ() સાથે સ્ટ્રિંગને વિભાજિત કરીને મેળવેલી યાદીમાં સ્ટ્રીપ() લાગુ કરીએ છીએ. વ્હાઇટસ્પેસ ધરાવતી અલ્પવિરામથી અલગ કરેલ સ્ટ્રિંગમાં વધારાની વ્હાઇટસ્પેસ યાદી બનાવવા માટે દૂર કરી શકાય છે.

s = 'one, two, three'
l = [x.strip() for x in s.split(',')]
print(l)
# ['one', 'two', 'three']

જ્યારે આ ખાલી સ્ટ્રિંગ પર લાગુ થાય છે, ત્યારે એક તત્વ તરીકે એક ખાલી સ્ટ્રિંગ સાથેની સૂચિ મેળવી શકાય છે.

s = ''
l = [x.strip() for x in s.split(',')]
print(l)
print(len(l))
# ['']
# 1

જો તમે ખાલી સ્ટ્રિંગ માટે ખાલી સૂચિ મેળવવા માંગતા હો, તો તમે સૂચિ સમજણ નોટેશનમાં શરતી શાખા સેટ કરી શકો છો.

s = ''
l = [x.strip() for x in s.split(',') if not s == '']
print(l)
print(len(l))
# []
# 0

one, , three'
ઉપરાંત, જો ઉપર વર્ણવ્યા મુજબ અલ્પવિરામથી અલગ કરેલ તત્વ ખૂટે છે, તો પ્રથમ પદ્ધતિ તેને ખાલી સ્ટ્રિંગ ઘટક તરીકે સૂચિબદ્ધ કરશે.

s = 'one, , three'
l = [x.strip() for x in s.split(',')]
print(l)
print(len(l))
# ['one', '', 'three']
# 3

જો તમે ગુમ થયેલ ભાગોને અવગણવા માંગતા હો, તો તમે સૂચિ સમજણ સંકેતમાં શરતી શાખા સેટ કરી શકો છો.

s = 'one, ,three'
l = [x.strip() for x in s.split(',') if not x.strip() == '']
print(l)
print(len(l))
# ['one', 'three']
# 2

સંખ્યાઓની સૂચિ તરીકે મેળવો

જો તમે સ્ટ્રિંગને બદલે સંખ્યાઓની સૂચિ તરીકે સંખ્યાઓની અલ્પવિરામથી વિભાજિત સ્ટ્રિંગ મેળવવા માંગતા હો, તો સૂચિ સમજણ સંકેતમાં સ્ટ્રિંગને નંબરમાં કન્વર્ટ કરવા માટે int() અથવા ફ્લોટ() લાગુ કરો.

s = '1, 2, 3, 4'
l = [x.strip() for x in s.split(',')]
print(l)
print(type(l[0]))
# ['1', '2', '3', '4']
# <class 'str'>

s = '1, 2, 3, 4'
l = [int(x.strip()) for x in s.split(',')]
print(l)
print(type(l[0]))
# [1, 2, 3, 4]
# <class 'int'>

join():સૂચિ મર્જ કરો અને તેને સ્ટ્રિંગ તરીકે મેળવો

વિપરીત પેટર્નમાં, જો તમે સૂચિમાં જોડાવા માંગતા હોવ અને ચોક્કસ સીમાંક દ્વારા અલગ તાર મેળવવા માંગતા હો, તો join() પદ્ધતિનો ઉપયોગ કરો.

• str.join() — Built-in Types — Python 3.10.1 Documentation

ભૂલ કરવી સરળ છે, પરંતુ નોંધ લો કે join() એ સ્ટ્રિંગ પદ્ધતિ છે, સૂચિ પદ્ધતિ નથી. સૂચિ દલીલ તરીકે ઉલ્લેખિત છે.

s = 'one, two,  three'
l = [x.strip() for x in s.split(',')]
print(l)
# ['one', 'two', 'three']

print(','.join(l))
# one,two,three

print('::'.join(l))
# one::two::three

તમે તેને નીચે પ્રમાણે એક લીટીમાં લખી શકો છો.

s = 'one, two,  three'
s_new = '-'.join([x.strip() for x in s.split(',')])
print(s_new)
# one-two-three

જો તમે માત્ર નિશ્ચિત સીમાંક બદલવા માંગતા હો, તો તેને રિપ્લેસ() પદ્ધતિથી બદલવું વધુ સરળ છે.

s = 'one,two,three'
s_new = s.replace(',', '+')
print(s_new)
# one+two+three