කොමාවෙන් වෙන් කරන ලද තන්තුවක් පයිතන් හි ලැයිස්තුවකට බෙදන විට, ඒ අතර හිස්තැන් නොමැති නම්, බෙදීම() පමණක් ක්‍රියා කරයි. හිස්තැන් තිබේ නම්, අමතර හිස්තැන් ඉවත් කිරීම සඳහා තීරු () සමඟ එය ඒකාබද්ධ කිරීම ප්රයෝජනවත් වේ. ඊට අමතරව, ලිස්ට් අවෙබෝධන අංකනය භාවිතා කිරීම ලිවීමට දක්ෂ ක්‍රමයකි.
මෙම කොටසේදී අපි මුලින්ම පහත කරුණු පැහැදිලි කරන්නෙමු.
- නිශ්චිත පරිසීමකයක් සමඟ තන්තුවක් බෙදා එය ලැයිස්තුවක් ලෙස ආපසු දෙන්න
split() - තන්තුවක මුල සහ අග සිට අමතර අක්ෂර ඉවත් කරන්න.
strip() - මූලද්‍රව්‍ය ලැයිස්තුගත කිරීමට ශ්‍රිත සහ ක්‍රම යෙදීම සඳහා අවබෝධතා අංක ලැයිස්තුගත කරන්න.
පහත දැක්වෙන පරිදි හිස්තැන් ඉවත් කිරීමෙන් හිස්තැන් සහ කොමා වලින් වෙන් කරන ලද නූල් ලැයිස්තුවක් සාදන ආකාරය ද එය පෙන්වයි.one, two, three'
ඊට අමතරව, අපි පහත සඳහන් කරුණු සාකච්ඡා කරමු
- එය අංක ලැයිස්තුවක් ලෙස ලබා ගන්නේ කෙසේද
- ලැයිස්තුවකට සම්බන්ධ වී එය නැවත තන්තුවක් බවට පත් කිරීමට join() භාවිතා කරන්නේ කෙසේද
split():නිශ්චිත පරිසීමකයක් සමඟ තන්තුවක් බෙදා එය ලැයිස්තුවක් ලෙස ආපසු දෙන්න
තන්තු සඳහා split() ක්‍රමය භාවිතා කිරීමෙන්, ඔබට නිශ්චිත පරිසීමකයක් සමඟ තන්තුවක් බෙදා එය ලැයිස්තුවක් (අරාවක්) ලෙස ලබා ගත හැකිය. නිශ්චිත පරිසීමකය පහත තර්කය මගින් නියම කළ හැක.sep
තර්කය sep මඟ හැර තිබේ නම් සහ පරිසීමකයක් නියම කර නොමැති නම්, එය තන්තුව හිස්තැන් වලින් බෙදා ලැයිස්තුවක් ලබා දෙයි. අඛණ්ඩ හිස්තැන් සහ ටැබ් ද ලැයිස්තුව බෙදනු ඇත, එබැවින් ඔබට ටැබ්-සීමිත නූල් ලැයිස්තුවක් සෑදීමට අවශ්‍ය නම්, ඔබට තර්කයෙන් තොරව බෙදීම() භාවිතා කළ හැක.
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']
sep තර්කයේ පරිසීමකයක් සඳහන් කර ඇත්නම්, එය එම තන්තුවෙන් ලැයිස්තුව බෙදා ලැයිස්තුවක් ලබා දෙයි.
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() යනු තන්තුවක මුල සහ අග සිට අමතර අක්ෂර ඉවත් කිරීමේ ක්‍රමයකි.
තර්කය මග හරිනු ලැබුවහොත්, සුදු අවකාශ අක්ෂර ඉවත් කර නව තන්තුවක් ආපසු එවනු ලැබේ. මුල් තන්තුවම වෙනස් නොවේ.
s = ' one ' print(s.strip()) # one print(s) # one
තන්තුවක් තර්කයක් ලෙස සඳහන් කළහොත්, තන්තුවෙහි අඩංගු අක්ෂර ඉවත් කරනු ලැබේ.
s = '-+-one-+-' print(s.strip('-+')) # one
මෙම අවස්ථාවේදී, අවකාශය ඉවත් නොකෙරේ. එමනිසා, ඔබට whitespace ද ඉවත් කිරීමට අවශ්‍ය නම්, පහත දැක්වෙන පරිදි හිස්තැන් ඇතුළු තන්තුවක් තර්කයක් ලෙස ලබා දෙන්න.-+ '
s = '-+- one -+-' print(s.strip('-+')) # one s = '-+- one -+-' print(s.strip('-+ ')) # one
strip() අන්ත දෙකම හසුරුවයි, නමුත් පහත ශ්‍රිත ද පවතී.
lstrip():ආරම්භය පමණක් සකසන්නrstrip():පේළියේ අවසානය පමණක් සකසන්න.
ලැයිස්තු අවබෝධතා අංකනය: මූලද්‍රව්‍ය ලැයිස්තුගත කිරීමට ශ්‍රිත සහ ක්‍රම යොදන්න
ඔබට ලැයිස්තුවක මූලද්‍රව්‍ය සඳහා ශ්‍රිතයක් හෝ ක්‍රමයක් යෙදීමට අවශ්‍ය නම්, ඔබට අවසානයේ ලැයිස්තුව ලබා ගැනීමට අවශ්‍ය නම් for loop වෙනුවට list comprehension අංකනය භාවිතා කිරීම බුද්ධිමත් වේ.
මෙහිදී, අපි string එක split() සමඟ බෙදීමෙන් ලබා ගන්නා ලැයිස්තුවට තීරු() යොදන්නෙමු. ලැයිස්තුවක් සෑදීමට සුදු ඉඩ අඩංගු කොමාවෙන් වෙන් කළ තන්තුවක ඇති අමතර සුදු ඉඩ ඉවත් කළ හැක.
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() හෝ float() යොදන්න.
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() ක්‍රමය භාවිතා කරන්න.
වැරැද්දක් කිරීම පහසුය, නමුත් join() යනු string ක්‍රමයක් මිස ලැයිස්තු ක්‍රමයක් නොවන බව සලකන්න. ලැයිස්තුව තර්කයක් ලෙස දක්වා ඇත.
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
