පහත දැක්වෙන්නේ Python හි string str concatenate සහ join කරන ආකාරය පිළිබඳ විස්තරයකි.
- බහු තන්තු ඒකාබද්ධ කිරීම සහ ඒකාබද්ධ කිරීම:
+,+=ක්රියාකරු - අංක සහ තන්තු සම්බන්ධ කර ඒකාබද්ධ කරන්න:
+,+=ක්රියාකරු,str(),format(),f-string - තන්තු වල ලැයිස්තු (අරා) තනි තන්තුවකට ඒකාබද්ධ කර ඒකාබද්ධ කරන්න:
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
තන්තු වචන අනුපිළිවෙලින් ඒකාබද්ධ කිරීම
ඔබ සරලව string Literals එක පැත්තකින් ලිව්වොත්, string literals එක concatenated වේ.
s = 'aaa''bbb''ccc'
print(s)
# aaabbbccc
පේළි දෙකක් අතර ඉඩක් තිබීම හෝ පසුපෙළ බිඳීමක් (අඛණ්ඩව සැලකීම) පිළිගත හැකි ය.
s = 'aaa' 'bbb' 'ccc'
print(s)
# aaabbbccc
s = 'aaa'\
'bbb'\
'ccc'
print(s)
# aaabbbccc
කේතයේ පේළි කිහිපයක දිගු නූල් ලිවීමට මෙය භාවිතා කිරීමේ තාක්ෂණයක් තිබේ.
- අදාළ ලිපි:Python හි බහු පේළි මත දිගු නූල් ලිවීම
මෙම ලිවීමේ ක්‍රමය string variables සඳහා කළ නොහැක.
# s = s1 s2 s3
# SyntaxError: invalid syntax
සංඛ්‍යාත්මක සහ තන්තු සම්බන්ධ කිරීම/සංක්‍රමණය:+,+=ක්රියාකරු,str(),format(),f-string
A + වෙනත් වර්ගයක ක්‍රියාකාරිත්වය දෝෂයකට තුඩු දෙයි.
s1 = 'aaa'
s2 = 'bbb'
i = 100
f = 0.25
# s = s1 + i
# TypeError: must be str, not int
ඔබට සංඛ්‍යාත්මක අගයක් (උදා, පූර්ණ සංඛ්‍යා වර්ගය int හෝ පාවෙන ලක්ෂ්‍ය ආකාරයේ float) තන්තුවක් සමඟ සම්බන්ධ කිරීමට අවශ්‍ය නම්, සංඛ්‍යාත්මක අගය str() සමඟ තන්තු වර්ගයකට පරිවර්තනය කර + ක්රියාකරු (හෝ += ක්රියාකරු සමඟ ඒකාබද්ධ කරන්න. )
s = s1 + '_' + str(i) + '_' + s2 + '_' + str(f)
print(s)
# aaa_100_bbb_0.25
ඔබට ශුන්‍ය පිරවීම හෝ දශම ස්ථාන වැනි සංඛ්‍යාවක ආකෘතිය පරිවර්තනය කිරීමට අවශ්‍ය නම්, ආකෘතිය() ශ්‍රිතය හෝ තන්තු ක්‍රමය ආකෘතිය() භාවිතා කරන්න.
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
ඇත්ත වශයෙන්ම, විචල්‍යයක අගය හැඩතල ගැන්වීමකින් තොරව කෙලින්ම තන්තුවකට ඇතුළත් කළ හැකිය. + operator භාවිතා කරනවාට වඩා මෙය ලිවීම සරලයි.
s = '{}_{}_{}_{}'.format(s1, i, s2, f)
print(s)
# aaa_100_bbb_0.25
ආකෘතිය සඳහන් කරන්නේ කෙසේද යන්න පිළිබඳ විස්තර සඳහා පහත ලිපිය බලන්න.
Python 3.6 සිට, f-strings (f-string) නම් යාන්ත්‍රණයක් ද හඳුන්වා දී ඇත, එය ආකෘතිය () ට වඩා ලිවීමට වඩා සරල ය.
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() භාවිතා කළ හැක.
පහත දැක්වෙන්නේ එය ලියන ආකාරයයි.
'String to be inserted between'.join([List of strings to be concatenated])
අතරට ඇතුළු කිරීමට තන්තුව’ සමඟ join() ක්‍රමය අමතන්න සහ තර්කයක් ලෙස [සම්බන්ධ කිරීමට නූල් ලැයිස්තුව] සමත් කරන්න.
හිස් තන්තුවක් භාවිතා කරන්නේ නම්, [සම්බන්ධ කළ යුතු තන්තු ලැයිස්තුව] සරලව ඒකාබද්ධ කරනු ලැබේ, කොමාවක් භාවිතා කරන්නේ නම්, නූල් කොමාවෙන් වෙන් කරනු ලැබේ, නව රේඛා අක්ෂරයක් භාවිතා කරන්නේ නම්, සෑම තන්තු මූලද්‍රව්‍යයක්ම නව රේඛාවක් ඇත.
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
ලැයිස්තුවක උදාහරණයක් පමණක් මෙහි දක්වා ඇතත්, tuples වැනි වෙනත් පුනරාවර්තනය කළ හැකි වස්තු සම්බන්ධ වීමට තර්ක ලෙස ද දැක්විය හැකිය.
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
Generator ප්‍රකාශන සාමාන්‍යයෙන් ලැයිස්තු අවබෝධයන්ට වඩා අඩු මතකයක් භාවිතා කිරීමේ වාසිය ඇත, නමුත් join() generators එහි අභ්‍යන්තර සැකසුම් තුළ ලැයිස්තු බවට පරිවර්තනය කරන බැවින් generator ප්‍රකාශන භාවිතා කිරීමේ විශේෂ වාසියක් නොමැත. ඇත්ත වශයෙන්ම, මුල සිටම ලැයිස්තු අවබෝධයන් භාවිතා කිරීම තරමක් වේගවත් වේ.
ලැයිස්තු අවබෝධතා සහ උත්පාදක ප්‍රකාශන පිළිබඳ වැඩි විස්තර සඳහා, පහත ලිපිය බලන්න.
