பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் எண்கள் மற்றும் சரங்களை ஒன்றுக்கொன்று மற்றும் பைத்தானில் மாற்றவும்

பைதான் எண்கள் மற்றும் சரங்களை பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் எண்களாகவும் வழக்கமான தசம எண்களாகவும் கையாள முடியும். அவற்றுக்கிடையே மாற்றுவதும் எளிது.

இந்தப் பிரிவில், மாதிரிக் குறியீட்டுடன் பின்வரும் உள்ளடக்கங்கள் விளக்கப்படும்.

• பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமலில் முழு எண்களை எழுதவும்.
• பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் குறியீட்டில் எண்களை சரங்களாக மாற்றவும்.
  • உள்ளமைக்கப்பட்ட செயல்பாடு (எ.கா. நிரலாக்க மொழியில்)bin(),oct(),hex()
  • சரம் முறைstr.format(), உள்ளமைந்த செயல்பாடுகள்format(), f சரம்
  • இருவரின் நிரப்பு வடிவத்தில் எதிர்மறை முழு எண்ணை சரமாக மாற்றவும்.
• பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் குறியீட்டில் உள்ள சரங்களை எண்களாக மாற்றவும்.
  • உள்ளமைக்கப்பட்ட செயல்பாடு (எ.கா. நிரலாக்க மொழியில்)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

முன்னொட்டுடன் கூட, வகை ஒரு முழு எண்ணாக இருக்கும்.

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

பைதான் 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 சரம்

எதிர்மறை மதிப்புகளுக்கு இரண்டு நிரப்பு வடிவத்தில் ஒரு சரத்தை எவ்வாறு பெறுவது என்பதையும் இந்தப் பகுதி விளக்குகிறது.

உள்ளமைக்கப்பட்ட செயல்பாடுகள் பின்(), oct(), hex()

பின்வரும் உள்ளமைக்கப்பட்ட செயல்பாடுகள் எண்களை பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் சரங்களாக மாற்றும்.

• பைனரி எண்:bin()
• எண்:oct()
• பதின்ம எண்:hex()

ஒவ்வொன்றும் பின்வரும் முன்னொட்டுகளுடன் ஒரு சரத்தை வழங்கும்

• பைனரி எண்:0b
• எண்:0o
• பதின்ம எண்:0x

• bin() — Built-in Functions — Python 3.10.0 Documentation
• oct() — Built-in Functions — Python 3.10.0 Documentation
• hex() — Built-in Functions — Python 3.10.0 Documentation

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() ஐப் பயன்படுத்தலாம்.

• str() — Built-in Functions — Python 3.10.0 Documentation

print(str(i))
# 255

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

உள்ளமைக்கப்பட்ட செயல்பாடு வடிவம்(), சரம் முறை str.format(), f சரம்

உள்ளமைக்கப்பட்ட செயல்பாடு வடிவம்() மற்றும் சரம் முறைகள் str.format() மற்றும் f-string ஆகியவை எண்களை பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் சரங்களாக மாற்றும்.

• format() — Built-in Functions — Python 3.10.0 Documentation

வடிவம்() இன் இரண்டாவது வாதத்தை பின்வருமாறு குறிப்பிடுவதன் மூலம், அதை முறையே பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் சரங்களாக மாற்றலாம்.

• பைனரி எண்: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 method str.format()ஐ மாற்றுவதற்கும் பயன்படுத்தலாம்.

• str.format() — Built-in Functions — Python 3.10.0 Documentation

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

பைதான் 3.6 இல் தொடங்கி, நீங்கள் f சரத்தையும் பயன்படுத்தலாம்.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

பைத்தானில், எதிர்மறை முழு எண்களில் பிட்வைஸ் செயல்பாடுகள் இரண்டின் நிரப்பு பிரதிநிதித்துவத்திலும் செய்யப்படுகின்றன. எனவே, இரண்டின் நிரப்பு வடிவத்தில் வெளிப்படுத்தப்பட்ட ஒரு சரத்தை நீங்கள் பெற விரும்பினால், நீங்கள் ஒரு பிட்வைஸ் லாஜிக்கல் அல்லது& பிட் இலக்கங்களின் அதிகபட்ச எண்ணிக்கையுடன், பின்வருமாறு.

• 4bit:0b1111（=0xf）
• 8bit:0xff
• 16bit:0xffff

print(bin(x & 0xff))
print(format(x & 0xffff, 'x'))
# 0b11110111
# fff7

பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் குறியீட்டில் உள்ள சரங்களை எண்களாக மாற்றவும்.

உள்ளமைக்கப்பட்ட செயல்பாடு int()

பைனரி, ஆக்டல் அல்லது ஹெக்ஸாடெசிமல் குறியீட்டில் உள்ள சரத்தை எண்ணாக மாற்ற, உள்ளமைக்கப்பட்ட செயல்பாடு int() ஐப் பயன்படுத்தவும்.

• int() — Built-in Functions — Python 3.10.0 Documentation

int(string, radix) உடன், பைனரி, ஆக்டல், ஹெக்ஸாடெசிமல் குறியீடு போன்றவற்றில் உள்ள ஒரு சரத்தை ரேடிக்ஸ் அடிப்படையில் எண் எண்ணாக மாற்றலாம். ரேடிக்ஸ் தவிர்க்கப்பட்டால், எண் தசமமாகக் கருதப்படுகிறது.

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 முன்னொட்டுடன் பைனரி குறியீட்டில் ஒரு சரத்தில் ஒரு செயல்பாட்டைச் செய்ய.

நீங்கள் அதை ஒரு எண் மதிப்பாக (முழு எண் வகை எண்ணாக) எளிதாக மாற்றலாம், அதில் செயல்பாடுகளைச் செய்யலாம், பின்னர் அதை மீண்டும் ஒரு சரத்திற்கு மாற்றலாம்.

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

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

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

பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் எண்களுக்கு இடையில் மாற்றவும்

பைனரி, ஆக்டல் மற்றும் ஹெக்ஸாடெசிமல் சரங்களை ஒன்றுக்கொன்று மாற்றுவதும் எளிதானது. எண் எண்ணாக மாற்றப்பட்டதும், அதை எந்த வடிவத்தின் சரமாக மாற்றலாம்.

பூஜ்ஜிய நிரப்புதல், முன்னொட்டு போன்றவற்றை வடிவமைத்தல் விவரக்குறிப்பு சரம் மூலம் கட்டுப்படுத்தலாம்.

a_0b = '0b1110001010011'

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

print(format(int(a, 0), '#010o'))
# 0o00000011