පහත අන්තර්ගත, නියැදි කේතය සමඟින්, පයිතන් හි තන්තු (str) සහ සංඛ්‍යා (int, float) ලැයිස්තු (අරා) එකිනෙක පරිවර්තනය කරන්නේ කෙසේද යන්න පැහැදිලි කරයි.
- අංක ලැයිස්තුවක් නූල් ලැයිස්තුවකට පරිවර්තනය කරන්න
- අංකයක් දශම තන්තුවකට පරිවර්තනය කරන්න
- සංඛ්‍යාත්මක අගයන් ද්විමය, අෂ්ටක සහ ෂඩ් දශම තන්තු බවට පරිවර්තනය කරයි
- ඝාතීය අංකනයේදී සංඛ්‍යාත්මක අගයක් තන්තුවකට පරිවර්තනය කරයි
- තන්තු ලැයිස්තුවක් අංක ලැයිස්තුවකට පරිවර්තනය කරන්න
- දශම තන්තුව සංඛ්‍යාත්මක බවට පරිවර්තනය කරන්න
- ද්විමය, අෂ්ටක සහ ෂඩ් දශම තන්තු සංඛ්‍යා බවට පරිවර්තනය කරයි
- ඝාතීය අංකනයෙහි ඇති නූල් සංඛ්‍යාත්මක අගයන් වෙත පරිවර්තනය කරයි
- අංක බවට පරිවර්තනය කළ හැකි නූල් පමණක් පරිවර්තනය කරන්න
ලැයිස්තුවකින් නව ලැයිස්තුවක් උත්පාදනය කරන විට, ලූප සඳහා වඩා ලිස්ට් අවෙබෝධයන් ලිවීමට සරල ය. මෙම ලිපියේ නියැදි කේතය ලැයිස්තු අවබෝධයන් ද භාවිතා කරයි. ලැයිස්තු අවබෝධය පිළිබඳ විස්තර සඳහා, පහත ලිපිය බලන්න.
ලැයිස්තුවලට විවිධ වර්ගයේ දත්ත ගබඩා කළ හැකි අතර ඒවා අරාවලින් දැඩි ලෙස වෙනස් වන බව සලකන්න. පහත අවස්ථා වලදී array (සම්මත පුස්තකාලය) හෝ NumPy භාවිතා කරන්න.
- මට මතක ප්‍රමාණය සහ මතක ලිපින අවශ්‍ය වන ක්‍රියාවලි හැසිරවීමට අවශ්‍යයි.
- විශාල දත්ත කට්ටල සංඛ්‍යාත්මක සැකසුම් ආදිය සඳහා අරා හැසිරවීමට අවශ්‍යයි.
අංක ලැයිස්තුවක් නූල් ලැයිස්තුවකට පරිවර්තනය කරන්න
අංකයක් දශම තන්තුවකට පරිවර්තනය කරන්න
සංඛ්‍යාත්මකව තන්තුවට පරිවර්තනය කිරීමට str() භාවිතා කරන්න.
Python හි, සංඛ්‍යා ඝාතීය, ෂඩ් දශම සහ ද්විමය (ෂඩ් දශම සහ ද්විමය අංකනය) ඇතුළු විවිධ ආකෘතිවලින් ප්‍රකාශ කළ හැක. str() පරිවර්තනය සාමාන්‍ය දශම අංකනයක තන්තුවක් ඇති කරයි.
ඉලක්කම් ගණන අනුව, ඝාතීය අංකනය ස්වයංක්‍රීයව භාවිතා කළ හැක.
l_n = [-0.5, 0, 1.0, 100, 1.2e-2, 0xff, 0b11]
l_n_str = [str(n) for n in l_n]
print(l_n_str)
# ['-0.5', '0', '1.0', '100', '0.012', '255', '3']
සංඛ්‍යාත්මක අගයන් ද්විමය, අෂ්ටක සහ ෂඩ් දශම තන්තු බවට පරිවර්තනය කරයි
ද්විමය, අෂ්ටක හෝ ෂඩ් දශම (ද්වීය අංකනය, අෂ්ටක අංකනය හෝ ෂඩ් දශම අංකනය) තන්තු බවට පරිවර්තනය කිරීම සඳහා, පහත ක්‍රම තිබේ.
bin()oct()hex()format()str.format()
ආකෘතිය () ශ්රිතය සමඟ, ශුන්ය පිරවීම සහ ඉලක්කම් සකස් කළ හැකිය.
l_i = [0, 64, 128, 192, 256]
l_i_hex1 = [hex(i) for i in l_i]
print(l_i_hex1)
# ['0x0', '0x40', '0x80', '0xc0', '0x100']
l_i_hex2 = [format(i, '04x') for i in l_i]
print(l_i_hex2)
# ['0000', '0040', '0080', '00c0', '0100']
l_i_hex3 = [format(i, '#06x') for i in l_i]
print(l_i_hex3)
# ['0x0000', '0x0040', '0x0080', '0x00c0', '0x0100']
ඝාතීය අංකනයේදී සංඛ්‍යාත්මක අගයක් තන්තුවකට පරිවර්තනය කරයි
ඉහත සඳහන් කළ පරිදි, සමහර අවස්ථා ඉලක්කම් ගණන අනුව ස්වයංක්‍රීයව ඝාතීය අංකනය විය හැක. කෙසේ වෙතත්, සෑම විටම ඝාතීය අංකනය තුළ තන්තුවකට පරිවර්තනය කිරීමට, පහත සඳහන් එකක් භාවිතා කරන්න
format()str.format()
ආකෘතිය() ශ්රිතය සහ string ක්‍රමය str.format() පිළිබඳ වැඩි විස්තර සඳහා පහත ලිපිය බලන්න.
Mantissa කොටසෙහි ඉලක්කම් ගණන නියම කළ හැක. E විශාල අකුරක් තර්කයක් ලෙස භාවිතා කරන්නේ නම්, ප්‍රතිදාන තන්තුවද විශාල E වේ.
l_f = [0.0001, 123.456, 123400000]
l_f_e1 = [format(f, 'e') for f in l_f]
print(l_f_e1)
# ['1.000000e-04', '1.234560e+02', '1.234000e+08']
l_f_e2 = [format(f, '.3E') for f in l_f]
print(l_f_e2)
# ['1.000E-04', '1.235E+02', '1.234E+08']
තන්තු ලැයිස්තුවක් අංක ලැයිස්තුවකට පරිවර්තනය කරන්න
දශම තන්තුව සංඛ්‍යාත්මක බවට පරිවර්තනය කරන්න
තන්තුවෙන් අංකයට පරිවර්තනය කිරීමට int() හෝ float() භාවිතා කරන්න.
int() යනු පූර්ණ සංඛ්‍යාවකට පරිවර්තනයක් වන අතර float() යනු පාවෙන ලක්ෂ්‍ය අංකයකට පරිවර්තනයකි.
float() හි නිඛිල කොටස මඟ හැර ඇති නූල් පූර්ණ සංඛ්‍යා කොටස සඳහා 0 සමඟ අනුපූරක වේ.
l_si = ['-10', '0', '100']
l_si_i = [int(s) for s in l_si]
print(l_si_i)
# [-10, 0, 100]
l_sf = ['.123', '1.23', '123']
l_sf_f = [float(s) for s in l_sf]
print(l_sf_f)
# [0.123, 1.23, 123.0]
ද්විමය, අෂ්ටක සහ ෂඩ් දශම තන්තු සංඛ්‍යා බවට පරිවර්තනය කරයි
int() හි දෙවන තර්කය radix විය හැක: ද්විමය සඳහා 2, අෂ්ටක සඳහා 8, සහ hexadecimal සඳහා 16, තන්තුවක් සංඛ්‍යාවක් බවට පරිවර්තනය කරයි.
0 නිශ්චිතව දක්වා ඇත්නම්, පහත දැක්වෙන උපසර්ග පෙළ එක් එක් නිඛිලයක් බවට පරිවර්තනය වේ.
0b- ද්විමය ඉලක්කම්
0o- අෂ්ටක
0x- ෂඩ් දශම
l_sb = ['0011', '0101', '1111']
l_sb_i = [int(s, 2) for s in l_sb]
print(l_sb_i)
# [3, 5, 15]
l_sbox = ['100', '0b100', '0o77', '0xff']
l_sbox_i = [int(s, 0) for s in l_sbox]
print(l_sbox_i)
# [100, 4, 63, 255]
ඝාතීය අංකනයෙහි ඇති නූල් සංඛ්‍යාත්මක අගයන් වෙත පරිවර්තනය කරයි
ඝාතීය අංකනයෙහි ඇති තන්තු විශේෂ පිරිවිතර අවශ්‍යතාවයකින් තොරව float() සමඟ කෙලින්ම පරිවර්තනය කළ හැක.
l_se = ['1.23e3', '0.123e-1', '123']
l_se_f = [float(s) for s in l_se]
print(l_se_f)
# [1230.0, 0.0123, 123.0]
අංක බවට පරිවර්තනය කළ හැකි නූල් පමණක් පරිවර්තනය කරන්න
සංඛ්‍යාවකට int() හෝ float() වෙත පරිවර්තනය කළ නොහැකි තන්තුවක් පසුකිරීම ValueError එකක් ඇති කරයි.
දෝෂයක් මත අසත්‍යයක් ලබා දෙන නව ශ්‍රිතයක් නිර්වචනය කර ඇත්නම්, පරිවර්තනය කළ හැකි මූලද්‍රව්‍ය පමණක් සංඛ්‍යා බවට පරිවර්තනය කර ලැයිස්තුවේ මූලද්‍රව්‍ය බවට පත්විය හැකිය.
def is_int(s):
try:
int(s)
except ValueError:
return False
else:
return True
def is_float(s):
try:
float(s)
except ValueError:
return False
else:
return True
l_multi = ['-100', '100', '1.23', '1.23e2', 'one']
l_multi_i = [int(s) for s in l_multi if is_int(s)]
print(l_multi_i)
# [-100, 100]
l_multi_f = [float(s) for s in l_multi if is_float(s)]
print(l_multi_f)
# [-100.0, 100.0, 1.23, 123.0]
