बाइनरी, ऑक्टल और हेक्साडेसिमल में

बाइनरी, ऑक्टल और हेक्साडेसिमल के बारे में

बाइनरी, ऑक्टल और हेक्साडेसिमल (जिसे हेक्स भी कहते हैं) अलग-अलग आधारों वाली अलग-अलग संख्या पद्धतियाँ हैं। बाइनरी का आधार 2 है, ऑक्टल का 8 और हेक्साडेसिमल का 16। Python में आम पूर्णांक आधार 10 के होते हैं। बाइनरी, ऑक्टल और हेक्साडेसिमल, ये तीनों पूर्णांकों के अलग-अलग रूप हैं। यानी ये धनात्मक और ऋणात्मक संख्याएँ (शून्य समेत) बिना भिन्न या दशमलव के दर्शाते हैं, और जो भी संक्रियाएँ हम पूर्णांकों पर कर सकते हैं, वे सब इन पर भी होती हैं।

बाइनरी

बाइनरी आधार 2 की संख्या पद्धति है, जिसमें सिर्फ अंक 0 और 1 इस्तेमाल होते हैं। यह आम तौर पर कंप्यूटर के ट्रांजिस्टर और स्विच से गुज़रने वाली बिजली के 0 ("बंद") और 1 ("चालू") वाले प्रवाह की स्थितियों को दर्शाती है, और चुंबकीय भंडारण माध्यमों के धनात्मक व ऋणात्मक आवेशों को भी। बाइनरी वे सभी पूर्णांक दर्शा सकती है जो आधार 10 में इस्तेमाल होते हैं।

आधार 2 पद्धति का एक हिस्सा कुछ ऐसा दिखता है, हालाँकि यह अनंत तक चलती है और 128 पर रुकती नहीं:

तो अगर हमें संख्या 6 को बाइनरी में लिखना हो, तो वह 110 होगी।

और संक्रिया यह होगी: 4 + 2 + 0 = 6

एक और उदाहरण: 19

बाइनरी संख्या यह होगी: 10011 और संक्रिया यह होगी: 16 + 0 + 0 + 2 + 1 = 19

Python में बाइनरी

Python में हम 0b उपसर्ग लगाकर बाइनरी लिटरल लिख सकते हैं। अगर हम 0b10011 लिखें, तो Python इसे बाइनरी संख्या मानकर उसे आधार 10 में बदल देगा।

>>> 0b10011
19

>>> type(0b10011)
<class 'int'>

Python में बाइनरी, पूर्णांक लिखने का बस एक अलग तरीका है, इसलिए सभी गणितीय संक्रियाओं के लिए बाइनरी रूप पूर्णांक ही होता है।

अगर आप 0b उपसर्ग के साथ कोई ऐसी संख्या लिखें जो बाइनरी पद्धति में नहीं है, तो SyntaxError एरर मिलेगी।

Traceback (most recent call last):
  File "c:\binary.py", line 1, in <module>
    0b10211
SyntaxError: invalid digit '2' in binary literal

बाइनरी संख्याओं के साथ संक्रियाएँ

चूँकि बाइनरी संख्याएँ पूर्णांक होती हैं, इसलिए हम इन पर वे सभी संक्रियाएँ कर सकते हैं जो हम पूर्णांकों के साथ कर सकते हैं।

# addition
>>> 0b10011 + 0b10011
38

# multiplication
>>> 0b10011 * 0b10011
361

हम बाइनरी और पूर्णांक, दोनों रूपों के बीच भी संक्रियाएँ कर सकते हैं। लेकिन गणित के ऑपरेटर के आम नियम यहाँ भी लागू होते हैं: दो बाइनरी संख्याओं या दो पूर्णांकों को भाग देने पर float ही लौटता है, चाहे भाग का नतीजा दशमलव-रहित ही क्यों न हो।

>>> 0b10011 + 19
38

>>> 0b10011/0b10011
1.0

>>> 0b10011/3
6.333333333333333

बाइनरी रूप में बदलना और वापस बदलना

Python बाइनरी लिटरल को अपने आप int में बदल देता है। किसी int को बाइनरी रूप में बदलने के लिए पहले से मौजूद [bin()][bin] फंक्शन इस्तेमाल कीजिए। bin() बाइनरी रूप की एक str लौटाता है, जिसके आगे 0b उपसर्ग लगा होता है।

>>> bin(19)
'0b10011'

