software - python tutorial pdf

Numpy पैक / unpackbits का उपयोग, वे आपके सबसे अच्छे दोस्त हैं।

Examples
--------
>>> a = np.array([[2], [7], [23]], dtype=np.uint8)
>>> a
array([[ 2],
       [ 7],
       [23]], dtype=uint8)
>>> b = np.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 1, 1, 1],
       [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)

ऐसा करने का एक आसान तरीका स्ट्रिंग प्रारूप का उपयोग करना है, यह पृष्ठ देखें।

>> "{0:b}".format(10)
'1010'

और यदि आप बाइनरी स्ट्रिंग की निश्चित लंबाई चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

>> "{0:{fill}8b}".format(10, fill='0')
'00001010'

यदि दो पूरक की आवश्यकता है, तो निम्नलिखित पंक्ति का उपयोग किया जा सकता है:

'{0:{fill}{width}b}'.format((x + 2**n) % 2**n, fill='0', width=n)

जहां एन बाइनरी स्ट्रिंग की चौड़ाई है।

कुछ हद तक समान समाधान

def to_bin(dec):
    flag = True
    bin_str = ''
    while flag:
        remainder = dec % 2
        quotient = dec / 2
        if quotient == 0:
            flag = False
        bin_str += str(remainder)
        dec = quotient
    bin_str = bin_str[::-1] # reverse the string
    return bin_str 

डीईसी, बिन, हेक्स के लिए सभी आवश्यक कार्यों के साथ कैलक्यूलेटर: (पायथन 3.5 के साथ बनाया और परीक्षण)

आप इनपुट टेस्ट नंबर बदल सकते हैं और कनवर्ट किए गए हैं।

# CONVERTER: DEC / BIN / HEX

def dec2bin(d):
    # dec -> bin
    b = bin(d)
    return b

def dec2hex(d):
    # dec -> hex
    h = hex(d)
    return h

def bin2dec(b):
    # bin -> dec
    bin_numb="{0:b}".format(b)
    d = eval(bin_numb)
    return d,bin_numb

def bin2hex(b):
    # bin -> hex
    h = hex(b)
    return h

def hex2dec(h):
    # hex -> dec
    d = int(h)
    return d

def hex2bin(h):
    # hex -> bin
    b = bin(h)
    return b


## TESTING NUMBERS
numb_dec = 99
numb_bin = 0b0111 
numb_hex = 0xFF


## CALCULATIONS
res_dec2bin = dec2bin(numb_dec)
res_dec2hex = dec2hex(numb_dec)

res_bin2dec,bin_numb = bin2dec(numb_bin)
res_bin2hex = bin2hex(numb_bin)

res_hex2dec = hex2dec(numb_hex)
res_hex2bin = hex2bin(numb_hex)



## PRINTING
print('------- DECIMAL to BIN / HEX -------\n')
print('decimal:',numb_dec,'\nbin:    ',res_dec2bin,'\nhex:    ',res_dec2hex,'\n')

print('------- BINARY to DEC / HEX -------\n')
print('binary: ',bin_numb,'\ndec:    ',numb_bin,'\nhex:    ',res_bin2hex,'\n')

print('----- HEXADECIMAL to BIN / HEX -----\n')
print('hexadec:',hex(numb_hex),'\nbin:    ',res_hex2bin,'\ndec:    ',res_hex2dec,'\n')

पाइथन वास्तव में इसके लिए पहले से ही कुछ बनाया गया है, '{0:b}'.format(42) जैसे '{0:b}'.format(42) करने की क्षमता '{0:b}'.format(42) , जो आपको 42 , या 101010 लिए थोड़ा पैटर्न 101010 ।

एक और सामान्य दर्शन के लिए, कोई भी भाषा या पुस्तकालय अपने उपयोगकर्ता आधार को वह सब कुछ नहीं देगा जो वे चाहते हैं। यदि आप एक envronment में काम कर रहे हैं जो आपको बिल्कुल वही प्रदान नहीं करता है, तो आपको कोड के स्निपेट एकत्र करना चाहिए क्योंकि आप यह सुनिश्चित करने के लिए विकसित होते हैं कि आपको कभी भी दो बार एक ही चीज़ लिखनी पड़ेगी। जैसे, उदाहरण के लिए:

def int2bin(i):
    if i == 0: return "0"
    s = ''
    while i:
        if i & 1 == 1:
            s = "1" + s
        else:
            s = "0" + s
        i /= 2
    return s

जो दशमलव मान के आधार पर आपकी बाइनरी स्ट्रिंग का निर्माण करेगा, मानते हुए कि पाइथन के पास पहले से ही एक आसान तरीका नहीं था।

सामान्य विचार कोड का उपयोग करना है (वरीयता के क्रम में):

