Python માં સ્ટ્રિંગ્સને જોડવું અને જોડવું: + ઓપરેટરો, જોડાવાનાં કાર્યો વગેરે.

નીચે પાયથોનમાં સ્ટ્રિંગ સ્ટ્રિંગને કેવી રીતે જોડવું અને જોડવું તેનું વર્ણન છે.

• બહુવિધ શબ્દમાળાઓનું જોડાણ અને મર્જિંગ:+,+=ઓપરેટર
• સંખ્યાઓ અને શબ્દમાળાઓ જોડો અને જોડો:+,+=ઓપરેટર,str(),format(),f-સ્ટ્રિંગ
• એક જ સ્ટ્રિંગમાં સ્ટ્રિંગ્સની સૂચિઓ (એરે)ને જોડો અને ભેગા કરો:join()
• સંખ્યાઓની યાદીઓ (એરે)ને એક જ સ્ટ્રિંગમાં જોડો અને જોડો:join(),str()

બહુવિધ શબ્દમાળાઓનું જોડાણ અને મર્જિંગ:+,+=ઓપરેટર

જોડાણ:+ઓપરેટર

++ ઓપરેટરનો ઉપયોગ નીચેના સ્ટ્રીંગ લિટરલ્સ અને સ્ટ્રિંગ વેરીએબલ્સને જોડવા માટે કરી શકાય છે

• …’
• “…”

s = 'aaa' + 'bbb' + 'ccc'
print(s)
# aaabbbccc

s1 = 'aaa'
s2 = 'bbb'
s3 = 'ccc'

s = s1 + s2 + s3
print(s)
# aaabbbccc

s = s1 + s2 + s3 + 'ddd'
print(s)
# aaabbbcccddd

જોડાણ:+=ઓપરેટર

+= ઓપરેટર, એક સંચિત સોંપણી ઓપરેટર, પણ વાપરી શકાય છે. ડાબી બાજુનું સ્ટ્રિંગ વેરીએબલ જમણી બાજુની સ્ટ્રિંગ સાથે જોડાયેલું છે અને તેને સોંપેલ અને અપડેટ કરવામાં આવે છે.

s1 += s2
print(s1)
# aaabbb

જો તમે સ્ટ્રિંગ વેરીએબલના અંતમાં સ્ટ્રિંગ ઉમેરવા માંગતા હો, તો ફક્ત સ્ટ્રિંગ વેરિયેબલ અને કોઈપણ સ્ટ્રિંગ લિટરલ (અથવા અન્ય સ્ટ્રિંગ વેરિયેબલ) પર += ઑપરેટર સાથે પ્રક્રિયા કરો.

s = 'aaa'

s += 'xxx'
print(s)
# aaaxxx

શબ્દમાળાના અક્ષરોનું સળંગ જોડાણ

જો તમે ખાલી સ્ટ્રિંગ લિટરલ્સ સાથે સાથે લખો છો, તો સ્ટ્રિંગ લિટરલ્સ સંકલિત થશે.

s = 'aaa''bbb''ccc'
print(s)
# aaabbbccc

બે લાઇન અથવા બેકસ્લેશ લાઇન વિરામ વચ્ચે જગ્યા હોવી સ્વીકાર્ય છે (એક ચાલુ ગણવામાં આવે છે).

s = 'aaa'  'bbb'    'ccc'
print(s)
# aaabbbccc

s = 'aaa'\
    'bbb'\
    'ccc'
print(s)
# aaabbbccc

કોડમાં બહુવિધ રેખાઓ પર લાંબી સ્ટ્રીંગ્સ લખવા માટે આનો ઉપયોગ કરવાની એક તકનીક છે.

• સંબંધિત લેખો:Python માં બહુવિધ રેખાઓ પર લાંબી તાર લખવી

શબ્દમાળા ચલો માટે આ લેખન પદ્ધતિ શક્ય નથી.

# s = s1 s2 s3
# SyntaxError: invalid syntax

સંખ્યાત્મક અને શબ્દમાળા જોડાણ/સંકલન:+,+=ઓપરેટર,str(),format(),f-સ્ટ્રિંગ

A + અલગ પ્રકારનું ઓપરેશન ભૂલમાં પરિણમે છે.

s1 = 'aaa'
s2 = 'bbb'

i = 100
f = 0.25

# s = s1 + i
# TypeError: must be str, not int

જો તમે આંકડાકીય મૂલ્ય (દા.ત., પૂર્ણાંક પ્રકાર int અથવા ફ્લોટિંગ-પોઇન્ટ પ્રકાર ફ્લોટ) ને સ્ટ્રિંગ સાથે જોડવા માંગતા હો, તો આંકડાકીય મૂલ્યને str() વડે સ્ટ્રિંગ પ્રકારમાં કન્વર્ટ કરો અને પછી તેને + ઑપરેટર (અથવા += ઑપરેટર) સાથે જોડી દો. ).

s = s1 + '_' + str(i) + '_' + s2 + '_' + str(f)
print(s)
# aaa_100_bbb_0.25

