Python හි ද්විමය, අෂ්ටක සහ ෂඩ් දශම සංඛ්‍යා සහ නූල් එකිනෙක වෙතට සහ ඉන් පිටතට පරිවර්තනය කරන්න

ව්යාපාරික

Python හට ද්විමය, අෂ්ටක සහ ෂඩ් දශම සංඛ්‍යා මෙන්ම සාමාන්‍ය දශම සංඛ්‍යා ලෙස සංඛ්‍යා සහ නූල් හැසිරවිය හැක. ඒවා අතර පරිවර්තනය කිරීම ද පහසුය.

මෙම කොටසෙහි, නියැදි කේතය සමඟ පහත අන්තර්ගතය පැහැදිලි කරනු ඇත.

  • ද්විමය, අෂ්ටක සහ ෂඩ් දශම වලින් පූර්ණ සංඛ්‍යා ලියන්න.
  • ද්විමය, අෂ්ටක සහ ෂඩ් දශම අංකනය තුළ සංඛ්‍යා නූල් බවට පරිවර්තනය කරන්න.
    • බිල්ට්-ඉන් ශ්‍රිතය (උදා. ක්‍රමලේඛන භාෂාවෙන්)bin(),oct(),hex()
    • නූල් ක්රමයstr.format(), බිල්ට් ක්‍රියාකාරකම්format(), f string
    • සෘණ පූර්ණ සංඛ්‍යාවක් තන්තුවකට දෙකක අනුපූරක ආකෘතියෙන් පරිවර්තනය කරන්න.
  • ද්විමය, අෂ්ටක සහ ෂඩ් දශම අංකවල ඇති නූල් සංඛ්‍යා බවට පරිවර්තනය කරන්න.
    • බිල්ට්-ඉන් ශ්‍රිතය (උදා. ක්‍රමලේඛන භාෂාවෙන්)int()
  • යෙදුම් උදාහරණ
    • ද්විමය නූල් අංක ගණිතය
    • ද්විමය, අෂ්ටක සහ ෂඩ් දශම සංඛ්‍යා අතර පරිවර්තනය කරන්න

ද්විමය, අෂ්ටක සහ ෂඩ් දශම වලින් පූර්ණ සංඛ්‍යා ලියන්න.

පහත උපසර්ග එකතු කිරීමෙන්, නිඛිල int සංඛ්‍යා පිළිවෙලින් ද්විමය, අෂ්ටක සහ ෂඩ් දශම වලින් ලිවිය හැක.
ඔබට විශාල අකුරු ද භාවිතා කළ හැකිය.

  • ද්විමය අංකය:0bහෝ0B
  • අෂ්ටක:0oහෝ0O
  • ෂඩාස්රාකාර අංකය:0xහෝ0X

මුද්‍රණ() හි ප්‍රතිදානය දශම අංකනය වනු ඇත.

bin_num = 0b10
oct_num = 0o10
hex_num = 0x10

print(bin_num)
print(oct_num)
print(hex_num)
# 2
# 8
# 16


Bin_num = 0B10
Oct_num = 0O10
Hex_num = 0X10

print(Bin_num)
print(Oct_num)
print(Hex_num)
# 2
# 8
# 16

උපසර්ගය සමඟ වුවද, වර්ගය නිඛිල int වේ.

print(type(bin_num))
print(type(oct_num))
print(type(hex_num))
# <class 'int'>
# <class 'int'>
# <class 'int'>

print(type(Bin_num))
print(type(Oct_num))
print(type(Hex_num))
# <class 'int'>
# <class 'int'>
# <class 'int'>

එය පූර්ණ සංඛ්‍යා වර්ගයක් බැවින් එය සාමාන්‍ය අංක ගණිත මෙහෙයුම් සඳහා භාවිතා කළ හැක.

result = 0b10 * 0o10 + 0x10
print(result)
# 32

Python 3.6 සමඟින් පටන්ගෙන, ඉලක්කම් වලින් යටි ඉරි _ ඇතුලත් කල හැක. යටි ඉරි _ නැවත නැවත කිරීම දෝෂයක් ඇති කරයි, නමුත් ඔබ එය නැවත නොකරන තාක් දුරට ඔබට කැමති ප්‍රමාණයක් ඇතුළත් කළ හැක.

