बायनरी, ऑक्टल आणि हेक्साडेसिमल संख्या आणि स्ट्रिंग्सना पायथनमध्ये एकमेकांमध्ये रूपांतरित करा

व्यवसाय

पायथन बायनरी, ऑक्टल आणि हेक्साडेसिमल संख्या तसेच नेहमीच्या दशांश संख्या म्हणून संख्या आणि स्ट्रिंग हाताळू शकतो. त्यांच्यामध्ये रूपांतर करणे देखील सोपे आहे.

या विभागात, नमुना कोडसह खालील सामग्री स्पष्ट केली जाईल.

  • पूर्णांक बायनरी, ऑक्टल आणि हेक्साडेसिमलमध्ये लिहा.
  • बायनरी, ऑक्टल आणि हेक्साडेसिमल नोटेशनमधील संख्यांना स्ट्रिंगमध्ये रूपांतरित करा.
    • अंगभूत कार्य (उदा. प्रोग्रामिंग भाषेत)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

जरी उपसर्ग सह, प्रकार एक पूर्णांक 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(), f स्ट्रिंग

नकारात्मक मूल्यांसाठी दोनच्या पूरक स्वरूपात व्यक्त केलेली स्ट्रिंग कशी मिळवायची हे देखील हा विभाग स्पष्ट करतो.

अंगभूत फंक्शन्स बिन(), ऑक्ट(), हेक्स()

खालील बिल्ट-इन फंक्शन्स संख्यांना बायनरी, ऑक्टल आणि हेक्साडेसिमल स्ट्रिंगमध्ये रूपांतरित करू शकतात.

  • बायनरी संख्या: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:] वापरा किंवा पुढे स्पष्ट केल्याप्रमाणे format() वापरा.

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'>

अंगभूत फंक्शन फॉरमॅट(), स्ट्रिंग पद्धत str.format(), f स्ट्रिंग

बिल्ट-इन फंक्शन फॉरमॅट() आणि स्ट्रिंग पद्धती str.format() आणि f-स्ट्रिंग देखील संख्यांना बायनरी, ऑक्टल आणि हेक्साडेसिमल स्ट्रिंगमध्ये रूपांतरित करू शकतात.

खालीलप्रमाणे format() चे दुसरे वितर्क निर्दिष्ट करून, ते अनुक्रमे बायनरी, ऑक्टल आणि हेक्साडेसिमल स्ट्रिंगमध्ये रूपांतरित केले जाऊ शकते.

  • बायनरी संख्या: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() देखील रूपांतरणासाठी वापरली जाऊ शकते.

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

Python 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

Python मध्ये, ऋण पूर्णांकांवर बिटवाइज ऑपरेशन्स देखील दोनच्या पूरक प्रतिनिधित्वामध्ये केल्या जातात. म्हणून, जर तुम्हाला दोनच्या पूरक स्वरूपात व्यक्त केलेली स्ट्रिंग मिळवायची असेल, तर तुम्ही बिटवाइज लॉजिकल OR& आवश्यक बिट अंकांच्या कमाल संख्येसह, खालीलप्रमाणे.

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

बायनरी, ऑक्टल आणि हेक्साडेसिमल नोटेशनमधील स्ट्रिंग्सला संख्यांमध्ये रूपांतरित करा.

अंगभूत फंक्शन int()

बायनरी, ऑक्टल किंवा हेक्साडेसिमल नोटेशनमधील स्ट्रिंग एका संख्येमध्ये रूपांतरित करण्यासाठी, अंगभूत फंक्शन int() वापरा.

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), त्यावर ऑपरेशन्स करू शकता आणि नंतर ते पुन्हा स्ट्रिंगमध्ये रूपांतरित करू शकता.

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
Copied title and URL