పైథాన్‌లో బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంఖ్యలు మరియు స్ట్రింగ్‌లను ఒకదానికొకటి మార్చండి

పైథాన్ సంఖ్యలు మరియు స్ట్రింగ్‌లను బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంఖ్యలు అలాగే సాధారణ దశాంశ సంఖ్యలుగా నిర్వహించగలదు. వాటి మధ్య మార్చడం కూడా సులభం.

ఈ విభాగంలో, నమూనా కోడ్‌తో పాటు క్రింది విషయాలు వివరించబడతాయి.

• బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్‌లలో పూర్ణాంకాలను వ్రాయండి.
• బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంజ్ఞామానంలో సంఖ్యలను స్ట్రింగ్‌లుగా మార్చండి.
  • అంతర్నిర్మిత ఫంక్షన్ (ఉదా. ప్రోగ్రామింగ్ భాషలో)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 స్ట్రింగ్

ప్రతికూల విలువల కోసం రెండు పూరక ఆకృతిలో వ్యక్తీకరించబడిన స్ట్రింగ్‌ను ఎలా పొందాలో కూడా ఈ విభాగం వివరిస్తుంది.

అంతర్నిర్మిత విధులు bin(), 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-స్ట్రింగ్ కూడా సంఖ్యలను బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ స్ట్రింగ్‌లుగా మార్చగలవు.

• 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

స్ట్రింగ్ పద్ధతి 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

ప్రతికూల పూర్ణాంకాన్ని రెండు పూరక ఆకృతిలో స్ట్రింగ్‌గా మార్చండి.

ప్రతికూల పూర్ణాంకాన్ని బిన్() లేదా ఫార్మాట్() ఉపయోగించి బైనరీ లేదా హెక్సాడెసిమల్ స్ట్రింగ్‌గా మార్చినప్పుడు, సంపూర్ణ విలువ మైనస్ గుర్తును కలిగి ఉంటుంది.

x = -9

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

పైథాన్‌లో, ప్రతికూల పూర్ణాంకాలపై బిట్‌వైస్ కార్యకలాపాలు కూడా రెండు పూరక ప్రాతినిధ్యంలో నిర్వహించబడతాయి. కాబట్టి, మీరు రెండు పూరక రూపంలో వ్యక్తీకరించబడిన స్ట్రింగ్‌ని పొందాలనుకుంటే, మీరు బిట్‌వైస్ లాజికల్ లేదా OR& కింది విధంగా అవసరమైన గరిష్ట సంఖ్యలో బిట్ అంకెలతో.

• 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)తో, బైనరీ, ఆక్టల్, హెక్సాడెసిమల్ సంజ్ఞామానం మొదలైనవాటిలో స్ట్రింగ్ strను రాడిక్స్ ఆధారంగా సంఖ్యా పూర్ణాంకానికి మార్చవచ్చు. రాడిక్స్ విస్మరించబడితే, ఆ సంఖ్య దశాంశంగా పరిగణించబడుతుంది.

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 ఉపసర్గతో బైనరీ సంజ్ఞామానంలో స్ట్రింగ్‌పై ఆపరేషన్ చేయడానికి.

మీరు దానిని సంఖ్యా విలువకు సులభంగా మార్చవచ్చు (పూర్ణాంకం రకం పూర్ణాంకం), దానిపై కార్యకలాపాలను నిర్వహించి, ఆపై దాన్ని మళ్లీ స్ట్రింగ్ strకి మార్చవచ్చు.

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