Converting a decimal integer (denary, base 10) to a binary string (base 2) is amazingly simple. An exception is raised for negative numbers and zero is a special case. To test the result, the binary string is converted back to the decimal value, easily done with the int(bStr, 2) function.

# convert a decimal (denary, base 10) integer to a binary string (base 2)
# tested with Python24   vegaseat    6/1/2005

def Denary2Binary(n):
    '''convert denary integer n to binary string bStr'''
    bStr = ''
    if n < 0:  raise ValueError, "must be a positive integer"
    if n == 0: return '0'
    while n > 0:
        bStr = str(n % 2) + bStr
        n = n >> 1
    return bStr

def int2bin(n, count=24):
    """returns the binary of integer n, using count number of digits"""
    return "".join([str((n >> y) & 1) for y in range(count-1, -1, -1)])

# this test runs when used as a standalone program, but not as an imported module
# let's say you save this module as den2bin.py and use it in another program
# when you import den2bin the __name__ namespace would now be  den2bin  and the
# test would be ignored
if __name__ == '__main__':
    print Denary2Binary(255)  # 11111111
    
    # convert back to test it
    print int(Denary2Binary(255), 2)  # 255
    
    print
    
    # this version formats the binary
    print int2bin(255, 12)  # 000011111111
    # test it
    print int("000011111111", 2)  # 255
    
    print

    # check the exceptions
    print Denary2Binary(0)
    print Denary2Binary(-5)  # should give a ValueError

Well...if you are a newbie (like me), here is another solution, although not the best (A better way is certainly the first one on this page).( indentation lost after pasting it here. indent appropriately for the code to work)

#!/usr/bin/env python
import dectobin #Module...defined later
import string #Module.....defined later
a=int(raw_input("Enter a decimal number: "))
if a<0:
print "Try entering a positive number/0 "
elif a==0:
print "Binary: 0"
else:
list=dectobin.conv(a)
list1=string.format(list)
print "Binary: " ,list1

#!/usr/bin/env python
#This function takes an integer as arguement and returns binary equivalent as a list
def conv(a):
bin=[] #Define an empty list which will hold binary values
while(a!=1): #You want to keep dividing your integer with 2 until the quotient becomes 1
b=a%2 #Ccollect remainder.....it will be either 0 or 1
bin.append(b) # Hold this value in the empty list defined earlier
a=a/2

bin.append(1) #The last 1 which will remain after successive division
return bin
#!/usr/bin/env python
def format(list):
j=" " # Define an empty string
for i in range(0,len(list)): # list will have the binary values separated by comma
s=repr(list) #Change each integer to string
j=j+s #Add it to an empty string
j=j[::-1] #Reverse the string
return j

Edited 6 Years Ago by armored saint: Formatting lost while copying

Here's a simple version using the bin() builtin while giving the same formatting options as the original example. Everyone has their own version of this, yet I still have yet to find a place where a string of the binary version of a number is useful.

def binary(n, digits=8):
    rep = bin(n)[2:]
    return ('0' * (digits - len(rep))) + rep

About the formatting in the previous example, you can also use the format operator

def binary(n, digits=8):
    return "{0:0>{1}}".format(bin(n)[2:], digits)

See this snippet about the marvels of format().

Edited 6 Years Ago by Gribouillis: n/a

Lambda always intrigues me:

# works with IronPython, Python2 and Python3

d = 255
# a recursive dec to bin function
d2b = lambda d: (not isinstance(d,int) or (d==0)) and '0' \
    or (d2b(d//2)+str(d%2))

print(d2b(d))  # 011111111

@ vegaseat: Thank you. Are you also vegasclimb?

@GothAlice:

"where string of the binary version is useful"?
For generating 1D fractals: http://tatetech.blogspot.com/2011/08/generating-1d-quasi-sierpinski-fractal.html

#!/usr/bin/python   

                                                                              
""" make1DFractalBin.py                                                        

    arg1 = Natural(for order of fractal)        

    arg2 = Natural(in 512 -- 527, 576 -- 591, 640 -- 655, 704 --719,

         768 -- 783, 832 -- 847, 896 -- 911, 960 -- 975)  for mask)

    Generates a 1D fractal of order N,     

    where the fractal generated by 975 is   

    1. removing the middle third of each segment 

    2. stretching by 3                 

    equivalent to more complicated make1DFractal.py Natural 

"""


import sys

# convert a decimal integer to a binary string (base 2)

# tested with Python24 vegaseat 6/1/2005                

#                                                                              

def Denary2Binary(n):

  """convert denary integer n to binary string bStr"""

  bStr = ''

  if n < 0: raise ValueError, "must be a positive integer"

  if n == 0: return '0'

  while n > 0:

    bStr = str(n % 2) + bStr

    n = n >> 1

  return bStr 

  #                                  

def main():

  maskDec = 975 # generator for Sierpinski square  

  #Read commandline argument for order of fractal         

  if len(sys.argv) < 2:

    print "usage: $ python make1DFractalBin.py Natural(Order of fractal) [Natur\

al](default = 975, else see top of file for allowed generators)"

    sys.exit(2)

  else:

    order = int(sys.argv[1])

    print "Order of Fractal ordered: ", order, '\n'

    if len(sys.argv) ==3:

      maskDec = int(sys.argv[2])


  print "Generator = ", maskDec

  maskB = Denary2Binary(maskDec)

  print "Mask = \n",maskB


  iter = 0

  while iter < order:

    l = len(maskB)-1

""" multiply the mask by 2**(twice its binary length), and add its original value. This is equivalent to stretching it and removing middle third.

"""

    maskDec = maskDec*((3-1)**(2*l)) + maskDec

    maskB = Denary2Binary(maskDec)

    print maskB

    iter+=1


if __name__ == '__main__':

  main()

For order 2 and generator 975 we get:

rtate-mn:paths rtate$ python make1DFractalBin.py 2 975

Order of Fractal ordered: 2


Generator = 975

Mask =

1111001111

1111001111000000001111001111

1111001111000000001111001111000000000000000000000000001111001111000000001111001111

Now all I have to do is "square it"!

A rather straightforward one-liner to do the same thing:

>>> bin(10)[2:].rjust(8, '0')
'00001010'

A rather straightforward one-liner to do the same thing:

>>> bin(10)[2:].rjust(8, '0')
'00001010'

It's true, only in 2005 we were with python 2.4 which had no bin() function. Also it's useful for beginners to see how one can implement bin() in pure python. It is a classical exercise in programming to display numbers in a different basis.

Edited 5 Years Ago by Gribouillis: n/a

The article starter has earned a lot of community kudos, and such articles offer a bounty for quality replies.