First of all, the above code you have pasted has lots of indentation issues, next time you should try to fix those indentation issues and running your program again, before posting it here.

Secondly, your logic is also wrong, you should not be checking -

while newNum == 1:

at start itself, you are setting newNum = decNum , unless you enter 1 , your program would not enter that while loop. The condition you need is -

while decNum != 0:

Secondly, the second while loop, should not be inside the first while loop, it should be outside, so that you print out the stack once all the computation is complete. Also , you don't even need the first newNum = decNum , before the loop starts.

I fixed all your indentation issues, and logical issues, the code is -

import sys
class Stack ():
    def __init__(self):
        self.items=[]
    def push (self,item):
        self.items.append(item)
    def pop (self):
        return self.items.pop()
    def size(self):
        return len(self.items)
s1= Stack()
decNum= int(raw_input("Enter the decimal num : "))
while decNum!=0:
    newNum= decNum%2
    decNum = decNum//2
    s1.push(newNum)
while s1.size() != 0:
    a=s1.pop()
    sys.stdout.write(str(a))
sys.stdout.flush()

In general, your idea is not bad.

The best solution, as far as I read, would be the algorithm Divide by 2 that uses a stack to keep track of the digits for the binary result.

As an intro, this algorithm assumes that we start with an integer greater than 0. A simple iteration then continually divides the decimal number by 2 and keeps track of the remainder.

The first division by 2 gives information as to whether the value is even or odd. An even value will have a remainder of 0. It will have the digit 0 in the ones place. An odd value will have a remainder of 1 and will have the digit 1 in the ones place. We think about building our binary number as a sequence of digits; the first remainder we compute will actually be the last digit in the sequence.

That said, we have:

from pythonds.basic.stack import Stack

def divideBy2(decNumber):
    remstack = Stack()

    while decNumber > 0:
        rem = decNumber % 2
        remstack.push(rem)
        decNumber = decNumber // 2

    binString = ""
    while not remstack.isEmpty():
        binString = binString + str(remstack.pop())

    return binString

print(divideBy2(42))

Comments regarding your code:

1. Why did you do this: dec_new = dec_number ? You could've just use dec_number. There's no need of assigning its value to another variable.
2. This: dec_new = dec_new // 2 could be as well as the above line of your code rewritten as: dec_new //= 2
3. The indentation should contain 4 spaces, not 2.

A version that better (than your solution) utilizes the memory would be:

def dec_to_bin(n):
    bits = []

    bits.append(str(0 if n%2 == 0 else 1))
    while n > 1:
        n = n // 2
        bits.append(str(0 if n%2 == 0 else 1))

    bits.reverse()
    return ''.join(bits)

What I did:

• floor divide all the numbers by two repeatedly until we reach 1
• going in reverse order, create bits of this array of numbers, if it is even, append a 0 and if it is odd append a 1.

Other ways of doing it:

Using recursion:

def dec_to_bin(x):
    return dec_to_bin(x/2) + [x%2] if x > 1 else [x]

The above solution returns the result as a list which you can later on .join() then apply int() to it.

Another idea that came to my mind is as simple as:

u = format(62, "08b")
>> 00111110

This may also work

def DecimalToBinary(number):
        #This function uses recursion to convert & print decimal to binary number
       if number > 1:
           convertToBinary(number//2)
       print(number % 2,end = '')

    # decimal number
    decimal = 34

    convertToBinary(decimal)
    #..........................................
    #it will show output as 110100

You can probably use the builtin bin function:

bin(8) #'0b1000'

to get the list:

[int(x) for x in bin(8)[2:]]

Although it seems like there's probably a better way...

all numbers are stored in binary. if you want a textual representation of a given number in binary, use bin(i)

>>> bin(10)
'0b1010'
>>> 0b1010
10