किसी बाइनरी लिटरल को पूर्णांक में बदलने के लिए हम पहले से मौजूद int() फंक्शन इस्तेमाल कर सकते हैं, और उसे बाइनरी रूप की एक स्ट्रिंग तथा आधार वाला आर्गुमेंट दे सकते हैं:

>>> int("0b10011", 2)
19

गलत आधार देने पर (या अमान्य बाइनरी रूप देने पर) ValueError एरर मिलेगी:

Traceback (most recent call last):
  File "c:\binary.py", line 4, in <module>
    int("0b10011", 3)
ValueError: invalid literal for int() with base 3: '0b10011'

बाइनरी मेथड

कुछ खास मेथड भी हैं जिन्हें हम बाइनरी संख्याओं पर इस्तेमाल कर सकते हैं।

<int>.bit_length() उतने बिट लौटाता है जितने उस संख्या को दर्शाने के लिए चाहिए:

>>> 0b11011.bit_length()
5

<int>.bit_count() बाइनरी संख्या में कितने एक हैं, यह लौटाता है। जैसे '0b11011' पर bit_count() 4 लौटाएगा:

>>> 0b11011.bit_count()
4

ऑक्टल

ऑक्टल आधार 8 की संख्या पद्धति है। इसमें अंक 0, 1, 2, 3, 4, 5, 6 और 7 इस्तेमाल होते हैं।

Python में हम 0o उपसर्ग लगाकर ऑक्टल संख्याएँ लिख सकते हैं। बाइनरी की तरह ही, Python ऑक्टल रूप को अपने आप int में बदल देता है।

>>> 0o123
83

बाइनरी की तरह, ऑक्टल संख्याएँ भी पूर्णांक ही होती हैं और उन पर पूर्णांक की सारी संक्रियाएँ हो सकती हैं। किसी ऐसी संख्या के आगे 0o लगाने पर, जो ऑक्टल पद्धति में नहीं है, SyntaxError एरर मिलेगी।

ऑक्टल रूप में बदलना और वापस बदलना

किसी int को ऑक्टल रूप में बदलने के लिए आप पहले से मौजूद [oct()][oct] फंक्शन इस्तेमाल कर सकते हैं। यह bin() फंक्शन की तरह ही काम करता है और एक स्ट्रिंग लौटाता है:

>>> oct(83)
'0o123'

किसी ऑक्टल संख्या को पूर्णांक में बदलने के लिए हम int() फंक्शन इस्तेमाल कर सकते हैं, और उसे ऑक्टल रूप की एक स्ट्रिंग तथा आधार (8) आर्गुमेंट के रूप में दे सकते हैं:

>>> int("0o123", 8)
83

बाइनरी की तरह, गलत आधार देने पर ValueError एरर मिलेगी।

हेक्साडेसिमल

हेक्साडेसिमल आधार 16 की संख्या पद्धति है। इसमें अंक 0 से 9 और अक्षर A, B, C, D, E तथा F इस्तेमाल होते हैं। A का मतलब 10, B का 11, C का 12, D का 13, E का 14 और F का 15 है।

Python में हम 0x उपसर्ग लगाकर हेक्साडेसिमल संख्याएँ लिख सकते हैं। बाइनरी और ऑक्टल की तरह, Python हेक्साडेसिमल लिटरल को अपने आप int में बदल देता है।

>>> 0x123
291

बाइनरी और ऑक्टल की तरह, हेक्साडेसिमल लिटरल भी पूर्णांक ही होते हैं, और आप उन पर पूर्णांक की सारी संक्रियाएँ कर सकते हैं। किसी गैर-हेक्साडेसिमल संख्या के आगे 0x लगाने पर SyntaxError एरर मिलेगी।

हेक्साडेसिमल रूप में बदलना और वापस बदलना

किसी int को हेक्साडेसिमल रूप में बदलने के लिए आप पहले से मौजूद [hex()][hex] फंक्शन इस्तेमाल कर सकते हैं। यह bin() फंक्शन की तरह ही काम करता है और एक स्ट्रिंग लौटाता है:

>>> hex(291)
'0x123'

किसी हेक्साडेसिमल रूप को पूर्णांक में बदलने के लिए हम int() फंक्शन इस्तेमाल कर सकते हैं, और उसे एक हेक्साडेसिमल स्ट्रिंग तथा आधार (16) आर्गुमेंट के रूप में दे सकते हैं:

>>> int("0x123", 16)
291

बाइनरी और ऑक्टल की तरह, गलत आधार देने पर ValueError एरर मिलेगी।