_ යටි ඉරි අංකයට බලපාන්නේ නැත, එබැවින් එය බොහෝ ඉලක්කම් ඇති විට එය බෙදුම්කරුවෙකු ලෙස භාවිතා කළ හැක. උදාහරණයක් ලෙස, සෑම ඉලක්කම් හතරකටම _ යටි ඉරි ඇතුළත් කිරීම කියවීමට පහසුය.

print(0b111111111111 == 0b1_1_1_1_1_1_1_1_1_1_1_1)
# True

bin_num = 0b1111_1111_1111
print(bin_num)
# 4095

ද්විමය, අෂ්ටක සහ ෂඩ් දශම අංකනය තුළ සංඛ්‍යා නූල් බවට පරිවර්තනය කරන්න.

ද්විමය, අෂ්ටක හෝ ෂඩ් දශම අංකනයකින් සංඛ්‍යාවක් තන්තුවක් බවට පරිවර්තනය කිරීමට, පහත බිල්ට් ශ්‍රිත භාවිතා කරන්න.

  • බිල්ට්-ඉන් ශ්‍රිතය (උදා. ක්‍රමලේඛන භාෂාවෙන්)bin(),oct(),hex()
  • නූල් ක්රමයstr.format(), බිල්ට් ක්‍රියාකාරකම්format(), f string

සෘණ අගයන් සඳහා දෙකේ අනුපූරක ආකෘතියෙන් ප්‍රකාශිත තන්තුවක් ලබා ගන්නේ කෙසේද යන්න ද මෙම කොටසේ පැහැදිලි කරයි.

බිල්ට්-ඉන් ශ්‍රිත bin(), oct(), hex()

පහත බිල්ට්-ඉන් ශ්‍රිතවලට සංඛ්‍යා ද්විමය, අෂ්ටක සහ ෂඩ් දශම තන්තු බවට පරිවර්තනය කළ හැක.

  • ද්විමය අංකය:bin()
  • අෂ්ටක:oct()
  • ෂඩාස්රාකාර අංකය:hex()

සෑම එකක්ම පහත උපසර්ග සහිත තන්තුවක් ලබා දෙයි

  • ද්විමය අංකය:0b
  • අෂ්ටක:0o
  • ෂඩාස්රාකාර අංකය:0x
i = 255

print(bin(i))
print(oct(i))
print(hex(i))
# 0b11111111
# 0o377
# 0xff

print(type(bin(i)))
print(type(oct(i)))
print(type(hex(i)))
# <class 'str'>
# <class 'str'>
# <class 'str'>

ඔබට උපසර්ගය අවශ්‍ය නැතිනම්, එය පිටුපසින් ඇති තන්තුව උකහා ගැනීමට පෙත්තක්[2:] භාවිතා කරන්න, නැතහොත් ඊළඟට පැහැදිලි කර ඇති පරිදි ආකෘතිය() භාවිතා කරන්න.

print(bin(i)[2:])
print(oct(i)[2:])
print(hex(i)[2:])
# 11111111
# 377
# ff

ඔබට එය දශම තන්තුවකට පරිවර්තනය කිරීමට අවශ්‍ය නම්, ඔබට str() භාවිතා කළ හැක.

print(str(i))
# 255

print(type(str(i)))
# <class 'str'>

Built-in function format(), string method str.format(), f string

බිල්ට්-ඉන් ක්‍රියාකාරී ආකෘතිය() සහ str.format() සහ f-string යන තන්තු ක්‍රම මඟින් සංඛ්‍යා ද්විමය, අෂ්ටක සහ ෂඩාස්‍ර තන්තු බවට පරිවර්තනය කළ හැක.

ආකෘතිය() හි දෙවන තර්කය පහත පරිදි දැක්වීමෙන්, එය පිළිවෙළින් ද්විමය, අෂ්ටක සහ ෂඩාස්‍ර තන්තු බවට පරිවර්තනය කළ හැක.

  • ද්විමය අංකය:b
  • අෂ්ටක:o
  • ෂඩාස්රාකාර අංකය:x
