पायथन में बाइनरी, ऑक्टल और हेक्साडेसिमल नंबरों और स्ट्रिंग्स को एक दूसरे से कन्वर्ट करें

पायथन संख्याओं और तारों को बाइनरी, ऑक्टल और हेक्साडेसिमल संख्याओं के साथ-साथ सामान्य दशमलव संख्याओं के रूप में संभाल सकता है। उनके बीच कनवर्ट करना भी आसान है।

इस खंड में, निम्नलिखित सामग्री को नमूना कोड के साथ समझाया जाएगा।

• बाइनरी, ऑक्टल और हेक्साडेसिमल में पूर्णांक लिखें।
• बाइनरी, ऑक्टल और हेक्साडेसिमल नोटेशन में संख्याओं को स्ट्रिंग में बदलें।
  • अंतर्निहित फ़ंक्शन (जैसे प्रोग्रामिंग भाषा में)bin(),oct(),hex()
  • स्ट्रिंग विधिstr.format(), अंतर्निहित कार्यformat(), एफ स्ट्रिंग
  • एक ऋणात्मक पूर्णांक को दो के पूरक प्रारूप में एक स्ट्रिंग में बदलें।
• बाइनरी, ऑक्टल और हेक्साडेसिमल नोटेशन में स्ट्रिंग्स को संख्याओं में बदलें।
  • अंतर्निहित फ़ंक्शन (जैसे प्रोग्रामिंग भाषा में)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

पायथन 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(), एफ स्ट्रिंग

यह खंड यह भी बताता है कि नकारात्मक मानों के लिए दो के पूरक प्रारूप में व्यक्त की गई स्ट्रिंग कैसे प्राप्त करें।

अंतर्निहित कार्य बिन (), अक्टूबर (), हेक्स ()

निम्नलिखित अंतर्निहित फ़ंक्शन संख्याओं को बाइनरी, ऑक्टल और हेक्साडेसिमल स्ट्रिंग्स में बदल सकते हैं।

• बाइनरी संख्या: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

स्ट्रिंग विधि 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() — Built-in Functions — Python 3.10.0 Documentation

इंट (स्ट्रिंग, रेडिक्स) के साथ, बाइनरी, ऑक्टल, हेक्साडेसिमल नोटेशन आदि में एक स्ट्रिंग स्ट्र को रेडिक्स के आधार पर एक संख्यात्मक इंट में परिवर्तित किया जा सकता है। यदि मूलांक को हटा दिया जाता है, तो संख्या को दशमलव माना जाता है।

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) में परिवर्तित कर सकते हैं, इस पर संचालन कर सकते हैं, और फिर इसे फिर से एक स्ट्रिंग 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