आप पाइथन में बाइनरी अक्षर कैसे व्यक्त करते हैं?

पाइथन शब्दशः के साथ बाइनरी संख्या के रूप में आप एक पूर्णांक कैसे व्यक्त करते हैं?

मैं आसानी से हेक्स के लिए जवाब खोजने में सक्षम था:

>>> 0x12AF
4783
>>> 0x100
256

और ऑक्टल:

>>> 01267
695
>>> 0100
64

पाइथन में बाइनरी व्यक्त करने के लिए आप अक्षर का उपयोग कैसे करते हैं?


उत्तर का सारांश

  • पायथन 2.5 और इससे पहले: int ('01010101111', 2) का उपयोग करके बाइनरी व्यक्त कर सकते हैं लेकिन शाब्दिक के साथ नहीं।
  • पायथन 2.5 और इससे पहले: द्विआधारी अक्षरों को व्यक्त करने के लिए कोई रास्ता नहीं है।
  • पायथन 2.6 बीटा: आप ऐसा कर सकते हैं: 0b1100111 या 0B1100111
  • पायथन 2.6 बीटा: एक ऑक्टल का प्रतिनिधित्व करने के लिए 0o27 या 0O27 (दूसरा अक्षर अक्षर ओ) भी अनुमति देगा।
  • पायथन 3.0 बीटा: 2.6 के समान है, लेकिन अब octals के लिए पुराने 027 वाक्यविन्यास की अनुमति नहीं देगा।
0
जोड़ा संपादित
विचारों: 1

6 उत्तर

>>> print int('01010101111',2)
687
>>> print int('11111111',2)
255

दूसरा रास्ता।

0
जोड़ा
यह आपके लिए स्ट्रिंग्स के लिए दिलचस्प है, लेकिन यदि शुद्ध संख्याओं के साथ काम करते हैं, तो आप कोड में अनावश्यक गणना जोड़ते हैं।
जोड़ा लेखक Daniel Möller, स्रोत

मुझे यकीन है कि यह पाइथन 3.0 में परिवर्तन के कारण चीजों में से एक है, शायद बिन() हेक्स() और oct() के साथ जाने के लिए।

संपादित करें: सभी मामलों में lbrandy का जवाब सही है।

0
जोड़ा

As far as I can tell Python, up through 2.5, only supports hexadecimal & octal literals. I did find some discussions about adding binary to future versions but nothing definite.

0
जोड़ा

आप पाइथन में बाइनरी अक्षर कैसे व्यक्त करते हैं?

वे "बाइनरी" अक्षर नहीं हैं, बल्कि, "पूर्णांक अक्षर" हैं। आप एक 0 या b के बाद एक बाइनरी प्रारूप के साथ पूर्णांक अक्षरों को अभिव्यक्त कर सकते हैं, इसके बाद शून्य और एक श्रृंखला की श्रृंखला के बाद, उदाहरण के लिए :

>>> 0b0010101010
170
>>> 0B010101
21

पायथन 3 दस्तावेज़ से, ये पूर्णांक प्रदान करने के तरीके हैं पायथन में अक्षर:

पूर्ण शब्दावली परिभाषाओं द्वारा पूर्णांक अक्षरों का वर्णन किया गया है:

 integer :: = decinteger | bininteger | octinteger | hexinteger
decinteger :: = nonzerodigit (["_"] अंक) * | "0" + (["_"] "0") *
bininteger :: = "0" ("बी" | "बी") (["_"] bindigit) +
octinteger :: = "0" ("ओ" | "ओ") (["_"] octdigit) +
हेक्सिनटेगर :: = "0" ("एक्स" | "एक्स") (["_"] हेक्सडिजिट) +
nonzerodigit :: = "1" ... "9"
अंक :: = "0" ... "9"
bindigit :: = "0" | "1"
octdigit :: = "0" ... "7"
हेक्सडिजिट :: = अंक | "ए" ... "एफ" | 'ए' ... 'एफ'
 
     

इसके अलावा पूर्णांक अक्षर की लंबाई के लिए कोई सीमा नहीं है   उपलब्ध स्मृति में संग्रहीत किया जा सकता है।

     

ध्यान दें कि गैर-शून्य दशमलव संख्या में अग्रणी शून्यों की अनुमति नहीं है।   यह सी-स्टाइल ऑक्टल अक्षरों, जो पायथन के साथ असंबद्धता के लिए है   संस्करण 3.0 से पहले उपयोग किया जाता है।

     

पूर्णांक अक्षर के कुछ उदाहरण:

  7 2147483647 0o177 0b100110111
3 79228162514264337593543950336 0o377 0xdeadbeef
      100_000_000_000 0b_1110_0101
 
     

संस्करण 3.6 में बदला गया: अंडरस्कोर को अब अक्षरों में समूहबद्ध उद्देश्यों के लिए अनुमति दी गई है।

बाइनरी व्यक्त करने के अन्य तरीके:

आपके पास एक स्ट्रिंग ऑब्जेक्ट में शून्य और एक हो सकते हैं जिसे छेड़छाड़ की जा सकती है (हालांकि आपको ज्यादातर मामलों में पूर्णांक पर केवल बिटवाई ऑपरेशंस करना चाहिए) - बस शून्य और स्ट्रिंग की स्ट्रिंग को पास करें और जिस आधार से आप कनवर्ट कर रहे हैं (2 ):

>>> int('010101', 2)
21

आप वैकल्पिक रूप से 0b या 0B उपसर्ग कर सकते हैं:

>>> int('0b0010101010', 2)
170

यदि आप इसे आधार के रूप में 0 पास करते हैं, तो यह स्ट्रिंग 10 को मान लेगा यदि स्ट्रिंग उपसर्ग के साथ निर्दिष्ट नहीं है:

>>> int('10101', 0)
10101
>>> int('0b10101', 0)
21

इंट बैक से मानव पठनीय बाइनरी में कनवर्ट करना:

बाइनरी शाब्दिक के स्ट्रिंग प्रस्तुति को देखने के लिए आप बिन को एक पूर्णांक पास कर सकते हैं:

>>> bin(21)
'0b10101'

और आप पीछे और आगे जाने के लिए bin और int को जोड़ सकते हैं:

>>> bin(int('010101', 2))
'0b10101'

यदि आप पिछले शून्यों के साथ न्यूनतम चौड़ाई रखना चाहते हैं, तो आप प्रारूप विनिर्देश का भी उपयोग कर सकते हैं:

>>> format(int('010101', 2), '{fill}{width}b'.format(width=10, fill=0))
'0000010101'
>>> format(int('010101', 2), '010b')
'0000010101'
0
जोड़ा

For reference—future Python possibilities:
Starting with Python 2.6 you can express binary literals using the prefix 0b or 0B:

>>> 0b101111
47

आप किसी संख्या के बाइनरी प्रतिनिधित्व प्राप्त करने के लिए नए bin फ़ंक्शन का भी उपयोग कर सकते हैं:

>>> bin(173)
'0b10101101'

Development version of the documentation: What's New in Python 2.6

0
जोड़ा

शुरुआत में 0 निर्दिष्ट करता है कि आधार 8 (10 नहीं) है, जो देखने में बहुत आसान है:

>>> int('010101', 0)
4161

यदि आप 0 से शुरू नहीं करते हैं, तो पायथन मानता है कि संख्या आधार 10 है।

>>> int('10101', 0)
10101
0
जोड़ा