See also this other snippet

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[i]) #Change each integer to string
j=j+s #Add it to an empty string
j=j[::-1] #Reverse the string
return j

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().

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.