बेस -2 बाइनरी नंबर स्ट्रिंग को इंट में कन्वर्ट करें

Question

मैं बस एक आधार -2 बाइनरी नंबर स्ट्रिंग को इंट में बदलना चाहता हूं, कुछ इस तरह से:

>>> '11111111'.fromBinaryToInt()
255

क्या पायथन में ऐसा करने का कोई तरीका है?

Comments

हालांकि यह वास्तव में कोई फर्क नहीं पड़ता है, एक बाइनरी स्ट्रिंग का मतलब आमतौर पर वास्तविक बाइनरी डेटा युक्त एक स्ट्रिंग होता है (एक बाइट में दो हेक्साडेसिमल अंक होते हैं, अर्थात "\ x00" एक शून्य बाइट है)।

— trevorKirkby

Answer 1

आप बिल्ट-इन intफ़ंक्शन का उपयोग करते हैं , और इसे इनपुट नंबर का आधार बनाते हैं, अर्थात 2बाइनरी नंबर के लिए:

>>> int('11111111', 2)
255

यहाँ python2 के लिए प्रलेखन है , और python3 के लिए ।

Comments

मामले में किसी के सामने की तलाश में है: bin(255)-> '0b11111111'। देखें इस जवाब पर जाएं।

— अक्सेली पैलेन

यह ध्यान दिया जाना चाहिए कि यह केवल अहस्ताक्षरित बाइनरी पूर्णांक के लिए काम करता है। हस्ताक्षरित पूर्णांक के लिए, रूपांतरण विकल्प एक गड़बड़ है।

— फेक नेम

अजगर 3 में यह कैसे करें?

— सारस आर्य

@ सरसराया यह बहुत समान है! :) मैंने अपडेट किया, ऊपर देखें।

— खोलना

और ध्यान दें कि एक इंटरैक्टिव आरईपीएल सत्र (जैसा कि >>>प्रॉम्प्ट द्वारा सुझाया गया है ), आपको बिल्कुल भी उपयोग करने की आवश्यकता नहीं है print। ओपी का काल्पनिक उदाहरण नहीं था। तो यह वास्तव में अजगर 2 और 3 में समान होना चाहिए

— जॉन वाई

Answer 2

अजगर इंटरएक्टिव इंटरफ़ेस में बस 0b11111111 टाइप करें:

>>> 0b11111111
    255

Answer 3

bitstringमॉड्यूल का उपयोग करके ऐसा करने का एक और तरीका है :

>>> from bitstring import BitArray
>>> b = BitArray(bin='11111111')
>>> b.uint
255

ध्यान दें कि अहस्ताक्षरित पूर्णांक हस्ताक्षरित पूर्णांक से अलग है:

>>> b.int
-1

bitstringमॉड्यूल एक आवश्यकता नहीं है, लेकिन यह अन्य रूपों में में और बिट्स से इनपुट मोड़ है, साथ ही उन्हें जोड़ तोड़ के लिए performant तरीकों की बहुत सारी है।

Answer 4

आधार के साथ इंट का उपयोग करना सही तरीका है। मैं यह करने से पहले मुझे लगता था कि int भी आधार लेता है। यह मूल रूप से द्विआधारी को दशमलव में परिवर्तित करने के आदिम तरीके की सूची समझ (जैसे 110 = 2 ** 0 * 0 + 2 ** 1 * 1 + 2 ** 2 * 1) पर लागू किया गया एक कम है।

add = lambda x,y : x + y
reduce(add, [int(x) * 2 ** y for x, y in zip(list(binstr), range(len(binstr) - 1, -1, -1))])

Comments

इसके बजाय परिभाषित करने की add = lambda x, y: x + y, int.__add__कम करने के लिए प्रदान किया जा सकता। उदाreduce(int.__add__, ...)

— जॉर्डन जांबाज़ोव

Answer 5

यदि आप यह जानना चाहते हैं कि दृश्य के पीछे क्या हो रहा है, तो यहां आप जाएं।

class Binary():
def __init__(self, binNumber):
    self._binNumber = binNumber
    self._binNumber = self._binNumber[::-1]
    self._binNumber = list(self._binNumber)
    self._x = [1]
    self._count = 1
    self._change = 2
    self._amount = 0
    print(self._ToNumber(self._binNumber))
def _ToNumber(self, number):
    self._number = number
    for i in range (1, len (self._number)):
        self._total = self._count * self._change
        self._count = self._total
        self._x.append(self._count)
    self._deep = zip(self._number, self._x)
    for self._k, self._v in self._deep:
        if self._k == '1':
            self._amount += self._v
    return self._amount
mo = Binary('101111110')

Answer 6

एक पुनरावर्ती पायथन कार्यान्वयन:

def int2bin(n):
    return int2bin(n >> 1) + [n & 1] if n > 1 else [1] 

Answer 7

यदि आप python3.6 का उपयोग कर रहे हैं या बाद में आप रूपांतरण करने के लिए f-string का उपयोग कर सकते हैं:

बाइनरी टू दशमलव:

>>> print(f'{0b1011010:#0}')
90

>>> bin_2_decimal = int(f'{0b1011010:#0}')
>>> bin_2_decimal
90

अष्टाधारी हेक्सा और आदि के लिए द्विआधारी।

>>> f'{0b1011010:#o}'
'0o132'  # octal

>>> f'{0b1011010:#x}'
'0x5a'   # hexadecimal

>>> f'{0b1011010:#0}'
'90'     # decimal

बृहदान्त्र द्वारा अलग की गई जानकारी के 2 टुकड़े पर ध्यान दें।

इस प्रकार, आप उपनिवेश के दाईं ओर बदलकर {बाइनरी, ऑक्टल, हेक्साडेसिमल, दशमलव} से {बाइनरी, ऑक्टल, हेक्साडेसिमल, दशमलव} के बीच परिवर्तित कर सकते हैं [:]

:#b -> converts to binary
:#o -> converts to octal
:#x -> converts to hexadecimal 
:#0 -> converts to decimal as above example

अष्ट / हेक्साडेसिमल / दशमलव के लिए बृहदान्त्र के बाईं ओर बदलने का प्रयास करें।

Answer 8

बड़े मैट्रिक्स (10 ** 5 पंक्तियों और ऊपर) के लिए एक वेक्टर मैट्मूल का उपयोग करना बेहतर होता है। एक शॉट में सभी पंक्तियों और कॉलों में पास करें। यह बेहद तेज है। यहां अजगर में लूपिंग नहीं है। मैंने मूल रूप से इसे कई बाइनरी कॉलम को 0/1 की तरह बदलने के लिए डिज़ाइन किया था, जैसे मूवीलेन में 10 अलग-अलग जॉनर कॉलम को एक उदाहरण पूर्ण पंक्ति के लिए एक पूर्णांक में।

def BitsToIntAFast(bits):
  m,n = bits.shape
  a = 2**np.arange(n)[::-1]  # -1 reverses array of powers of 2 of same length as bits
  return bits @ a