print(format(i, 'b'))
print(format(i, 'o'))
print(format(i, 'x'))
# 11111111
# 377
# ff

print(type(format(i, 'b')))
print(type(format(i, 'o')))
print(type(format(i, 'x')))
# <class 'str'>
# <class 'str'>
# <class 'str'>

ඔබට 0b,0o,0x උපසර්ගය සහිත තන්තුවක් ලබා ගැනීමට අවශ්‍ය නම්, හැඩතල ගැන්වීමේ පිරිවිතර තන්තුවට # එකතු කරන්න.

print(format(i, '#b'))
print(format(i, '#o'))
print(format(i, '#x'))
# 0b11111111
# 0o377
# 0xff

ඕනෑම ඉලක්කම් ගණනකින් 0 පිරවිය හැකිය. උපසර්ගයක් සමඟ ශුන්‍යය පිරවීමේදී උපසර්ගය සඳහා අක්ෂර ගණන (අක්ෂර දෙකක්) ද සැලකිල්ලට ගත යුතු බව සලකන්න.

print(format(i, '08b'))
print(format(i, '08o'))
print(format(i, '08x'))
# 11111111
# 00000377
# 000000ff

print(format(i, '#010b'))
print(format(i, '#010o'))
print(format(i, '#010x'))
# 0b11111111
# 0o00000377
# 0x000000ff

string ක්‍රමය str.format() පරිවර්තනය සඳහා ද භාවිතා කළ හැක.

print('{:08b}'.format(i))
print('{:08o}'.format(i))
print('{:08x}'.format(i))
# 11111111
# 00000377
# 000000ff

Python 3.6 සමඟින් පටන් ගෙන, ඔබට f string ද භාවිතා කළ හැක.f'xxx'

print(f'{i:08b}')
print(f'{i:08o}')
print(f'{i:08x}')
# 11111111
# 00000377
# 000000ff

සෘණ පූර්ණ සංඛ්‍යාවක් තන්තුවකට දෙකක අනුපූරක ආකෘතියෙන් පරිවර්තනය කරන්න.

bin() හෝ format() භාවිතයෙන් සෘණ නිඛිලයක් ද්විමය හෝ ෂඩ් දශම තන්තුවකට පරිවර්තනය කළ විට නිරපේක්ෂ අගයට සෘණ ලකුණක් ඇත.

x = -9

print(x)
print(bin(x))
# -9
# -0b1001

Python හි, සෘණ නිඛිල මත bitwise මෙහෙයුම් ද දෙකේ අනුපූරක නියෝජනය තුළ සිදු කෙරේ. එමනිසා, ඔබට දෙකේ අනුපූරක ආකාරයෙන් ප්‍රකාශිත තන්තුවක් ලබා ගැනීමට අවශ්‍ය නම්, ඔබට bitwise logical OR& අවශ්‍ය උපරිම බිටු ඉලක්කම් සංඛ්‍යාව සමඟ, පහත පරිදි.

  • 4bit:0b1111（=0xf）
  • 8bit:0xff
  • 16bit:0xffff
print(bin(x & 0xff))
print(format(x & 0xffff, 'x'))
# 0b11110111
# fff7

ද්විමය, අෂ්ටක සහ ෂඩ් දශම අංකවල ඇති නූල් සංඛ්‍යා බවට පරිවර්තනය කරන්න.

බිල්ට්-ඉන් ශ්‍රිතය int()

ද්විමය, අෂ්ටක හෝ ෂඩ් දශම අංකනයක ඇති තන්තුවක් සංඛ්‍යාවක් බවට පරිවර්තනය කිරීමට, int() හි ඇති ශ්‍රිතය භාවිතා කරන්න.

int(string, radix) සමඟින්, ද්විමය, අෂ්ටක, ෂඩාස්‍ර අංකනය, යනාදී string str radix මත පදනම්ව සංඛ්‍යාත්මක int බවට පරිවර්තනය කළ හැක. රේඩික්ස් ඉවත් කර ඇත්නම්, අංකය දශම ලෙස සලකනු ලැබේ.