જો તમે સંખ્યાના ફોર્મેટને કન્વર્ટ કરવા માંગતા હો, જેમ કે શૂન્ય-ભરણ અથવા દશાંશ સ્થાનો, તો format() ફંક્શન અથવા સ્ટ્રિંગ મેથડ ફોર્મેટ() નો ઉપયોગ કરો.

s = s1 + '_' + format(i, '05') + '_' + s2 + '_' + format(f, '.5f')
print(s)
# aaa_00100_bbb_0.25000

s = '{}_{:05}_{}_{:.5f}'.format(s1, i, s2, f)
print(s)
# aaa_00100_bbb_0.25000

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

s = '{}_{}_{}_{}'.format(s1, i, s2, f)
print(s)
# aaa_100_bbb_0.25

ફોર્મેટનો ઉલ્લેખ કેવી રીતે કરવો તેની વિગતો માટે નીચેનો લેખ જુઓ.

• સંબંધિત લેખો:પાયથોનમાં ફોર્મેટ કન્વર્ઝન, ફોર્મેટ (0-ફિલિંગ, ઘાતાંકીય સંકેત, હેક્સાડેસિમલ, વગેરે)

Python 3.6 થી, f-strings (f-string) નામની મિકેનિઝમ પણ રજૂ કરવામાં આવી છે, જે format() કરતાં લખવા માટે પણ સરળ છે.

s = f'{s1}_{i:05}_{s2}_{f:.5f}'
print(s)
# aaa_00100_bbb_0.25000

s = f'{s1}_{i}_{s2}_{f}'
print(s)
# aaa_100_bbb_0.25

સ્ટ્રિંગ્સની સૂચિઓ (એરે) સાથે જોડો અને જોડાઓ:join()

સ્ટ્રિંગ મેથડ join() નો ઉપયોગ સ્ટ્રિંગની યાદીને એક સ્ટ્રિંગમાં જોડવા માટે કરી શકાય છે.

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

તેને કેવી રીતે લખવું તે નીચે મુજબ છે.

'String to be inserted between'.join([List of strings to be concatenated])

જોડાવા () મેથડને ‘ વચ્ચે દાખલ કરવા માટે સ્ટ્રિંગ’ સાથે કૉલ કરો અને દલીલ તરીકે [કંટીનેટ કરવા માટે સ્ટ્રિંગ્સની સૂચિ] પાસ કરો.

જો ખાલી સ્ટ્રિંગનો ઉપયોગ કરવામાં આવે છે, તો [સંકલિત કરવા માટેના શબ્દમાળાઓની સૂચિ] સરળ રીતે જોડવામાં આવશે, જો અલ્પવિરામનો ઉપયોગ કરવામાં આવે, તો શબ્દમાળાઓ અલ્પવિરામથી અલગ કરવામાં આવશે, અને જો નવી લાઇન અક્ષરનો ઉપયોગ કરવામાં આવશે, તો દરેક સ્ટ્રિંગ ઘટક નવી લાઇન કરવામાં આવશે.

l = ['aaa', 'bbb', 'ccc']

s = ''.join(l)
print(s)
# aaabbbccc

s = ','.join(l)
print(s)
# aaa,bbb,ccc

s = '-'.join(l)
print(s)
# aaa-bbb-ccc

s = '\n'.join(l)
print(s)
# aaa
# bbb
# ccc

જો કે અહીં ફક્ત સૂચિનું ઉદાહરણ આપવામાં આવ્યું છે, અન્ય પુનરાવર્તિત ઑબ્જેક્ટ્સ જેમ કે ટ્યુપલ્સ પણ જોડાવા માટે દલીલો તરીકે સ્પષ્ટ કરી શકાય છે.

join() ના વિપરીત, split() નો ઉપયોગ ચોક્કસ સીમાંકન દ્વારા સીમાંકિત સ્ટ્રિંગને વિભાજિત કરવા અને તેને સૂચિ તરીકે મેળવવા માટે થાય છે.

સંખ્યાઓની યાદીઓ (એરે)ને સ્ટ્રિંગ તરીકે જોડો અને જોડો:join(),str()

જો જોડાવા માટેની દલીલ એ એવી સૂચિ છે કે જેના તત્વો શબ્દમાળાઓ નથી તો ભૂલ થાય છે.

l = [0, 1, 2]

# s = '-'.join(l)
# TypeError: sequence item 0: expected str instance, int found

સંખ્યાઓની સૂચિને એક સ્ટ્રિંગમાં જોડવા માટે, સંખ્યાઓને સ્ટ્રિંગમાં રૂપાંતરિત કરવા માટે સૂચિ સમજણ સંકેતમાં દરેક ઘટક પર str() ફંક્શન લાગુ કરો અને પછી તેને join() સાથે જોડો.

s = '-'.join([str(n) for n in l])
print(s)
# 0-1-2

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

s = '-'.join((str(n) for n in l))
print(s)
# 0-1-2

s = '-'.join(str(n) for n in l)
print(s)
# 0-1-2

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

• python – List vs generator comprehension speed with join function – Stack Overflow

સૂચિની સમજણ અને જનરેટર અભિવ્યક્તિઓ વિશે વધુ માહિતી માટે, નીચેનો લેખ જુઓ.

• સંબંધિત લેખો:પાયથોન સૂચિ સમજણનો ઉપયોગ કેવી રીતે કરવો