पाइथनमा बाइनरी, अक्टल, र हेक्साडेसिमल नम्बरहरू र स्ट्रिङहरूलाई एकअर्कामा रूपान्तरण गर्नुहोस्

व्यापार

पाइथनले संख्याहरू र स्ट्रिङहरूलाई बाइनरी, अक्टल, र हेक्साडेसिमल सङ्ख्याका साथै सामान्य दशमलव सङ्ख्याहरूलाई ह्यान्डल गर्न सक्छ। तिनीहरू बीच रूपान्तरण गर्न पनि सजिलो छ।

यस खण्डमा, निम्न सामग्रीहरू नमूना कोडको साथ व्याख्या गरिनेछ।

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

पाइथन ३.६ बाट सुरु गर्दै, संख्याहरूमा अन्डरस्कोरहरू सम्मिलित गर्न सम्भव छ। एउटा अन्डरस्कोर _ दोहोर्याउँदा त्रुटि हुनेछ, तर तपाईंले यसलाई दोहोर्याउन नसकेसम्म तपाईं आफूले चाहेजति सम्मिलित गर्न सक्नुहुन्छ।

_ अन्डरस्कोरले संख्यालाई असर गर्दैन, त्यसैले धेरै अंकहरू हुँदा यसलाई विभाजकको रूपमा प्रयोग गर्न सकिन्छ। उदाहरणका लागि, प्रत्येक चार अंकमा अन्डरस्कोर _ सम्मिलित गर्न सजिलो छ।

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:] प्रयोग गर्नुहोस्, वा अर्को व्याख्या गरिए अनुसार ढाँचा() प्रयोग गर्नुहोस्।

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 string

बिल्ट-इन प्रकार्य ढाँचा() र स्ट्रिङ विधिहरू str.format() र f-string ले संख्याहरूलाई बाइनरी, अक्टल, र हेक्साडेसिमल स्ट्रिङहरूमा रूपान्तरण गर्न सक्छ।

निम्नानुसार 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

कुनै पनि अंकको साथ ० भर्न पनि सम्भव छ। याद गर्नुहोस् कि उपसर्ग (दुई क्यारेक्टरहरू) को लागि क्यारेक्टरहरूको संख्या पनि उपसर्गको साथ शून्य भर्दा खातामा लिनु पर्छ।

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

पाइथन ३.६ बाट सुरु गर्दै, तपाइँ 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

पाइथनमा, ऋणात्मक पूर्णाङ्कहरूमा बिटवाइज अपरेसनहरू दुईको पूरक प्रतिनिधित्वमा पनि गरिन्छ। त्यसकारण, यदि तपाइँ दुईको पूरक फारममा व्यक्त गरिएको स्ट्रिङ प्राप्त गर्न चाहनुहुन्छ भने, तपाइँ बिटवाइज तार्किक OR& निम्नानुसार आवश्यक बिट अंकहरूको अधिकतम संख्याको साथ।

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

बाइनरी, अक्टल, र हेक्साडेसिमल नोटेशनमा स्ट्रिङहरूलाई सङ्ख्याहरूमा रूपान्तरण गर्नुहोस्।

बिल्ट-इन प्रकार्य int()

बाइनरी, अक्टल, वा हेक्साडेसिमल नोटेशनमा स्ट्रिङलाई नम्बरमा रूपान्तरण गर्न, बिल्ट-इन प्रकार्य int() प्रयोग गर्नुहोस्।

int(string, 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'>

यदि मूलांक ० मा सेट गरिएको छ भने, निम्न स्ट्रिङ उपसर्गको आधारमा रूपान्तरण गरिन्छ।

  • बाइनरी उपसर्ग: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

यदि आधार संख्या ० छ र त्यहाँ कुनै उपसर्ग छैन भने, यसलाई दशमलव संख्याको रूपमा रूपान्तरण गरिनेछ, तर ध्यान दिनुहोस् कि यदि शुरुवात (बायाँ तर्फ) ० भरिएको छ भने, त्रुटि देखा पर्नेछ।

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

बाइनरी, अक्टल र हेक्साडेसिमल संख्याहरू बीच रूपान्तरण गर्नुहोस्

बाइनरी, अक्टल, र हेक्साडेसिमल स्ट्रिङहरूलाई एकअर्कामा रूपान्तरण गर्न पनि सजिलो छ। एक पटक संख्यात्मक int मा रूपान्तरण गरेपछि, यसलाई कुनै पनि ढाँचाको स्ट्रिङमा रूपान्तरण गर्न सकिन्छ।

शून्य-भरण, उपसर्ग, आदि ढाँचा विशिष्टता स्ट्रिङ द्वारा नियन्त्रण गर्न सकिन्छ।

a_0b = '0b1110001010011'

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

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