• भाषा या अंतर्निर्मित पुस्तकालयों।
• उपयुक्त लाइसेंस के साथ तीसरे पक्ष के पुस्तकालय।
• आपका खुद का संग्रह
• कुछ नया लिखने की जरूरत है (और बाद में अपने संग्रह में सहेजें)।

बिटवाई ऑपरेटरों का उपयोग करके, एक और एल्गोरिदम के साथ एक और समाधान।

def int2bin(val):
    res=''
    while val>0:
        res += str(val&1)
        val=val>>1     # val=val/2 
    return res[::-1]   # reverse the string

स्ट्रिंग को उलट किए बिना एक तेज़ संस्करण।

def int2bin(val):
   res=''
   while val>0:
       res = chr((val&1) + 0x30) + res
       val=val>>1    
   return res 

यदि आप "शुद्ध" पायथन छोड़ने के इच्छुक हैं लेकिन बहुत सारी फायरपावर हासिल करते हैं, तो ऋषि है - उदाहरण यहां :

sage: a = 15
sage: a.binary()
'1111'

आप ध्यान दें कि यह एक स्ट्रिंग के रूप में लौटाता है, इसलिए इसे उस नंबर के रूप में उपयोग करने के लिए जिसे आप कुछ करना चाहते हैं

sage: eval('0b'+b)
15

यदि आप bin() के समतुल्य bin() तलाश में हैं, तो इसे पायथन 2.6 में जोड़ा गया था।

उदाहरण:

>>> bin(10)
'0b1010'

यहां कोड है जिसे मैंने अभी लागू किया है। यह एक विधि नहीं है लेकिन आप इसे उपयोग में आसान फ़ंक्शन के रूप में उपयोग कर सकते हैं!

def inttobinary(number):
  if number == 0:
    return str(0)
  result =""
  while (number != 0):
      remainder = number%2
      number = number/2
      result += str(remainder)
  return result[::-1] # to invert the string

यहां नियमित गणित का उपयोग करने का एक और तरीका है, कोई लूप नहीं, केवल रिकर्सन। (मामूली मामला 0 कुछ भी नहीं देता है)।

def toBin(num):
  if num == 0:
    return ""
  return toBin(num//2) + str(num%2)

print ([(toBin(i)) for i in range(10)])

['', '1', '10', '11', '100', '101', '110', '111', '1000', '1001']

यूसुफ याज़ीसी के जवाब के समान रेखा के साथ

def intToBin(n):
    if(n < 0):
        print "Sorry, invalid input."
    elif(n == 0):
        print n
    else:
        result = ""
        while(n != 0):
            result += str(n%2)
            n /= 2
        print result[::-1]

मैंने इसे समायोजित किया ताकि एकमात्र परिवर्तनीय उत्परिवर्तित किया जा सके (और निश्चित रूप से एन)।

यदि आपको कहीं और इस फ़ंक्शन का उपयोग करने की आवश्यकता है (यानी, परिणाम दूसरे मॉड्यूल द्वारा उपयोग किया गया है), निम्न समायोजन पर विचार करें:

def intToBin(n):
    if(n < 0):
        return -1
    elif(n == 0):
        return str(n)
    else:
        result = ""
        while(n != 0):
            result += str(n%2)
            n /= 2
        return result[::-1]

तो -1 आपका प्रेषित मान होगा जो रूपांतरण को इंगित करता है। (यह माना जाता है कि आप केवल सकारात्मक संख्याओं को परिवर्तित कर रहे हैं, चाहे वे पूर्णांक हों या लंबे हों)।

संदर्भ के रूप में:

def toBinary(n):
    return ''.join(str(1 & int(n) >> i) for i in range(64)[::-1])

यह फ़ंक्शन एक सकारात्मक पूर्णांक को 18446744073709551615 जितना बड़ा रूपांतरित कर सकता है, जिसे स्ट्रिंग '1111111111111111111111111111111111111111111111111111111111111111' रूप में दर्शाया गया है।

इसे एक बहुत बड़ा पूर्णांक प्रदान करने के लिए संशोधित किया जा सकता है, हालांकि यह "{0:b}".format() या bin() रूप में आसान नहीं हो सकता है।

लैम्ब्डा के साथ एक लाइनर:

>>> binary = lambda n: '' if n==0 else binary(n/2) + str(n%2)

परीक्षा:

>>> binary(5)
'101'

संपादित करें :

परन्तु फिर :(

t1 = time()
for i in range(1000000):
     binary(i)
t2 = time()
print(t2 - t1)
# 6.57236599922

की तुलना में

t1 = time()
for i in range(1000000):
    '{0:b}'.format(i)
t2 = time()
print(t2 - t1)
# 0.68017411232

n=input()
print(bin(n).replace("0b", ""))

try:
    while True:
        p = ""
        a = input()
        while a != 0:
            l = a % 2
            b = a - l
            a = b / 2
            p = str(l) + p
        print(p)
except:
    print ("write 1 number")