print(int('10'))
print(int('10', 2))
print(int('10', 8))
print(int('10', 16))
# 10
# 2
# 8
# 16

print(type(int('10')))
print(type(int('10', 2)))
print(type(int('10', 8)))
print(type(int('10', 16)))
# <class 'int'>
# <class 'int'>
# <class 'int'>
# <class 'int'>

රේඩික්ස් 0 ලෙස සකසා ඇත්නම්, පහත දැක්වෙන තන්තු උපසර්ගය මත පදනම්ව පරිවර්තනය සිදු කෙරේ.

  • ද්විමය උපසර්ගය:0bහෝ0B
  • අෂ්ටක උපසර්ගය:0oහෝ0O
  • ෂඩාස්රාකාර උපසර්ගය:0xහෝ0X
print(int('0b10', 0))
print(int('0o10', 0))
print(int('0x10', 0))
# 2
# 8
# 16

print(int('0B10', 0))
print(int('0O10', 0))
print(int('0X10', 0))
# 2
# 8
# 16

පාදක අංකය 0 නම් සහ උපසර්ගය නොමැති නම්, එය දශම අංකයක් ලෙස පරිවර්තනය කරනු ඇත, නමුත් ආරම්භය (වම් පැත්ත) 0 වලින් පුරවා ඇත්නම්, දෝෂයක් ඇති වන බව සලකන්න.

print(int('10', 0))
# 10

# print(int('010', 0))
# ValueError: invalid literal for int() with base 0: '010'

වෙනත් අවස්ථා වලදී, ශුන්‍ය පිරවූ නූල් එලෙසම පරිවර්තනය කළ හැක.

print(int('010'))
# 10

print(int('00ff', 16))
print(int('0x00ff', 0))
# 255
# 255

නිශ්චිත රේඩික්ස් හෝ උපසර්ගය සමඟ තන්තුව පරිවර්තනය කළ නොහැකි නම්, දෝෂයක් සිදු වේ.

# print(int('ff', 2))
# ValueError: invalid literal for int() with base 2: 'ff'

# print(int('0a10', 0))
# ValueError: invalid literal for int() with base 0: '0a10'

# print(int('0bff', 0))
# ValueError: invalid literal for int() with base 0: '0bff'

යෙදුම් උදාහරණ

ද්විමය නූල් අංක ගණිතය

උදාහරණයක් ලෙස, උපසර්ගය 0b සමඟ ද්විමය අංකනය තුළ තන්තුවක් මත මෙහෙයුමක් සිදු කිරීමට.

ඔබට එය පහසුවෙන් සංඛ්‍යාත්මක අගයකට පරිවර්තනය කළ හැකිය (පූර්ණ සංඛ්‍යා වර්ගය int), එය මත මෙහෙයුම් සිදු කරන්න, ඉන්පසු එය නැවත string str එකක් බවට පරිවර්තනය කරන්න.

a = '0b1001'
b = '0b0011'

c = int(a, 0) + int(b, 0)

print(c)
print(bin(c))
# 12
# 0b1100

ද්විමය, අෂ්ටක සහ ෂඩ් දශම සංඛ්‍යා අතර පරිවර්තනය කරන්න

ද්විමය, අෂ්ටක සහ ෂඩ් දශම තන්තු එකිනෙකට පරිවර්තනය කිරීම ද පහසුය. සංඛ්‍යාත්මක int බවට පරිවර්තනය කළ පසු, එය ඕනෑම ආකෘතියක තන්තුවකට පරිවර්තනය කළ හැකිය.

ශුන්‍ය පිරවීම, උපසර්ගය ආදිය හැඩතල ගැන්වීමේ පිරිවිතර පෙළ මඟින් පාලනය කළ හැක.

a_0b = '0b1110001010011'

print(format(int(a, 0), '#010x'))
# 0x00000009

print(format(int(a, 0), '#010o'))
# 0o00000011
Copied title and URL